diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index 55d20255c9..ff261bad78 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -3,7 +3,7 @@ FROM mcr.microsoft.com/vscode/devcontainers/python:0-${VARIANT}
 
 USER vscode
 
-RUN curl -sSf https://rye.astral.sh/get | RYE_VERSION="0.35.0" RYE_INSTALL_OPTION="--yes" bash
+RUN curl -sSf https://rye.astral.sh/get | RYE_VERSION="0.44.0" RYE_INSTALL_OPTION="--yes" bash
 ENV PATH=/home/vscode/.rye/shims:$PATH
 
 RUN echo "[[ -d .venv ]] && source .venv/bin/activate || export PATH=\$PATH" >> /home/vscode/.bashrc
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d0e0ffe2f3..4c617a6f19 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,18 +1,23 @@
 name: CI
 on:
   push:
-    branches:
-      - main
+    branches-ignore:
+      - 'generated'
+      - 'codegen/**'
+      - 'integrated/**'
+      - 'stl-preview-head/**'
+      - 'stl-preview-base/**'
   pull_request:
-    branches:
-      - main
+    branches-ignore:
+      - 'stl-preview-head/**'
+      - 'stl-preview-base/**'
 
 jobs:
   lint:
+    timeout-minutes: 10
     name: lint
-    runs-on: ubuntu-latest
-    if: github.repository == 'openai/openai-python'
-
+    runs-on: ${{ github.repository == 'stainless-sdks/openai-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
     steps:
       - uses: actions/checkout@v4
 
@@ -21,7 +26,7 @@ jobs:
           curl -sSf https://rye.astral.sh/get | bash
           echo "$HOME/.rye/shims" >> $GITHUB_PATH
         env:
-          RYE_VERSION: '0.35.0'
+          RYE_VERSION: '0.44.0'
           RYE_INSTALL_OPTION: '--yes'
 
       - name: Install dependencies
@@ -30,11 +35,51 @@ jobs:
       - name: Run lints
         run: ./scripts/lint
 
+  build:
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
+    timeout-minutes: 10
+    name: build
+    permissions:
+      contents: read
+      id-token: write
+    runs-on: ${{ github.repository == 'stainless-sdks/openai-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rye
+        run: |
+          curl -sSf https://rye.astral.sh/get | bash
+          echo "$HOME/.rye/shims" >> $GITHUB_PATH
+        env:
+          RYE_VERSION: '0.44.0'
+          RYE_INSTALL_OPTION: '--yes'
+
+      - name: Install dependencies
+        run: rye sync --all-features
+
+      - name: Run build
+        run: rye build
+
+      - name: Get GitHub OIDC Token
+        if: github.repository == 'stainless-sdks/openai-python'
+        id: github-oidc
+        uses: actions/github-script@v6
+        with:
+          script: core.setOutput('github_token', await core.getIDToken());
+
+      - name: Upload tarball
+        if: github.repository == 'stainless-sdks/openai-python'
+        env:
+          URL: https://pkg.stainless.com/s
+          AUTH: ${{ steps.github-oidc.outputs.github_token }}
+          SHA: ${{ github.sha }}
+        run: ./scripts/utils/upload-artifact.sh
+
   test:
+    timeout-minutes: 10
     name: test
-    runs-on: ubuntu-latest
-    if: github.repository == 'openai/openai-python'
-
+    runs-on: ${{ github.repository == 'stainless-sdks/openai-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
     steps:
       - uses: actions/checkout@v4
 
@@ -43,7 +88,7 @@ jobs:
           curl -sSf https://rye.astral.sh/get | bash
           echo "$HOME/.rye/shims" >> $GITHUB_PATH
         env:
-          RYE_VERSION: '0.35.0'
+          RYE_VERSION: '0.44.0'
           RYE_INSTALL_OPTION: '--yes'
 
       - name: Bootstrap
@@ -53,8 +98,10 @@ jobs:
         run: ./scripts/test
 
   examples:
+    timeout-minutes: 10
     name: examples
-    runs-on: ubuntu-latest
+    runs-on: ${{ github.repository == 'stainless-sdks/openai-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
+    if: github.repository == 'openai/openai-python' && (github.event_name == 'push' || github.event.pull_request.head.repo.fork)
 
     steps:
       - uses: actions/checkout@v4
@@ -64,17 +111,17 @@ jobs:
           curl -sSf https://rye.astral.sh/get | bash
           echo "$HOME/.rye/shims" >> $GITHUB_PATH
         env:
-          RYE_VERSION: '0.35.0'
+          RYE_VERSION: '0.44.0'
           RYE_INSTALL_OPTION: '--yes'
       - name: Install dependencies
         run: |
           rye sync --all-features
 
-      - env: 
+      - env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
         run: |
             rye run python examples/demo.py
-      - env: 
+      - env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
         run: |
             rye run python examples/async_demo.py
diff --git a/.github/workflows/create-releases.yml b/.github/workflows/create-releases.yml
index 2a97049033..b3e1c679d4 100644
--- a/.github/workflows/create-releases.yml
+++ b/.github/workflows/create-releases.yml
@@ -28,7 +28,7 @@ jobs:
           curl -sSf https://rye.astral.sh/get | bash
           echo "$HOME/.rye/shims" >> $GITHUB_PATH
         env:
-          RYE_VERSION: '0.35.0'
+          RYE_VERSION: '0.44.0'
           RYE_INSTALL_OPTION: '--yes'
 
       - name: Publish to PyPI
diff --git a/.github/workflows/detect-breaking-changes.yml b/.github/workflows/detect-breaking-changes.yml
new file mode 100644
index 0000000000..f10fdf3b19
--- /dev/null
+++ b/.github/workflows/detect-breaking-changes.yml
@@ -0,0 +1,42 @@
+name: CI
+on:
+  pull_request:
+    branches:
+      - main
+      - next
+
+jobs:
+  detect_breaking_changes:
+    runs-on: 'ubuntu-latest'
+    name: detect-breaking-changes
+    if: github.repository == 'openai/openai-python'
+    steps:
+      - name: Calculate fetch-depth
+        run: |
+          echo "FETCH_DEPTH=$(expr ${{ github.event.pull_request.commits }} + 1)" >> $GITHUB_ENV
+
+      - uses: actions/checkout@v4
+        with:
+          # Ensure we can check out the pull request base in the script below.
+          fetch-depth: ${{ env.FETCH_DEPTH }}
+
+      - name: Install Rye
+        run: |
+          curl -sSf https://rye.astral.sh/get | bash
+          echo "$HOME/.rye/shims" >> $GITHUB_PATH
+        env:
+          RYE_VERSION: '0.44.0'
+          RYE_INSTALL_OPTION: '--yes'
+      - name: Install dependencies
+        run: |
+          rye sync --all-features
+      - name: Detect removed symbols
+        run: |
+          rye run python scripts/detect-breaking-changes.py "${{ github.event.pull_request.base.sha }}"
+
+      - name: Detect breaking changes
+        run: |
+          # Try to check out previous versions of the breaking change detection script. This ensures that
+          # we still detect breaking changes when entire files and their tests are removed.
+          git checkout "${{ github.event.pull_request.base.sha }}" -- ./scripts/detect-breaking-changes 2>/dev/null || true
+          ./scripts/detect-breaking-changes ${{ github.event.pull_request.base.sha }}
\ No newline at end of file
diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml
index 76d0efca80..32bd6929e2 100644
--- a/.github/workflows/publish-pypi.yml
+++ b/.github/workflows/publish-pypi.yml
@@ -18,7 +18,7 @@ jobs:
           curl -sSf https://rye.astral.sh/get | bash
           echo "$HOME/.rye/shims" >> $GITHUB_PATH
         env:
-          RYE_VERSION: '0.35.0'
+          RYE_VERSION: '0.44.0'
           RYE_INSTALL_OPTION: '--yes'
 
       - name: Publish to PyPI
diff --git a/.gitignore b/.gitignore
index 8779740800..55c6ca861f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
 .prism.log
-.vscode
 _dev
 
 __pycache__
@@ -14,3 +13,7 @@ dist
 .envrc
 codegen.log
 Brewfile.lock.json
+
+.DS_Store
+
+examples/*.mp3
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 6d3d57b7ab..108509ed29 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
 {
-  ".": "1.66.3"
+  ".": "2.8.1"
 }
\ No newline at end of file
diff --git a/.stats.yml b/.stats.yml
index edc2aaf89f..fe1a09be6b 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,2 +1,4 @@
-configured_endpoints: 81
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-c8579861bc21d4d2155a5b9e8e7d54faee8083730673c4d32cbbe573d7fb4116.yml
+configured_endpoints: 136
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai%2Fopenai-a7e92d12ebe89ca019a7ac5b29759064eefa2c38fe08d03516f2620e66abb32b.yml
+openapi_spec_hash: acbc703b2739447abc6312b2d753631c
+config_hash: b876221dfb213df9f0a999e75d38a65e
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000..5b01030785
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "python.analysis.importFormat": "relative",
+}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e799f6d117..1bfa59348f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,1208 @@
 # Changelog
 
+## 2.8.1 (2025-11-17)
+
+Full Changelog: [v2.8.0...v2.8.1](https://github.com/openai/openai-python/compare/v2.8.0...v2.8.1)
+
+### Bug Fixes
+
+* **api:** align types of input items / output items for typescript ([64c9fb3](https://github.com/openai/openai-python/commit/64c9fb3fcc79f0049b3a36bd429faf0600d969f6))
+
+## 2.8.0 (2025-11-13)
+
+Full Changelog: [v2.7.2...v2.8.0](https://github.com/openai/openai-python/compare/v2.7.2...v2.8.0)
+
+### Features
+
+* **api:** gpt 5.1 ([8d9f2ca](https://github.com/openai/openai-python/commit/8d9f2cab4cb2e12f6e2ab1de967f858736a656ac))
+
+
+### Bug Fixes
+
+* **compat:** update signatures of `model_dump` and `model_dump_json` for Pydantic v1 ([c7bd234](https://github.com/openai/openai-python/commit/c7bd234b18239fcdbf0edb1b51ca9116c0ac7251))
+
+## 2.7.2 (2025-11-10)
+
+Full Changelog: [v2.7.1...v2.7.2](https://github.com/openai/openai-python/compare/v2.7.1...v2.7.2)
+
+### Bug Fixes
+
+* compat with Python 3.14 ([15a7ec8](https://github.com/openai/openai-python/commit/15a7ec8a753d7f57d525fca60c547fd5331cb214))
+
+
+### Chores
+
+* **package:** drop Python 3.8 support ([afc14f2](https://github.com/openai/openai-python/commit/afc14f2e42e7a8174f2ff1a5672829b808a716bf))
+
+## 2.7.1 (2025-11-04)
+
+Full Changelog: [v2.7.0...v2.7.1](https://github.com/openai/openai-python/compare/v2.7.0...v2.7.1)
+
+### Bug Fixes
+
+* **api:** fix nullability of logprobs ([373b7f6](https://github.com/openai/openai-python/commit/373b7f6e4255dfef3ccd92520011e8ba44e8b7f0))
+
+## 2.7.0 (2025-11-03)
+
+Full Changelog: [v2.6.1...v2.7.0](https://github.com/openai/openai-python/compare/v2.6.1...v2.7.0)
+
+### Features
+
+* **api:** Realtime API token_limits, Hybrid searching ranking options ([5b43992](https://github.com/openai/openai-python/commit/5b4399219d7ed326411aec524d25ef2b8e3152fc))
+* **api:** remove InputAudio from ResponseInputContent ([bd70a33](https://github.com/openai/openai-python/commit/bd70a33234741fa68c185105e4f53cc0275a2a50))
+
+
+### Bug Fixes
+
+* **client:** close streams without requiring full consumption ([d8bb7d6](https://github.com/openai/openai-python/commit/d8bb7d6d728c5481de4198eebe668b67803ae14a))
+* **readme:** update realtime examples ([#2714](https://github.com/openai/openai-python/issues/2714)) ([d0370a8](https://github.com/openai/openai-python/commit/d0370a8d61fc2f710a34d8aad48f649a9683106d))
+* **uploads:** avoid file handle leak ([4f1b691](https://github.com/openai/openai-python/commit/4f1b691ab4db41aebd397ec41942b43fb0f0743c))
+
+
+### Chores
+
+* **internal/tests:** avoid race condition with implicit client cleanup ([933d23b](https://github.com/openai/openai-python/commit/933d23bd8d7809c77e0796becfe052167d44d40a))
+* **internal:** grammar fix (it's -> its) ([f7e9e9e](https://github.com/openai/openai-python/commit/f7e9e9e4f43039f19a41375a6d2b2bdc2264dad7))
+
+## 2.6.1 (2025-10-24)
+
+Full Changelog: [v2.6.0...v2.6.1](https://github.com/openai/openai-python/compare/v2.6.0...v2.6.1)
+
+### Bug Fixes
+
+* **api:** docs updates ([d01a0c9](https://github.com/openai/openai-python/commit/d01a0c96ecb94c78b7e16546790c573704b7515b))
+
+
+### Chores
+
+* **client:** clean up custom translations code ([cfb9e25](https://github.com/openai/openai-python/commit/cfb9e25855b8eb020abe02cdd99566adf474e821))
+
+## 2.6.0 (2025-10-20)
+
+Full Changelog: [v2.5.0...v2.6.0](https://github.com/openai/openai-python/compare/v2.5.0...v2.6.0)
+
+### Features
+
+* **api:** Add responses.input_tokens.count ([6dd09e2](https://github.com/openai/openai-python/commit/6dd09e2829f385f72b28620888d91a4493c96772))
+
+
+### Bug Fixes
+
+* **api:** internal openapi updates ([caabd7c](https://github.com/openai/openai-python/commit/caabd7c81f0f557f66dc0089af460185a5816c11))
+
+## 2.5.0 (2025-10-17)
+
+Full Changelog: [v2.4.0...v2.5.0](https://github.com/openai/openai-python/compare/v2.4.0...v2.5.0)
+
+### Features
+
+* **api:** api update ([8b280d5](https://github.com/openai/openai-python/commit/8b280d57d6d361bc3a032e030158f6859c445291))
+
+
+### Chores
+
+* bump `httpx-aiohttp` version to 0.1.9 ([67f2f0a](https://github.com/openai/openai-python/commit/67f2f0afe51dab9d5899fe18b1a4e86b2c774d10))
+
+## 2.4.0 (2025-10-16)
+
+Full Changelog: [v2.3.0...v2.4.0](https://github.com/openai/openai-python/compare/v2.3.0...v2.4.0)
+
+### Features
+
+* **api:** Add support for gpt-4o-transcribe-diarize on audio/transcriptions endpoint ([bdbe9b8](https://github.com/openai/openai-python/commit/bdbe9b8f440209afa2979db4a9eda9579b3d2550))
+
+
+### Chores
+
+* fix dangling comment ([da14e99](https://github.com/openai/openai-python/commit/da14e9960608f7ade6f5cdf91967830c8a6c1657))
+* **internal:** detect missing future annotations with ruff ([2672b8f](https://github.com/openai/openai-python/commit/2672b8f0726300f7c62c356f25545ef0b3c0bb2e))
+
+## 2.3.0 (2025-10-10)
+
+Full Changelog: [v2.2.0...v2.3.0](https://github.com/openai/openai-python/compare/v2.2.0...v2.3.0)
+
+### Features
+
+* **api:** comparison filter in/not in ([aa49f62](https://github.com/openai/openai-python/commit/aa49f626a6ea9d77ad008badfb3741e16232d62f))
+
+
+### Chores
+
+* **package:** bump jiter to >=0.10.0 to support Python 3.14 ([#2618](https://github.com/openai/openai-python/issues/2618)) ([aa445ca](https://github.com/openai/openai-python/commit/aa445cab5c93c6908697fe98e73e16963330b141))
+
+## 2.2.0 (2025-10-06)
+
+Full Changelog: [v2.1.0...v2.2.0](https://github.com/openai/openai-python/compare/v2.1.0...v2.2.0)
+
+### Features
+
+* **api:** dev day 2025 launches ([38ac009](https://github.com/openai/openai-python/commit/38ac0093ebb3419b1e2280d0dc2d26c74a2bbbec))
+
+
+### Bug Fixes
+
+* **client:** add chatkit to beta resource ([de3e561](https://github.com/openai/openai-python/commit/de3e5619d0a85b17906a9416039ef309e820dc0f))
+
+## 2.1.0 (2025-10-02)
+
+Full Changelog: [v2.0.1...v2.1.0](https://github.com/openai/openai-python/compare/v2.0.1...v2.1.0)
+
+### Features
+
+* **api:** add support for realtime calls ([7f7925b](https://github.com/openai/openai-python/commit/7f7925b4074ecbf879714698000e10fa0519d51a))
+
+## 2.0.1 (2025-10-01)
+
+Full Changelog: [v2.0.0...v2.0.1](https://github.com/openai/openai-python/compare/v2.0.0...v2.0.1)
+
+### Bug Fixes
+
+* **api:** add status, approval_request_id to MCP tool call ([2a02255](https://github.com/openai/openai-python/commit/2a022553f83b636defcfda3b1c6f4b12d901357b))
+
+## 2.0.0 (2025-09-30)
+
+Full Changelog: [v1.109.1...v2.0.0](https://github.com/openai/openai-python/compare/v1.109.1...v2.0.0)
+
+### ⚠ BREAKING CHANGES
+
+* **api:** `ResponseFunctionToolCallOutputItem.output` and `ResponseCustomToolCallOutput.output` now return `string | Array<ResponseInputText | ResponseInputImage | ResponseInputFile>` instead of `string` only. This may break existing callsites that assume `output` is always a string.
+
+### Features
+
+* **api:** Support images and files for function call outputs in responses, BatchUsage ([4105376](https://github.com/openai/openai-python/commit/4105376a60293581371fd5635b805b717d24aa19))
+
+## 1.109.1 (2025-09-24)
+
+Full Changelog: [v1.109.0...v1.109.1](https://github.com/openai/openai-python/compare/v1.109.0...v1.109.1)
+
+### Bug Fixes
+
+* **compat:** compat with `pydantic&lt;2.8.0` when using additional fields ([5d95ecf](https://github.com/openai/openai-python/commit/5d95ecf7abd65f3e4e273be14c80f9b4cd91ffe8))
+
+## 1.109.0 (2025-09-23)
+
+Full Changelog: [v1.108.2...v1.109.0](https://github.com/openai/openai-python/compare/v1.108.2...v1.109.0)
+
+### Features
+
+* **api:** gpt-5-codex ([34502b5](https://github.com/openai/openai-python/commit/34502b5a175f8a10ea8694fcea38fe7308de89ef))
+
+## 1.108.2 (2025-09-22)
+
+Full Changelog: [v1.108.1...v1.108.2](https://github.com/openai/openai-python/compare/v1.108.1...v1.108.2)
+
+### Bug Fixes
+
+* **api:** fix mcp tool name ([fd1c673](https://github.com/openai/openai-python/commit/fd1c673fa8d5581b38c69c37aa4fd1fd251259a2))
+
+
+### Chores
+
+* **api:** openapi updates for conversations ([3224f6f](https://github.com/openai/openai-python/commit/3224f6f9b4221b954a8f63de66bcaab389164ee5))
+* do not install brew dependencies in ./scripts/bootstrap by default ([6764b00](https://github.com/openai/openai-python/commit/6764b00bcb8aeab41e73d2fcaf6c7a18ea9f7909))
+* improve example values ([20b58e1](https://github.com/openai/openai-python/commit/20b58e164f9f28b9fc562968263fa3eacc6f5c7c))
+
+## 1.108.1 (2025-09-19)
+
+Full Changelog: [v1.108.0...v1.108.1](https://github.com/openai/openai-python/compare/v1.108.0...v1.108.1)
+
+### Features
+
+* **api:** add reasoning_text ([18d8e12](https://github.com/openai/openai-python/commit/18d8e12061d1fd4e09d24986ff6e38c5063013e9))
+
+
+### Chores
+
+* **types:** change optional parameter type from NotGiven to Omit ([acc190a](https://github.com/openai/openai-python/commit/acc190a29526e64db6074e7f21aca800423c128c))
+
+## 1.108.0 (2025-09-17)
+
+Full Changelog: [v1.107.3...v1.108.0](https://github.com/openai/openai-python/compare/v1.107.3...v1.108.0)
+
+### Features
+
+* **api:** type updates for conversations, reasoning_effort and results for evals ([c2ee28c](https://github.com/openai/openai-python/commit/c2ee28c1b77eed98766fbb01cf1ad2ee240f412e))
+
+
+### Chores
+
+* **internal:** update pydantic dependency ([369d10a](https://github.com/openai/openai-python/commit/369d10a40dfe744f6bfc10c99eb1f58176500120))
+
+## 1.107.3 (2025-09-15)
+
+Full Changelog: [v1.107.2...v1.107.3](https://github.com/openai/openai-python/compare/v1.107.2...v1.107.3)
+
+### Chores
+
+* **api:** docs and spec refactoring ([9bab5da](https://github.com/openai/openai-python/commit/9bab5da1802c3575c58e73ed1470dd5fa61fd1d2))
+* **tests:** simplify `get_platform` test ([0b1f6a2](https://github.com/openai/openai-python/commit/0b1f6a28d5a59e10873264e976d2e332903eef29))
+
+## 1.107.2 (2025-09-12)
+
+Full Changelog: [v1.107.1...v1.107.2](https://github.com/openai/openai-python/compare/v1.107.1...v1.107.2)
+
+### Chores
+
+* **api:** Minor docs and type updates for realtime ([ab6a10d](https://github.com/openai/openai-python/commit/ab6a10da4ed7e6386695b6f5f29149d4870f85c9))
+* **tests:** simplify `get_platform` test ([01f03e0](https://github.com/openai/openai-python/commit/01f03e0ad1f9ab3f2ed8b7c13d652263c6d06378))
+
+## 1.107.1 (2025-09-10)
+
+Full Changelog: [v1.107.0...v1.107.1](https://github.com/openai/openai-python/compare/v1.107.0...v1.107.1)
+
+### Chores
+
+* **api:** fix realtime GA types ([570fc5a](https://github.com/openai/openai-python/commit/570fc5a28ada665fd658b24675361680cfeb086f))
+
+## 1.107.0 (2025-09-08)
+
+Full Changelog: [v1.106.1...v1.107.0](https://github.com/openai/openai-python/compare/v1.106.1...v1.107.0)
+
+### Features
+
+* **api:** ship the RealtimeGA API shape ([dc319d8](https://github.com/openai/openai-python/commit/dc319d8bbb3a20108399c1d15f98e63bdd84eb5c))
+
+
+### Chores
+
+* **internal:** codegen related update ([b79b7ca](https://github.com/openai/openai-python/commit/b79b7ca3a72009a036db0a344b500f616ca0443f))
+
+## 1.106.1 (2025-09-04)
+
+Full Changelog: [v1.106.0...v1.106.1](https://github.com/openai/openai-python/compare/v1.106.0...v1.106.1)
+
+### Chores
+
+* **internal:** move mypy configurations to `pyproject.toml` file ([ca413a2](https://github.com/openai/openai-python/commit/ca413a277496c3b883b103ad1138a886e89ae15e))
+
+## 1.106.0 (2025-09-04)
+
+Full Changelog: [v1.105.0...v1.106.0](https://github.com/openai/openai-python/compare/v1.105.0...v1.106.0)
+
+### Features
+
+* **client:** support callable api_key ([#2588](https://github.com/openai/openai-python/issues/2588)) ([e1bad01](https://github.com/openai/openai-python/commit/e1bad015b8a2b98bfee955a24bc931347a58efc1))
+* improve future compat with pydantic v3 ([6645d93](https://github.com/openai/openai-python/commit/6645d9317a240982928b92c2f4af0381db6edc09))
+
+## 1.105.0 (2025-09-03)
+
+Full Changelog: [v1.104.2...v1.105.0](https://github.com/openai/openai-python/compare/v1.104.2...v1.105.0)
+
+### Features
+
+* **api:** Add gpt-realtime models ([8502041](https://github.com/openai/openai-python/commit/85020414808314df9cb42e020b11baff12f18f16))
+
+## 1.104.2 (2025-09-02)
+
+Full Changelog: [v1.104.1...v1.104.2](https://github.com/openai/openai-python/compare/v1.104.1...v1.104.2)
+
+### Bug Fixes
+
+* **types:** add aliases back for web search tool types ([2521cd8](https://github.com/openai/openai-python/commit/2521cd8445906e418dbae783b0d7c375ad91d49d))
+
+## 1.104.1 (2025-09-02)
+
+Full Changelog: [v1.104.0...v1.104.1](https://github.com/openai/openai-python/compare/v1.104.0...v1.104.1)
+
+### Chores
+
+* **api:** manual updates for ResponseInputAudio ([0db5061](https://github.com/openai/openai-python/commit/0db50619663656ba97bba30ab640bbb33683d196))
+
+## 1.104.0 (2025-09-02)
+
+Full Changelog: [v1.103.0...v1.104.0](https://github.com/openai/openai-python/compare/v1.103.0...v1.104.0)
+
+### Features
+
+* **types:** replace List[str] with SequenceNotStr in params ([bc00bda](https://github.com/openai/openai-python/commit/bc00bda880a80089be8a1758c016266ca72dab2c))
+
+
+### Bug Fixes
+
+* **types:** update more types to use SequenceNotStr ([cff135c](https://github.com/openai/openai-python/commit/cff135cb7059ef1bf8f9b101a83529fc0cee37c4))
+* **types:** update some types to SequenceNotStr ([03f8b88](https://github.com/openai/openai-python/commit/03f8b88a0d428b74a7822e678a60d0ef106ea961))
+
+
+### Chores
+
+* remove unused import ([ac7795b](https://github.com/openai/openai-python/commit/ac7795b50d956ec5dc468302e8e3579a0467edcb))
+
+## 1.103.0 (2025-09-02)
+
+Full Changelog: [v1.102.0...v1.103.0](https://github.com/openai/openai-python/compare/v1.102.0...v1.103.0)
+
+### Features
+
+* **api:** realtime API updates ([b7c2ddc](https://github.com/openai/openai-python/commit/b7c2ddc5e5dedda01015b3d0e14ea6eb68c282d3))
+
+
+### Bug Fixes
+
+* **responses:** add missing params to stream() method ([bfc0673](https://github.com/openai/openai-python/commit/bfc06732ffe3764cb95cef9f23b4b5c0d312826a))
+
+
+### Chores
+
+* bump `inline-snapshot` version to 0.28.0 ([#2590](https://github.com/openai/openai-python/issues/2590)) ([a6b0872](https://github.com/openai/openai-python/commit/a6b087226587d4cc4f59f1f09a595921b2823ef2))
+* **client:** format imports ([7ae3020](https://github.com/openai/openai-python/commit/7ae3020b3ca7de21e6e9a0a1c40908e655f6cad5))
+* **internal:** add Sequence related utils ([d3d72b9](https://github.com/openai/openai-python/commit/d3d72b9ce3c0885bf2b6934ac57d9e84f8653208))
+* **internal:** fix formatting ([3ab273f](https://github.com/openai/openai-python/commit/3ab273f21e601f088be7502b7bb5d249fc386d6a))
+* **internal:** minor formatting change ([478a348](https://github.com/openai/openai-python/commit/478a34881c968e9cab9d93ac2cf8da2fcb37c46c))
+* **internal:** update pyright exclude list ([66e440f](https://github.com/openai/openai-python/commit/66e440fac3ca388400392c64211450dedc491c11))
+
+## 1.102.0 (2025-08-26)
+
+Full Changelog: [v1.101.0...v1.102.0](https://github.com/openai/openai-python/compare/v1.101.0...v1.102.0)
+
+### Features
+
+* **api:** add web search filters ([1c199a8](https://github.com/openai/openai-python/commit/1c199a8dc85f773ae656fe850fdfb80b91f8f6b1))
+
+
+### Bug Fixes
+
+* avoid newer type syntax ([bd0c668](https://github.com/openai/openai-python/commit/bd0c668d754b89c78c2c9ad2e081258c04aaece6))
+
+
+### Chores
+
+* **internal:** change ci workflow machines ([3e129d5](https://github.com/openai/openai-python/commit/3e129d5e49f6391dea7497132cb3cfed8e5dd8ee))
+* **internal:** codegen related update ([b6dc170](https://github.com/openai/openai-python/commit/b6dc170832d719fc5028cfe234748c22e6e168aa))
+
+## 1.101.0 (2025-08-21)
+
+Full Changelog: [v1.100.3...v1.101.0](https://github.com/openai/openai-python/compare/v1.100.3...v1.101.0)
+
+### Features
+
+* **api:** Add connectors support for MCP tool ([a47f962](https://github.com/openai/openai-python/commit/a47f962daf579c142b8af5579be732772b688a29))
+* **api:** adding support for /v1/conversations to the API ([e30bcbc](https://github.com/openai/openai-python/commit/e30bcbc0cb7c827af779bee6971f976261abfb67))
+
+
+### Chores
+
+* update github action ([7333b28](https://github.com/openai/openai-python/commit/7333b282718a5f6977f30e1a2548207b3a089bd4))
+
+## 1.100.3 (2025-08-20)
+
+Full Changelog: [v1.100.2...v1.100.3](https://github.com/openai/openai-python/compare/v1.100.2...v1.100.3)
+
+### Chores
+
+* **internal/ci:** setup breaking change detection ([ca2f936](https://github.com/openai/openai-python/commit/ca2f93600238e875f26395faf6afbefaf15b7c97))
+
+## 1.100.2 (2025-08-19)
+
+Full Changelog: [v1.100.1...v1.100.2](https://github.com/openai/openai-python/compare/v1.100.1...v1.100.2)
+
+### Chores
+
+* **api:** accurately represent shape for verbosity on Chat Completions ([c39d5fd](https://github.com/openai/openai-python/commit/c39d5fd3f5429c6d41f257669a1dd4c67a477455))
+
+## 1.100.1 (2025-08-18)
+
+Full Changelog: [v1.100.0...v1.100.1](https://github.com/openai/openai-python/compare/v1.100.0...v1.100.1)
+
+### Bug Fixes
+
+* **types:** revert response text config deletion ([ac4fb19](https://github.com/openai/openai-python/commit/ac4fb1922ae125c8310c30e402932e8bb2976f58))
+
+## 1.100.0 (2025-08-18)
+
+Full Changelog: [v1.99.9...v1.100.0](https://github.com/openai/openai-python/compare/v1.99.9...v1.100.0)
+
+### Features
+
+* **api:** add new text parameters, expiration options ([e3dfa7c](https://github.com/openai/openai-python/commit/e3dfa7c417b8c750ff62d98650e75e72ad9b1477))
+
+## 1.99.9 (2025-08-12)
+
+Full Changelog: [v1.99.8...v1.99.9](https://github.com/openai/openai-python/compare/v1.99.8...v1.99.9)
+
+### Bug Fixes
+
+* **types:** actually fix ChatCompletionMessageToolCall type ([20cb0c8](https://github.com/openai/openai-python/commit/20cb0c86d598e196386ff43db992f6497eb756d0))
+
+## 1.99.8 (2025-08-11)
+
+Full Changelog: [v1.99.7...v1.99.8](https://github.com/openai/openai-python/compare/v1.99.7...v1.99.8)
+
+### Bug Fixes
+
+* **internal/tests:** correct snapshot update comment ([2784a7a](https://github.com/openai/openai-python/commit/2784a7a7da24ddba74b5717f07d67546864472b9))
+* **types:** revert ChatCompletionMessageToolCallUnion breaking change ([ba54e03](https://github.com/openai/openai-python/commit/ba54e03bc2d21825d891685bf3bad4a9253cbeb0))
+
+
+### Chores
+
+* **internal/tests:** add inline snapshot format command ([8107db8](https://github.com/openai/openai-python/commit/8107db8ff738baa65fe4cf2f2d7f1acd29219c78))
+* **internal:** fix formatting ([f03a03d](https://github.com/openai/openai-python/commit/f03a03de8c84740209d021598ff8bf56b6d3c684))
+* **tests:** add responses output_text test ([971347b](https://github.com/openai/openai-python/commit/971347b3a05f79c51abd11c86b382ca73c28cefb))
+
+
+### Refactors
+
+* **tests:** share snapshot utils ([791c567](https://github.com/openai/openai-python/commit/791c567cd87fb8d587965773b1da0404c7848c68))
+
+## 1.99.7 (2025-08-11)
+
+Full Changelog: [v1.99.6...v1.99.7](https://github.com/openai/openai-python/compare/v1.99.6...v1.99.7)
+
+### Bug Fixes
+
+* **types:** rename ChatCompletionMessageToolCallParam ([48085e2](https://github.com/openai/openai-python/commit/48085e2f473799d079e71d48d2f5612a6fbeb976))
+* **types:** revert ChatCompletionMessageToolCallParam to a TypedDict ([c8e9cec](https://github.com/openai/openai-python/commit/c8e9cec5c93cc022fff546f27161717f769d1f81))
+
+## 1.99.6 (2025-08-09)
+
+Full Changelog: [v1.99.5...v1.99.6](https://github.com/openai/openai-python/compare/v1.99.5...v1.99.6)
+
+### Bug Fixes
+
+* **types:** re-export more tool call types ([8fe5741](https://github.com/openai/openai-python/commit/8fe574131cfe8f0453788cc6105d22834e7c102f))
+
+
+### Chores
+
+* **internal:** update comment in script ([e407bb5](https://github.com/openai/openai-python/commit/e407bb52112ad73e5eedf929434ee4ff7ac5a5a8))
+* update @stainless-api/prism-cli to v5.15.0 ([a1883fc](https://github.com/openai/openai-python/commit/a1883fcdfa02b81e5129bdb43206597a51f885fa))
+
+## 1.99.5 (2025-08-08)
+
+Full Changelog: [v1.99.4...v1.99.5](https://github.com/openai/openai-python/compare/v1.99.4...v1.99.5)
+
+### Bug Fixes
+
+* **client:** fix verbosity parameter location in Responses ([2764ff4](https://github.com/openai/openai-python/commit/2764ff459eb8b309d25b39b40e363b16a5b95019))
+
+## 1.99.4 (2025-08-08)
+
+Full Changelog: [v1.99.3...v1.99.4](https://github.com/openai/openai-python/compare/v1.99.3...v1.99.4)
+
+### Bug Fixes
+
+* **types:** rename chat completion tool ([8d3bf88](https://github.com/openai/openai-python/commit/8d3bf88f5bc11cf30b8b050c24b2cc5a3807614f))
+* **types:** revert ChatCompletionToolParam to a TypedDict ([3f4ae72](https://github.com/openai/openai-python/commit/3f4ae725af53e631ddc128c1c6862ecf0b08e073))
+
+## 1.99.3 (2025-08-07)
+
+Full Changelog: [v1.99.2...v1.99.3](https://github.com/openai/openai-python/compare/v1.99.2...v1.99.3)
+
+### Bug Fixes
+
+* **responses:** add output_text back ([585a4f1](https://github.com/openai/openai-python/commit/585a4f15e5a088bf8afee745bc4a7803775ac283))
+
+## 1.99.2 (2025-08-07)
+
+Full Changelog: [v1.99.1...v1.99.2](https://github.com/openai/openai-python/compare/v1.99.1...v1.99.2)
+
+### Features
+
+* **api:** adds GPT-5 and new API features: platform.openai.com/docs/guides/gpt-5 ([ed370d8](https://github.com/openai/openai-python/commit/ed370d805e4d5d1ec14a136f5b2516751277059f))
+
+
+### Bug Fixes
+
+* **types:** correct tool types ([0c57bd7](https://github.com/openai/openai-python/commit/0c57bd7f2183a20b714d04edea380a4df0464a40))
+
+
+### Chores
+
+* **tests:** bump inline-snapshot dependency ([e236fde](https://github.com/openai/openai-python/commit/e236fde99a335fcaac9760f324e4807ce2cf7cba))
+
+## 1.99.1 (2025-08-05)
+
+Full Changelog: [v1.99.0...v1.99.1](https://github.com/openai/openai-python/compare/v1.99.0...v1.99.1)
+
+### Bug Fixes
+
+* **internal:** correct event imports ([2a6d143](https://github.com/openai/openai-python/commit/2a6d1436288a07f67f6afefe5c0b5d6ae32d7e70))
+
+## 1.99.0 (2025-08-05)
+
+Full Changelog: [v1.98.0...v1.99.0](https://github.com/openai/openai-python/compare/v1.98.0...v1.99.0)
+
+### Features
+
+* **api:** manual updates ([d4aa726](https://github.com/openai/openai-python/commit/d4aa72602bf489ef270154b881b3967d497d4220))
+* **client:** support file upload requests ([0772e6e](https://github.com/openai/openai-python/commit/0772e6ed8310e15539610b003dd73f72f474ec0c))
+
+
+### Bug Fixes
+
+* add missing prompt_cache_key & prompt_cache_key params ([00b49ae](https://github.com/openai/openai-python/commit/00b49ae8d44ea396ac0536fc3ce4658fc669e2f5))
+
+
+### Chores
+
+* **internal:** fix ruff target version ([aa6b252](https://github.com/openai/openai-python/commit/aa6b252ae0f25f195dede15755e05dd2f542f42d))
+
+## 1.98.0 (2025-07-30)
+
+Full Changelog: [v1.97.2...v1.98.0](https://github.com/openai/openai-python/compare/v1.97.2...v1.98.0)
+
+### Features
+
+* **api:** manual updates ([88a8036](https://github.com/openai/openai-python/commit/88a8036c5ea186f36c57029ef4501a0833596f56))
+
+## 1.97.2 (2025-07-30)
+
+Full Changelog: [v1.97.1...v1.97.2](https://github.com/openai/openai-python/compare/v1.97.1...v1.97.2)
+
+### Chores
+
+* **client:** refactor streaming slightly to better future proof it ([71c0c74](https://github.com/openai/openai-python/commit/71c0c747132221b798e419bc5a37baf67173d34e))
+* **project:** add settings file for vscode ([29c22c9](https://github.com/openai/openai-python/commit/29c22c90fd229983355089f95d0bba9de15efedb))
+
+## 1.97.1 (2025-07-22)
+
+Full Changelog: [v1.97.0...v1.97.1](https://github.com/openai/openai-python/compare/v1.97.0...v1.97.1)
+
+### Bug Fixes
+
+* **parsing:** ignore empty metadata ([58c359f](https://github.com/openai/openai-python/commit/58c359ff67fd6103268e4405600fd58844b6f27b))
+* **parsing:** parse extra field types ([d524b7e](https://github.com/openai/openai-python/commit/d524b7e201418ccc9b5c2206da06d1be011808e5))
+
+
+### Chores
+
+* **api:** event shapes more accurate ([f3a9a92](https://github.com/openai/openai-python/commit/f3a9a9229280ecb7e0b2779dd44290df6d9824ef))
+
+## 1.97.0 (2025-07-16)
+
+Full Changelog: [v1.96.1...v1.97.0](https://github.com/openai/openai-python/compare/v1.96.1...v1.97.0)
+
+### Features
+
+* **api:** manual updates ([ed8e899](https://github.com/openai/openai-python/commit/ed8e89953d11bd5f44fa531422bdbb7a577ab426))
+
+## 1.96.1 (2025-07-15)
+
+Full Changelog: [v1.96.0...v1.96.1](https://github.com/openai/openai-python/compare/v1.96.0...v1.96.1)
+
+### Chores
+
+* **api:** update realtime specs ([b68b71b](https://github.com/openai/openai-python/commit/b68b71b178719e0b49ecfe34486b9d9ac0627924))
+
+## 1.96.0 (2025-07-15)
+
+Full Changelog: [v1.95.1...v1.96.0](https://github.com/openai/openai-python/compare/v1.95.1...v1.96.0)
+
+### Features
+
+* clean up environment call outs ([87c2e97](https://github.com/openai/openai-python/commit/87c2e979e0ec37347b7f595c2696408acd25fe20))
+
+
+### Chores
+
+* **api:** update realtime specs, build config ([bf06d88](https://github.com/openai/openai-python/commit/bf06d88b33f9af82a51d9a8af5b7a38925906f7a))
+
+## 1.95.1 (2025-07-11)
+
+Full Changelog: [v1.95.0...v1.95.1](https://github.com/openai/openai-python/compare/v1.95.0...v1.95.1)
+
+### Bug Fixes
+
+* **client:** don't send Content-Type header on GET requests ([182b763](https://github.com/openai/openai-python/commit/182b763065fbaaf68491a7e4a15fcb23cac361de))
+
+## 1.95.0 (2025-07-10)
+
+Full Changelog: [v1.94.0...v1.95.0](https://github.com/openai/openai-python/compare/v1.94.0...v1.95.0)
+
+### Features
+
+* **api:** add file_url, fix event ID ([265e216](https://github.com/openai/openai-python/commit/265e216396196d66cdfb5f92c5ef1a2a6ff27b5b))
+
+
+### Chores
+
+* **readme:** fix version rendering on pypi ([1eee5ca](https://github.com/openai/openai-python/commit/1eee5cabf2fd93877cd3ba85d0c6ed2ffd5f159f))
+
+## 1.94.0 (2025-07-10)
+
+Full Changelog: [v1.93.3...v1.94.0](https://github.com/openai/openai-python/compare/v1.93.3...v1.94.0)
+
+### Features
+
+* **api:** return better error message on missing embedding ([#2369](https://github.com/openai/openai-python/issues/2369)) ([e53464a](https://github.com/openai/openai-python/commit/e53464ae95f6a041f3267762834e6156c5ce1b57))
+
+## 1.93.3 (2025-07-09)
+
+Full Changelog: [v1.93.2...v1.93.3](https://github.com/openai/openai-python/compare/v1.93.2...v1.93.3)
+
+### Bug Fixes
+
+* **parsing:** correctly handle nested discriminated unions ([fc8a677](https://github.com/openai/openai-python/commit/fc8a67715d8f1b45d8639b8b6f9f6590fe358734))
+
+## 1.93.2 (2025-07-08)
+
+Full Changelog: [v1.93.1...v1.93.2](https://github.com/openai/openai-python/compare/v1.93.1...v1.93.2)
+
+### Chores
+
+* **internal:** bump pinned h11 dep ([4fca6ae](https://github.com/openai/openai-python/commit/4fca6ae2d0d7f27cbac8d06c3917932767c8c6b8))
+* **package:** mark python 3.13 as supported ([2229047](https://github.com/openai/openai-python/commit/2229047b8a549df16c617bddfe3b4521cfd257a5))
+
+## 1.93.1 (2025-07-07)
+
+Full Changelog: [v1.93.0...v1.93.1](https://github.com/openai/openai-python/compare/v1.93.0...v1.93.1)
+
+### Bug Fixes
+
+* **ci:** correct conditional ([de6a9ce](https://github.com/openai/openai-python/commit/de6a9ce078731d60b0bdc42a9322548c575f11a3))
+* **responses:** add missing arguments to parse ([05590ec](https://github.com/openai/openai-python/commit/05590ec2a96399afd05baf5a3ee1d9a744f09c40))
+* **vector stores:** add missing arguments to files.create_and_poll ([3152134](https://github.com/openai/openai-python/commit/3152134510532ec7c522d6b50a820deea205b602))
+* **vector stores:** add missing arguments to files.upload_and_poll ([9d4f425](https://github.com/openai/openai-python/commit/9d4f42569d5b59311453b1b11ee1dd2e8a271268))
+
+
+### Chores
+
+* **ci:** change upload type ([cd4aa88](https://github.com/openai/openai-python/commit/cd4aa889c50581d861728c9606327992485f0d0d))
+* **ci:** only run for pushes and fork pull requests ([f89c7eb](https://github.com/openai/openai-python/commit/f89c7eb46c6f081254715d75543cbee3ffa83822))
+* **internal:** codegen related update ([bddb8d2](https://github.com/openai/openai-python/commit/bddb8d2091455920e8526068d64f3f8a5cac7ae6))
+* **tests:** ensure parse method is in sync with create ([4f58e18](https://github.com/openai/openai-python/commit/4f58e187c12dc8b2c33e9cca284b0429e5cc4de5))
+* **tests:** ensure vector store files create and poll method is in sync ([0fe75a2](https://github.com/openai/openai-python/commit/0fe75a28f6109b2d25b015dc99472a06693e0e9f))
+
+## 1.93.0 (2025-06-27)
+
+Full Changelog: [v1.92.3...v1.93.0](https://github.com/openai/openai-python/compare/v1.92.3...v1.93.0)
+
+### Features
+
+* **cli:** add support for fine_tuning.jobs ([#1224](https://github.com/openai/openai-python/issues/1224)) ([e362bfd](https://github.com/openai/openai-python/commit/e362bfd10dfd04176560b964470ab0c517c601f3))
+
+## 1.92.3 (2025-06-27)
+
+Full Changelog: [v1.92.2...v1.92.3](https://github.com/openai/openai-python/compare/v1.92.2...v1.92.3)
+
+### Bug Fixes
+
+* **client:** avoid encoding error with empty API keys ([5a3e64e](https://github.com/openai/openai-python/commit/5a3e64e0cc761dbaa613fb22ec16e7e73c3bcf72))
+
+
+### Documentation
+
+* **examples/realtime:** mention macOS requirements ([#2142](https://github.com/openai/openai-python/issues/2142)) ([27bf6b2](https://github.com/openai/openai-python/commit/27bf6b2a933c61d5ec23fd266148af888f69f5c1))
+
+## 1.92.2 (2025-06-26)
+
+Full Changelog: [v1.92.1...v1.92.2](https://github.com/openai/openai-python/compare/v1.92.1...v1.92.2)
+
+### Chores
+
+* **api:** remove unsupported property ([ec24408](https://github.com/openai/openai-python/commit/ec2440864e03278144d7f58b97c31d87903e0843))
+
+## 1.92.1 (2025-06-26)
+
+Full Changelog: [v1.92.0...v1.92.1](https://github.com/openai/openai-python/compare/v1.92.0...v1.92.1)
+
+### Chores
+
+* **client:** sync stream/parse methods over ([e2536cf](https://github.com/openai/openai-python/commit/e2536cfd74224047cece9c2ad86f0ffe51c0667c))
+* **docs:** update README to include links to docs on Webhooks ([ddbf9f1](https://github.com/openai/openai-python/commit/ddbf9f1dc47a32257716189f2056b45933328c9c))
+
+## 1.92.0 (2025-06-26)
+
+Full Changelog: [v1.91.0...v1.92.0](https://github.com/openai/openai-python/compare/v1.91.0...v1.92.0)
+
+### Features
+
+* **api:** webhook and deep research support ([d3bb116](https://github.com/openai/openai-python/commit/d3bb116f34f470502f902b88131deec43a953b12))
+* **client:** move stream and parse out of beta ([0e358ed](https://github.com/openai/openai-python/commit/0e358ed66b317038705fb38958a449d284f3cb88))
+
+
+### Bug Fixes
+
+* **ci:** release-doctor — report correct token name ([ff8c556](https://github.com/openai/openai-python/commit/ff8c5561e44e8a0902732b5934c97299d2c98d4e))
+
+
+### Chores
+
+* **internal:** add tests for breaking change detection ([710fe8f](https://github.com/openai/openai-python/commit/710fe8fd5f9e33730338341680152d3f2556dfa0))
+* **tests:** skip some failing tests on the latest python versions ([93ccc38](https://github.com/openai/openai-python/commit/93ccc38a8ef1575d77d33d031666d07d10e4af72))
+
+## 1.91.0 (2025-06-23)
+
+Full Changelog: [v1.90.0...v1.91.0](https://github.com/openai/openai-python/compare/v1.90.0...v1.91.0)
+
+### Features
+
+* **api:** update api shapes for usage and code interpreter ([060d566](https://github.com/openai/openai-python/commit/060d5661e4a1fcdb953c52facd3e668ee80f9295))
+
+## 1.90.0 (2025-06-20)
+
+Full Changelog: [v1.89.0...v1.90.0](https://github.com/openai/openai-python/compare/v1.89.0...v1.90.0)
+
+### Features
+
+* **api:** make model and inputs not required to create response ([11bd62e](https://github.com/openai/openai-python/commit/11bd62eb7e46eec748edaf2e0cecf253ffc1202c))
+
+## 1.89.0 (2025-06-20)
+
+Full Changelog: [v1.88.0...v1.89.0](https://github.com/openai/openai-python/compare/v1.88.0...v1.89.0)
+
+### Features
+
+* **client:** add support for aiohttp ([9218b07](https://github.com/openai/openai-python/commit/9218b07727bf6f6eb00953df66de6ab061fecddb))
+
+
+### Bug Fixes
+
+* **tests:** fix: tests which call HTTP endpoints directly with the example parameters ([35bcc4b](https://github.com/openai/openai-python/commit/35bcc4b80bdbaa31108650f2a515902e83794e5a))
+
+
+### Chores
+
+* **readme:** update badges ([68044ee](https://github.com/openai/openai-python/commit/68044ee85d1bf324b17d3f60c914df4725d47fc8))
+
+## 1.88.0 (2025-06-17)
+
+Full Changelog: [v1.87.0...v1.88.0](https://github.com/openai/openai-python/compare/v1.87.0...v1.88.0)
+
+### Features
+
+* **api:** manual updates ([5d18a84](https://github.com/openai/openai-python/commit/5d18a8448ecbe31597e98ec7f64d7050c831901e))
+
+
+### Chores
+
+* **ci:** enable for pull requests ([542b0ce](https://github.com/openai/openai-python/commit/542b0ce98f14ccff4f9e1bcbd3a9ea5e4f846638))
+* **internal:** minor formatting ([29d723d](https://github.com/openai/openai-python/commit/29d723d1f1baf2a5843293c8647dc7baa16d56d1))
+
+## 1.87.0 (2025-06-16)
+
+Full Changelog: [v1.86.0...v1.87.0](https://github.com/openai/openai-python/compare/v1.86.0...v1.87.0)
+
+### Features
+
+* **api:** add reusable prompt IDs ([36bfe6e](https://github.com/openai/openai-python/commit/36bfe6e8ae12a31624ba1a360d9260f0aeec448a))
+
+
+### Bug Fixes
+
+* **client:** update service_tier on `client.beta.chat.completions` ([aa488d5](https://github.com/openai/openai-python/commit/aa488d5cf210d8640f87216538d4ff79d7181f2a))
+
+
+### Chores
+
+* **internal:** codegen related update ([b1a31e5](https://github.com/openai/openai-python/commit/b1a31e5ef4387d9f82cf33f9461371651788d381))
+* **internal:** update conftest.py ([bba0213](https://github.com/openai/openai-python/commit/bba0213842a4c161f2235e526d50901a336eecef))
+* **tests:** add tests for httpx client instantiation & proxies ([bc93712](https://github.com/openai/openai-python/commit/bc9371204f457aee9ed9b6ec1b61c2084f32faf1))
+
+## 1.86.0 (2025-06-10)
+
+Full Changelog: [v1.85.0...v1.86.0](https://github.com/openai/openai-python/compare/v1.85.0...v1.86.0)
+
+### Features
+
+* **api:** Add o3-pro model IDs ([d8dd80b](https://github.com/openai/openai-python/commit/d8dd80b1b4e6c73687d7acb6c3f62f0bf4b8282c))
+
+## 1.85.0 (2025-06-09)
+
+Full Changelog: [v1.84.0...v1.85.0](https://github.com/openai/openai-python/compare/v1.84.0...v1.85.0)
+
+### Features
+
+* **api:** Add tools and structured outputs to evals ([002cc7b](https://github.com/openai/openai-python/commit/002cc7bb3c315d95b81c2e497f55d21be7fd26f8))
+
+
+### Bug Fixes
+
+* **responses:** support raw responses for `parse()` ([d459943](https://github.com/openai/openai-python/commit/d459943cc1c81cf9ce5c426edd3ef9112fdf6723))
+
+## 1.84.0 (2025-06-03)
+
+Full Changelog: [v1.83.0...v1.84.0](https://github.com/openai/openai-python/compare/v1.83.0...v1.84.0)
+
+### Features
+
+* **api:** add new realtime and audio models, realtime session options ([0acd0da](https://github.com/openai/openai-python/commit/0acd0da6bc0468c6c857711bc5e77d0bc6d31be6))
+
+
+### Chores
+
+* **api:** update type names ([1924559](https://github.com/openai/openai-python/commit/192455913b38bf0323ddd0e2b1499b114e2111a1))
+
+## 1.83.0 (2025-06-02)
+
+Full Changelog: [v1.82.1...v1.83.0](https://github.com/openai/openai-python/compare/v1.82.1...v1.83.0)
+
+### Features
+
+* **api:** Config update for pakrym-stream-param ([88bcf3a](https://github.com/openai/openai-python/commit/88bcf3af9ce8ffa8347547d4d30aacac1ceba939))
+* **client:** add follow_redirects request option ([26d715f](https://github.com/openai/openai-python/commit/26d715f4e9b0f2b19e2ac16acc796a949338e1e1))
+
+
+### Bug Fixes
+
+* **api:** Fix evals and code interpreter interfaces ([2650159](https://github.com/openai/openai-python/commit/2650159f6d01f6eb481cf8c7942142e4fd21ce44))
+* **client:** return binary content from `get /containers/{container_id}/files/{file_id}/content` ([f7c80c4](https://github.com/openai/openai-python/commit/f7c80c4368434bd0be7436375076ba33a62f63b5))
+
+
+### Chores
+
+* **api:** mark some methods as deprecated ([3e2ca57](https://github.com/openai/openai-python/commit/3e2ca571cb6cdd9e15596590605b2f98a4c5a42e))
+* deprecate Assistants API ([9d166d7](https://github.com/openai/openai-python/commit/9d166d795e03dea49af680ec9597e9497522187c))
+* **docs:** remove reference to rye shell ([c7978e9](https://github.com/openai/openai-python/commit/c7978e9f1640c311022988fcd716cbb5c865daa8))
+
+## 1.82.1 (2025-05-29)
+
+Full Changelog: [v1.82.0...v1.82.1](https://github.com/openai/openai-python/compare/v1.82.0...v1.82.1)
+
+### Bug Fixes
+
+* **responses:** don't include `parsed_arguments` when re-serialising ([6d04193](https://github.com/openai/openai-python/commit/6d041937963ce452affcfb3553146ee51acfeb7a))
+
+
+### Chores
+
+* **internal:** fix release workflows ([361a909](https://github.com/openai/openai-python/commit/361a909a0cc83e5029ea425fd72202ffa8d1a46a))
+
+## 1.82.0 (2025-05-22)
+
+Full Changelog: [v1.81.0...v1.82.0](https://github.com/openai/openai-python/compare/v1.81.0...v1.82.0)
+
+### Features
+
+* **api:** new streaming helpers for background responses ([2a65d4d](https://github.com/openai/openai-python/commit/2a65d4de0aaba7801edd0df10f225530fd4969bd))
+
+
+### Bug Fixes
+
+* **azure:** mark images/edits as a deployment endpoint [#2371](https://github.com/openai/openai-python/issues/2371) ([5d1d5b4](https://github.com/openai/openai-python/commit/5d1d5b4b6072afe9fd7909b1a36014c8c11c1ad6))
+
+
+### Documentation
+
+* **readme:** another async example fix ([9ec8289](https://github.com/openai/openai-python/commit/9ec8289041f395805c67efd97847480f84eb9dac))
+* **readme:** fix async example ([37d0b25](https://github.com/openai/openai-python/commit/37d0b25b6e82cd381e5d1aa6e28f1a1311d02353))
+
+## 1.81.0 (2025-05-21)
+
+Full Changelog: [v1.80.0...v1.81.0](https://github.com/openai/openai-python/compare/v1.80.0...v1.81.0)
+
+### Features
+
+* **api:** add container endpoint ([054a210](https://github.com/openai/openai-python/commit/054a210289d7e0db22d2d2a61bbe4d4d9cc0cb47))
+
+## 1.80.0 (2025-05-21)
+
+Full Changelog: [v1.79.0...v1.80.0](https://github.com/openai/openai-python/compare/v1.79.0...v1.80.0)
+
+### Features
+
+* **api:** new API tools ([d36ae52](https://github.com/openai/openai-python/commit/d36ae528d55fe87067c4b8c6b2c947cbad5e5002))
+
+
+### Chores
+
+* **docs:** grammar improvements ([e746145](https://github.com/openai/openai-python/commit/e746145a12b5335d8841aff95c91bbbde8bae8e3))
+
+## 1.79.0 (2025-05-16)
+
+Full Changelog: [v1.78.1...v1.79.0](https://github.com/openai/openai-python/compare/v1.78.1...v1.79.0)
+
+### Features
+
+* **api:** further updates for evals API ([32c99a6](https://github.com/openai/openai-python/commit/32c99a6f5885d4bf3511a7f06b70000edd274301))
+* **api:** manual updates ([25245e5](https://github.com/openai/openai-python/commit/25245e5e3d0713abfb65b760aee1f12bc61deb41))
+* **api:** responses x eval api ([fd586cb](https://github.com/openai/openai-python/commit/fd586cbdf889c9a5c6b9be177ff02fbfffa3eba5))
+* **api:** Updating Assistants and Evals API schemas ([98ba7d3](https://github.com/openai/openai-python/commit/98ba7d355551213a13803f68d5642eecbb4ffd39))
+
+
+### Bug Fixes
+
+* fix create audio transcription endpoint ([e9a89ab](https://github.com/openai/openai-python/commit/e9a89ab7b6387610e433550207a23973b7edda3a))
+
+
+### Chores
+
+* **ci:** fix installation instructions ([f26c5fc](https://github.com/openai/openai-python/commit/f26c5fc85d98d700b68cb55c8be5d15983a9aeaf))
+* **ci:** upload sdks to package manager ([861f105](https://github.com/openai/openai-python/commit/861f1055768168ab04987a42efcd32a07bc93542))
+
+## 1.78.1 (2025-05-12)
+
+Full Changelog: [v1.78.0...v1.78.1](https://github.com/openai/openai-python/compare/v1.78.0...v1.78.1)
+
+### Bug Fixes
+
+* **internal:** fix linting due to broken __test__ annotation ([5a7d7a0](https://github.com/openai/openai-python/commit/5a7d7a081138c6473bff44e60d439812ecb85cdf))
+* **package:** support direct resource imports ([2293fc0](https://github.com/openai/openai-python/commit/2293fc0dd23a9c756067cdc22b39c18448f35feb))
+
+## 1.78.0 (2025-05-08)
+
+Full Changelog: [v1.77.0...v1.78.0](https://github.com/openai/openai-python/compare/v1.77.0...v1.78.0)
+
+### Features
+
+* **api:** Add reinforcement fine-tuning api support ([bebe361](https://github.com/openai/openai-python/commit/bebe36104bd3062d09ab9bbfb4bacfc99e737cb2))
+
+
+### Bug Fixes
+
+* ignore errors in isinstance() calls on LazyProxy subclasses ([#2343](https://github.com/openai/openai-python/issues/2343)) ([52cbbdf](https://github.com/openai/openai-python/commit/52cbbdf2207567741f16d18f1ea1b0d13d667375)), closes [#2056](https://github.com/openai/openai-python/issues/2056)
+
+
+### Chores
+
+* **internal:** update proxy tests ([b8e848d](https://github.com/openai/openai-python/commit/b8e848d5fb58472cbfa27fb3ed01efc25a05d944))
+* use lazy imports for module level client ([4d0f409](https://github.com/openai/openai-python/commit/4d0f409e79a18cce9855fe076f5a50e52b8bafd8))
+* use lazy imports for resources ([834813c](https://github.com/openai/openai-python/commit/834813c5cb1a84effc34e5eabed760393e1de806))
+
+## 1.77.0 (2025-05-02)
+
+Full Changelog: [v1.76.2...v1.77.0](https://github.com/openai/openai-python/compare/v1.76.2...v1.77.0)
+
+### Features
+
+* **api:** add image sizes, reasoning encryption ([473469a](https://github.com/openai/openai-python/commit/473469afa1a5f0a03f727bdcdadb9fd57872f9c5))
+
+
+### Bug Fixes
+
+* **parsing:** handle whitespace only strings ([#2007](https://github.com/openai/openai-python/issues/2007)) ([246bc5b](https://github.com/openai/openai-python/commit/246bc5b7559887840717667a0dad465caef66c3b))
+
+
+### Chores
+
+* only strip leading whitespace ([8467d66](https://github.com/openai/openai-python/commit/8467d666e0ddf1a9f81b8769a5c8a2fef1de20c1))
+
+## 1.76.2 (2025-04-29)
+
+Full Changelog: [v1.76.1...v1.76.2](https://github.com/openai/openai-python/compare/v1.76.1...v1.76.2)
+
+### Chores
+
+* **api:** API spec cleanup ([0a4d3e2](https://github.com/openai/openai-python/commit/0a4d3e2b495d22dd42ce1773b870554c64f9b3b2))
+
+## 1.76.1 (2025-04-29)
+
+Full Changelog: [v1.76.0...v1.76.1](https://github.com/openai/openai-python/compare/v1.76.0...v1.76.1)
+
+### Chores
+
+* broadly detect json family of content-type headers ([b4b1b08](https://github.com/openai/openai-python/commit/b4b1b086b512eecc0ada7fc1efa45eb506982f13))
+* **ci:** only use depot for staging repos ([35312d8](https://github.com/openai/openai-python/commit/35312d80e6bbc1a61d06ad253af9a713b5ef040c))
+* **ci:** run on more branches and use depot runners ([a6a45d4](https://github.com/openai/openai-python/commit/a6a45d4af8a4d904b37573a9b223d56106b4887d))
+
+## 1.76.0 (2025-04-23)
+
+Full Changelog: [v1.75.0...v1.76.0](https://github.com/openai/openai-python/compare/v1.75.0...v1.76.0)
+
+### Features
+
+* **api:** adding new image model support ([74d7692](https://github.com/openai/openai-python/commit/74d7692e94c9dca96db8793809d75631c22dbb87))
+
+
+### Bug Fixes
+
+* **pydantic v1:** more robust `ModelField.annotation` check ([#2163](https://github.com/openai/openai-python/issues/2163)) ([7351b12](https://github.com/openai/openai-python/commit/7351b12bc981f56632b92342d9ef26f6fb28d540))
+* **pydantic v1:** more robust ModelField.annotation check ([eba7856](https://github.com/openai/openai-python/commit/eba7856db55afb8cb44376a0248587549f7bc65f))
+
+
+### Chores
+
+* **ci:** add timeout thresholds for CI jobs ([0997211](https://github.com/openai/openai-python/commit/09972119df5dd4c7c8db137c721364787e22d4c6))
+* **internal:** fix list file params ([da2113c](https://github.com/openai/openai-python/commit/da2113c60b50b4438459325fcd38d55df3f63d8e))
+* **internal:** import reformatting ([b425fb9](https://github.com/openai/openai-python/commit/b425fb906f62550c3669b09b9d8575f3d4d8496b))
+* **internal:** minor formatting changes ([aed1d76](https://github.com/openai/openai-python/commit/aed1d767898324cf90328db329e04e89a77579c3))
+* **internal:** refactor retries to not use recursion ([8cb8cfa](https://github.com/openai/openai-python/commit/8cb8cfab48a4fed70a756ce50036e7e56e1f9f87))
+* **internal:** update models test ([870ad4e](https://github.com/openai/openai-python/commit/870ad4ed3a284d75f44b825503750129284c7906))
+* update completion parse signature ([a44016c](https://github.com/openai/openai-python/commit/a44016c64cdefe404e97592808ed3c25411ab27b))
+
+## 1.75.0 (2025-04-16)
+
+Full Changelog: [v1.74.1...v1.75.0](https://github.com/openai/openai-python/compare/v1.74.1...v1.75.0)
+
+### Features
+
+* **api:** add o3 and o4-mini model IDs ([4bacbd5](https://github.com/openai/openai-python/commit/4bacbd5503137e266c127dc643ebae496cb4f158))
+
+## 1.74.1 (2025-04-16)
+
+Full Changelog: [v1.74.0...v1.74.1](https://github.com/openai/openai-python/compare/v1.74.0...v1.74.1)
+
+### Chores
+
+* **internal:** base client updates ([06303b5](https://github.com/openai/openai-python/commit/06303b501f8c17040c495971a4ee79ae340f6f4a))
+* **internal:** bump pyright version ([9fd1c77](https://github.com/openai/openai-python/commit/9fd1c778c3231616bf1331cb1daa86fdfca4cb7f))
+
+## 1.74.0 (2025-04-14)
+
+Full Changelog: [v1.73.0...v1.74.0](https://github.com/openai/openai-python/compare/v1.73.0...v1.74.0)
+
+### Features
+
+* **api:** adding gpt-4.1 family of model IDs ([d4dae55](https://github.com/openai/openai-python/commit/d4dae5553ff3a2879b9ab79a6423661b212421f9))
+
+
+### Bug Fixes
+
+* **chat:** skip azure async filter events ([#2255](https://github.com/openai/openai-python/issues/2255)) ([fd3a38b](https://github.com/openai/openai-python/commit/fd3a38b1ed30af0a9f3302c1cfc6be6b352e65de))
+
+
+### Chores
+
+* **client:** minor internal fixes ([6071ae5](https://github.com/openai/openai-python/commit/6071ae5e8b4faa465afc8d07370737e66901900a))
+* **internal:** update pyright settings ([c8f8beb](https://github.com/openai/openai-python/commit/c8f8bebf852380a224701bc36826291d6387c53d))
+
+## 1.73.0 (2025-04-12)
+
+Full Changelog: [v1.72.0...v1.73.0](https://github.com/openai/openai-python/compare/v1.72.0...v1.73.0)
+
+### Features
+
+* **api:** manual updates ([a3253dd](https://github.com/openai/openai-python/commit/a3253dd798c1eccd9810d4fc593e8c2a568bcf4f))
+
+
+### Bug Fixes
+
+* **perf:** optimize some hot paths ([f79d39f](https://github.com/openai/openai-python/commit/f79d39fbcaea8f366a9e48c06fb1696bab3e607d))
+* **perf:** skip traversing types for NotGiven values ([28d220d](https://github.com/openai/openai-python/commit/28d220de3b4a09d80450d0bcc9b347bbf68f81ec))
+
+
+### Chores
+
+* **internal:** expand CI branch coverage ([#2295](https://github.com/openai/openai-python/issues/2295)) ([0ae783b](https://github.com/openai/openai-python/commit/0ae783b99122975be521365de0b6d2bce46056c9))
+* **internal:** reduce CI branch coverage ([2fb7d42](https://github.com/openai/openai-python/commit/2fb7d425cda679a54aa3262090479fd747363bb4))
+* slight wording improvement in README ([#2291](https://github.com/openai/openai-python/issues/2291)) ([e020759](https://github.com/openai/openai-python/commit/e0207598d16a2a9cb3cb3a8e8e97fa9cfdccd5e8))
+* workaround build errors ([4e10c96](https://github.com/openai/openai-python/commit/4e10c96a483db28dedc2d8c2908765fb7317e049))
+
+## 1.72.0 (2025-04-08)
+
+Full Changelog: [v1.71.0...v1.72.0](https://github.com/openai/openai-python/compare/v1.71.0...v1.72.0)
+
+### Features
+
+* **api:** Add evalapi to sdk ([#2287](https://github.com/openai/openai-python/issues/2287)) ([35262fc](https://github.com/openai/openai-python/commit/35262fcef6ccb7d1f75c9abdfdc68c3dcf87ef53))
+
+
+### Chores
+
+* **internal:** fix examples ([#2288](https://github.com/openai/openai-python/issues/2288)) ([39defd6](https://github.com/openai/openai-python/commit/39defd61e81ea0ec6b898be12e9fb7e621c0e532))
+* **internal:** skip broken test ([#2289](https://github.com/openai/openai-python/issues/2289)) ([e2c9bce](https://github.com/openai/openai-python/commit/e2c9bce1f59686ee053b495d06ea118b4a89e09e))
+* **internal:** slight transform perf improvement ([#2284](https://github.com/openai/openai-python/issues/2284)) ([746174f](https://github.com/openai/openai-python/commit/746174fae7a018ece5dab54fb0b5a15fcdd18f2f))
+* **tests:** improve enum examples ([#2286](https://github.com/openai/openai-python/issues/2286)) ([c9dd81c](https://github.com/openai/openai-python/commit/c9dd81ce0277e8b1f5db5e0a39c4c2bcd9004bcc))
+
+## 1.71.0 (2025-04-07)
+
+Full Changelog: [v1.70.0...v1.71.0](https://github.com/openai/openai-python/compare/v1.70.0...v1.71.0)
+
+### Features
+
+* **api:** manual updates ([bf8b4b6](https://github.com/openai/openai-python/commit/bf8b4b69906bfaea622c9c644270e985d92e2df2))
+* **api:** manual updates ([3e37aa3](https://github.com/openai/openai-python/commit/3e37aa3e151d9738625a1daf75d6243d6fdbe8f2))
+* **api:** manual updates ([dba9b65](https://github.com/openai/openai-python/commit/dba9b656fa5955b6eba8f6910da836a34de8d59d))
+* **api:** manual updates ([f0c463b](https://github.com/openai/openai-python/commit/f0c463b47836666d091b5f616871f1b94646d346))
+
+
+### Chores
+
+* **deps:** allow websockets v15 ([#2281](https://github.com/openai/openai-python/issues/2281)) ([19c619e](https://github.com/openai/openai-python/commit/19c619ea95839129a86c19d5b60133e1ed9f2746))
+* **internal:** only run examples workflow in main repo ([#2282](https://github.com/openai/openai-python/issues/2282)) ([c3e0927](https://github.com/openai/openai-python/commit/c3e0927d3fbbb9f753ba12adfa682a4235ba530a))
+* **internal:** remove trailing character ([#2277](https://github.com/openai/openai-python/issues/2277)) ([5a21a2d](https://github.com/openai/openai-python/commit/5a21a2d7994e39bb0c86271eeb807983a9ae874a))
+* Remove deprecated/unused remote spec feature ([23f76eb](https://github.com/openai/openai-python/commit/23f76eb0b9ddf12bcb04a6ad3f3ec5e956d2863f))
+
+## 1.70.0 (2025-03-31)
+
+Full Changelog: [v1.69.0...v1.70.0](https://github.com/openai/openai-python/compare/v1.69.0...v1.70.0)
+
+### Features
+
+* **api:** add `get /responses/{response_id}/input_items` endpoint ([4c6a35d](https://github.com/openai/openai-python/commit/4c6a35dec65362a6a738c3387dae57bf8cbfcbb2))
+
+## 1.69.0 (2025-03-27)
+
+Full Changelog: [v1.68.2...v1.69.0](https://github.com/openai/openai-python/compare/v1.68.2...v1.69.0)
+
+### Features
+
+* **api:** add `get /chat/completions` endpoint ([e6b8a42](https://github.com/openai/openai-python/commit/e6b8a42fc4286656cc86c2acd83692b170e77b68))
+
+
+### Bug Fixes
+
+* **audio:** correctly parse transcription stream events ([16a3a19](https://github.com/openai/openai-python/commit/16a3a195ff31f099fbe46043a12d2380c2c01f83))
+
+
+### Chores
+
+* add hash of OpenAPI spec/config inputs to .stats.yml ([515e1cd](https://github.com/openai/openai-python/commit/515e1cdd4a3109e5b29618df813656e17f22b52a))
+* **api:** updates to supported Voice IDs ([#2261](https://github.com/openai/openai-python/issues/2261)) ([64956f9](https://github.com/openai/openai-python/commit/64956f9d9889b04380c7f5eb926509d1efd523e6))
+* fix typos ([#2259](https://github.com/openai/openai-python/issues/2259)) ([6160de3](https://github.com/openai/openai-python/commit/6160de3e099f09c2d6ee5eeee4cbcc55b67a8f87))
+
+## 1.68.2 (2025-03-21)
+
+Full Changelog: [v1.68.1...v1.68.2](https://github.com/openai/openai-python/compare/v1.68.1...v1.68.2)
+
+### Refactors
+
+* **package:** rename audio extra to voice_helpers ([2dd6cb8](https://github.com/openai/openai-python/commit/2dd6cb87489fe12c5e45128f44d985c3f49aba1d))
+
+## 1.68.1 (2025-03-21)
+
+Full Changelog: [v1.68.0...v1.68.1](https://github.com/openai/openai-python/compare/v1.68.0...v1.68.1)
+
+### Bug Fixes
+
+* **client:** remove duplicate types ([#2235](https://github.com/openai/openai-python/issues/2235)) ([063f7d0](https://github.com/openai/openai-python/commit/063f7d0684c350ca9d766e2cb150233a22a623c8))
+* **helpers/audio:** remove duplicative module ([f253d04](https://github.com/openai/openai-python/commit/f253d0415145f2c4904ea2e7b389d31d94e45a54))
+* **package:** make sounddevice and numpy optional dependencies ([8b04453](https://github.com/openai/openai-python/commit/8b04453f0483736c13f0209a9f8f3618bc0e86c9))
+
+
+### Chores
+
+* **ci:** run workflows on next too ([67f89d4](https://github.com/openai/openai-python/commit/67f89d478aab780d1481c9bf6682c6633e431137))
+
+## 1.68.0 (2025-03-20)
+
+Full Changelog: [v1.67.0...v1.68.0](https://github.com/openai/openai-python/compare/v1.67.0...v1.68.0)
+
+### Features
+
+* add audio helpers ([423655c](https://github.com/openai/openai-python/commit/423655ca9077cfd258f1e52f6eb386fc8307fa5f))
+* **api:** new models for TTS, STT, + new audio features for Realtime ([#2232](https://github.com/openai/openai-python/issues/2232)) ([ab5192d](https://github.com/openai/openai-python/commit/ab5192d0a7b417ade622ec94dd48f86beb90692c))
+
+## 1.67.0 (2025-03-19)
+
+Full Changelog: [v1.66.5...v1.67.0](https://github.com/openai/openai-python/compare/v1.66.5...v1.67.0)
+
+### Features
+
+* **api:** o1-pro now available through the API ([#2228](https://github.com/openai/openai-python/issues/2228)) ([40a19d8](https://github.com/openai/openai-python/commit/40a19d8592c1767d6318230fc93e37c360d1bcd1))
+
+## 1.66.5 (2025-03-18)
+
+Full Changelog: [v1.66.4...v1.66.5](https://github.com/openai/openai-python/compare/v1.66.4...v1.66.5)
+
+### Bug Fixes
+
+* **types:** improve responses type names ([#2224](https://github.com/openai/openai-python/issues/2224)) ([5f7beb8](https://github.com/openai/openai-python/commit/5f7beb873af5ccef2551f34ab3ef098e099ce9c6))
+
+
+### Chores
+
+* **internal:** add back releases workflow ([c71d4c9](https://github.com/openai/openai-python/commit/c71d4c918eab3532b36ea944b0c4069db6ac2d38))
+* **internal:** codegen related update ([#2222](https://github.com/openai/openai-python/issues/2222)) ([f570d91](https://github.com/openai/openai-python/commit/f570d914a16cb5092533e32dfd863027d378c0b5))
+
+## 1.66.4 (2025-03-17)
+
+Full Changelog: [v1.66.3...v1.66.4](https://github.com/openai/openai-python/compare/v1.66.3...v1.66.4)
+
+### Bug Fixes
+
+* **ci:** ensure pip is always available ([#2207](https://github.com/openai/openai-python/issues/2207)) ([3f08e56](https://github.com/openai/openai-python/commit/3f08e56a48a04c2b7f03a4ad63f38228e25810e6))
+* **ci:** remove publishing patch ([#2208](https://github.com/openai/openai-python/issues/2208)) ([dd2dab7](https://github.com/openai/openai-python/commit/dd2dab7faf2a003da3e6af66780bd250be6e7f3f))
+* **types:** handle more discriminated union shapes ([#2206](https://github.com/openai/openai-python/issues/2206)) ([f85a9c6](https://github.com/openai/openai-python/commit/f85a9c633dcb9b64c0eb47d20151894742bbef22))
+
+
+### Chores
+
+* **internal:** bump rye to 0.44.0 ([#2200](https://github.com/openai/openai-python/issues/2200)) ([2dd3139](https://github.com/openai/openai-python/commit/2dd3139df6e7fe6307f9847e6527073e355e5047))
+* **internal:** remove CI condition ([#2203](https://github.com/openai/openai-python/issues/2203)) ([9620fdc](https://github.com/openai/openai-python/commit/9620fdcf4f2d01b6753ecc0abc16e5239c2b41e1))
+* **internal:** remove extra empty newlines ([#2195](https://github.com/openai/openai-python/issues/2195)) ([a1016a7](https://github.com/openai/openai-python/commit/a1016a78fe551e0f0e2562a0e81d1cb724d195da))
+* **internal:** update release workflows ([e2def44](https://github.com/openai/openai-python/commit/e2def4453323aa1cf8077df447fd55eb4c626393))
+
 ## 1.66.3 (2025-03-12)
 
 Full Changelog: [v1.66.2...v1.66.3](https://github.com/openai/openai-python/compare/v1.66.2...v1.66.3)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 52c2eb213a..c14e652328 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -17,8 +17,7 @@ $ rye sync --all-features
 You can then run scripts using `rye run python script.py` or by activating the virtual environment:
 
 ```sh
-$ rye shell
-# or manually activate - https://docs.python.org/3/library/venv.html#how-venvs-work
+# Activate the virtual environment - https://docs.python.org/3/library/venv.html#how-venvs-work
 $ source .venv/bin/activate
 
 # now you can omit the `rye run` prefix
diff --git a/README.md b/README.md
index c52bffbb5f..470707e1f3 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,9 @@
 # OpenAI Python API library
 
-[![PyPI version](https://img.shields.io/pypi/v/openai.svg)](https://pypi.org/project/openai/)
+<!-- prettier-ignore -->
+[![PyPI version](https://img.shields.io/pypi/v/openai.svg?label=pypi%20(stable))](https://pypi.org/project/openai/)
 
-The OpenAI Python library provides convenient access to the OpenAI REST API from any Python 3.8+
+The OpenAI Python library provides convenient access to the OpenAI REST API from any Python 3.9+
 application. The library includes type definitions for all request params and response fields,
 and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).
 
@@ -145,6 +146,44 @@ asyncio.run(main())
 
 Functionality between the synchronous and asynchronous clients is otherwise identical.
 
+### With aiohttp
+
+By default, the async client uses `httpx` for HTTP requests. However, for improved concurrency performance you may also use `aiohttp` as the HTTP backend.
+
+You can enable this by installing `aiohttp`:
+
+```sh
+# install from PyPI
+pip install openai[aiohttp]
+```
+
+Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
+
+```python
+import asyncio
+from openai import DefaultAioHttpClient
+from openai import AsyncOpenAI
+
+
+async def main() -> None:
+    async with AsyncOpenAI(
+        api_key="My API Key",
+        http_client=DefaultAioHttpClient(),
+    ) as client:
+        chat_completion = await client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": "Say this is a test",
+                }
+            ],
+            model="gpt-4o",
+        )
+
+
+asyncio.run(main())
+```
+
 ## Streaming responses
 
 We provide support for streaming responses using Server Side Events (SSE).
@@ -174,20 +213,20 @@ client = AsyncOpenAI()
 
 
 async def main():
-    stream = client.responses.create(
+    stream = await client.responses.create(
         model="gpt-4o",
         input="Write a one-sentence bedtime story about a unicorn.",
         stream=True,
     )
 
-    for event in stream:
+    async for event in stream:
         print(event)
 
 
 asyncio.run(main())
 ```
 
-## Realtime API beta
+## Realtime API
 
 The Realtime API enables you to build low-latency, multi-modal conversational experiences. It currently supports text and audio as both input and output, as well as [function calling](https://platform.openai.com/docs/guides/function-calling) through a WebSocket connection.
 
@@ -204,8 +243,10 @@ from openai import AsyncOpenAI
 async def main():
     client = AsyncOpenAI()
 
-    async with client.beta.realtime.connect(model="gpt-4o-realtime-preview") as connection:
-        await connection.session.update(session={'modalities': ['text']})
+    async with client.realtime.connect(model="gpt-realtime") as connection:
+        await connection.session.update(
+            session={"type": "realtime", "output_modalities": ["text"]}
+        )
 
         await connection.conversation.item.create(
             item={
@@ -217,10 +258,10 @@ async def main():
         await connection.response.create()
 
         async for event in connection:
-            if event.type == 'response.text.delta':
+            if event.type == "response.output_text.delta":
                 print(event.delta, flush=True, end="")
 
-            elif event.type == 'response.text.done':
+            elif event.type == "response.output_text.done":
                 print()
 
             elif event.type == "response.done":
@@ -238,7 +279,7 @@ Whenever an error occurs, the Realtime API will send an [`error` event](https://
 ```py
 client = AsyncOpenAI()
 
-async with client.beta.realtime.connect(model="gpt-4o-realtime-preview") as connection:
+async with client.realtime.connect(model="gpt-realtime") as connection:
     ...
     async for event in connection:
         if event.type == 'error':
@@ -351,7 +392,7 @@ response = client.chat.responses.create(
 
 ## File uploads
 
-Request parameters that correspond to file uploads can be passed as `bytes`, a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance or a tuple of `(filename, contents, media type)`.
+Request parameters that correspond to file uploads can be passed as `bytes`, or a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance or a tuple of `(filename, contents, media type)`.
 
 ```python
 from pathlib import Path
@@ -367,6 +408,86 @@ client.files.create(
 
 The async client uses the exact same interface. If you pass a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance, the file contents will be read asynchronously automatically.
 
+## Webhook Verification
+
+Verifying webhook signatures is _optional but encouraged_.
+
+For more information about webhooks, see [the API docs](https://platform.openai.com/docs/guides/webhooks).
+
+### Parsing webhook payloads
+
+For most use cases, you will likely want to verify the webhook and parse the payload at the same time. To achieve this, we provide the method `client.webhooks.unwrap()`, which parses a webhook request and verifies that it was sent by OpenAI. This method will raise an error if the signature is invalid.
+
+Note that the `body` parameter must be the raw JSON string sent from the server (do not parse it first). The `.unwrap()` method will parse this JSON for you into an event object after verifying the webhook was sent from OpenAI.
+
+```python
+from openai import OpenAI
+from flask import Flask, request
+
+app = Flask(__name__)
+client = OpenAI()  # OPENAI_WEBHOOK_SECRET environment variable is used by default
+
+
+@app.route("/webhook", methods=["POST"])
+def webhook():
+    request_body = request.get_data(as_text=True)
+
+    try:
+        event = client.webhooks.unwrap(request_body, request.headers)
+
+        if event.type == "response.completed":
+            print("Response completed:", event.data)
+        elif event.type == "response.failed":
+            print("Response failed:", event.data)
+        else:
+            print("Unhandled event type:", event.type)
+
+        return "ok"
+    except Exception as e:
+        print("Invalid signature:", e)
+        return "Invalid signature", 400
+
+
+if __name__ == "__main__":
+    app.run(port=8000)
+```
+
+### Verifying webhook payloads directly
+
+In some cases, you may want to verify the webhook separately from parsing the payload. If you prefer to handle these steps separately, we provide the method `client.webhooks.verify_signature()` to _only verify_ the signature of a webhook request. Like `.unwrap()`, this method will raise an error if the signature is invalid.
+
+Note that the `body` parameter must be the raw JSON string sent from the server (do not parse it first). You will then need to parse the body after verifying the signature.
+
+```python
+import json
+from openai import OpenAI
+from flask import Flask, request
+
+app = Flask(__name__)
+client = OpenAI()  # OPENAI_WEBHOOK_SECRET environment variable is used by default
+
+
+@app.route("/webhook", methods=["POST"])
+def webhook():
+    request_body = request.get_data(as_text=True)
+
+    try:
+        client.webhooks.verify_signature(request_body, request.headers)
+
+        # Parse the body after verification
+        event = json.loads(request_body)
+        print("Verified event:", event)
+
+        return "ok"
+    except Exception as e:
+        print("Invalid signature:", e)
+        return "Invalid signature", 400
+
+
+if __name__ == "__main__":
+    app.run(port=8000)
+```
+
 ## Handling errors
 
 When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `openai.APIConnectionError` is raised.
@@ -733,7 +854,7 @@ print(openai.__version__)
 
 ## Requirements
 
-Python 3.8 or higher.
+Python 3.9 or higher.
 
 ## Contributing
 
diff --git a/SECURITY.md b/SECURITY.md
index 3b3bd8a662..4adb0c54f1 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -16,13 +16,13 @@ before making any information public.
 ## Reporting Non-SDK Related Security Issues
 
 If you encounter security issues that are not directly related to SDKs but pertain to the services
-or products provided by OpenAI please follow the respective company's security reporting guidelines.
+or products provided by OpenAI, please follow the respective company's security reporting guidelines.
 
 ### OpenAI Terms and Policies
 
 Our Security Policy can be found at [Security Policy URL](https://openai.com/policies/coordinated-vulnerability-disclosure-policy).
 
-Please contact disclosure@openai.com for any questions or concerns regarding security of our services.
+Please contact disclosure@openai.com for any questions or concerns regarding the security of our services.
 
 ---
 
diff --git a/api.md b/api.md
index e760fe69c1..28ee551af3 100644
--- a/api.md
+++ b/api.md
@@ -2,9 +2,11 @@
 
 ```python
 from openai.types import (
+    AllModels,
     ChatModel,
     ComparisonFilter,
     CompoundFilter,
+    CustomToolInputFormat,
     ErrorObject,
     FunctionDefinition,
     FunctionParameters,
@@ -14,6 +16,9 @@ from openai.types import (
     ResponseFormatJSONObject,
     ResponseFormatJSONSchema,
     ResponseFormatText,
+    ResponseFormatTextGrammar,
+    ResponseFormatTextPython,
+    ResponsesModel,
 )
 ```
 
@@ -44,6 +49,7 @@ Types:
 ```python
 from openai.types.chat import (
     ChatCompletion,
+    ChatCompletionAllowedToolChoice,
     ChatCompletionAssistantMessageParam,
     ChatCompletionAudio,
     ChatCompletionAudioParam,
@@ -53,25 +59,31 @@ from openai.types.chat import (
     ChatCompletionContentPartInputAudio,
     ChatCompletionContentPartRefusal,
     ChatCompletionContentPartText,
+    ChatCompletionCustomTool,
     ChatCompletionDeleted,
     ChatCompletionDeveloperMessageParam,
     ChatCompletionFunctionCallOption,
     ChatCompletionFunctionMessageParam,
+    ChatCompletionFunctionTool,
     ChatCompletionMessage,
+    ChatCompletionMessageCustomToolCall,
+    ChatCompletionMessageFunctionToolCall,
     ChatCompletionMessageParam,
-    ChatCompletionMessageToolCall,
+    ChatCompletionMessageToolCallUnion,
     ChatCompletionModality,
     ChatCompletionNamedToolChoice,
+    ChatCompletionNamedToolChoiceCustom,
     ChatCompletionPredictionContent,
     ChatCompletionRole,
     ChatCompletionStoreMessage,
     ChatCompletionStreamOptions,
     ChatCompletionSystemMessageParam,
     ChatCompletionTokenLogprob,
-    ChatCompletionTool,
+    ChatCompletionToolUnion,
     ChatCompletionToolChoiceOption,
     ChatCompletionToolMessageParam,
     ChatCompletionUserMessageParam,
+    ChatCompletionAllowedTools,
     ChatCompletionReasoningEffort,
 )
 ```
@@ -125,7 +137,17 @@ Methods:
 Types:
 
 ```python
-from openai.types import Image, ImageModel, ImagesResponse
+from openai.types import (
+    Image,
+    ImageEditCompletedEvent,
+    ImageEditPartialImageEvent,
+    ImageEditStreamEvent,
+    ImageGenCompletedEvent,
+    ImageGenPartialImageEvent,
+    ImageGenStreamEvent,
+    ImageModel,
+    ImagesResponse,
+)
 ```
 
 Methods:
@@ -149,7 +171,14 @@ Types:
 ```python
 from openai.types.audio import (
     Transcription,
+    TranscriptionDiarized,
+    TranscriptionDiarizedSegment,
+    TranscriptionInclude,
     TranscriptionSegment,
+    TranscriptionStreamEvent,
+    TranscriptionTextDeltaEvent,
+    TranscriptionTextDoneEvent,
+    TranscriptionTextSegmentEvent,
     TranscriptionVerbose,
     TranscriptionWord,
     TranscriptionCreateResponse,
@@ -219,6 +248,21 @@ Methods:
 
 # FineTuning
 
+## Methods
+
+Types:
+
+```python
+from openai.types.fine_tuning import (
+    DpoHyperparameters,
+    DpoMethod,
+    ReinforcementHyperparameters,
+    ReinforcementMethod,
+    SupervisedHyperparameters,
+    SupervisedMethod,
+)
+```
+
 ## Jobs
 
 Types:
@@ -240,6 +284,8 @@ Methods:
 - <code title="get /fine_tuning/jobs">client.fine_tuning.jobs.<a href="./src/openai/resources/fine_tuning/jobs/jobs.py">list</a>(\*\*<a href="src/openai/types/fine_tuning/job_list_params.py">params</a>) -> <a href="./src/openai/types/fine_tuning/fine_tuning_job.py">SyncCursorPage[FineTuningJob]</a></code>
 - <code title="post /fine_tuning/jobs/{fine_tuning_job_id}/cancel">client.fine_tuning.jobs.<a href="./src/openai/resources/fine_tuning/jobs/jobs.py">cancel</a>(fine_tuning_job_id) -> <a href="./src/openai/types/fine_tuning/fine_tuning_job.py">FineTuningJob</a></code>
 - <code title="get /fine_tuning/jobs/{fine_tuning_job_id}/events">client.fine_tuning.jobs.<a href="./src/openai/resources/fine_tuning/jobs/jobs.py">list_events</a>(fine_tuning_job_id, \*\*<a href="src/openai/types/fine_tuning/job_list_events_params.py">params</a>) -> <a href="./src/openai/types/fine_tuning/fine_tuning_job_event.py">SyncCursorPage[FineTuningJobEvent]</a></code>
+- <code title="post /fine_tuning/jobs/{fine_tuning_job_id}/pause">client.fine_tuning.jobs.<a href="./src/openai/resources/fine_tuning/jobs/jobs.py">pause</a>(fine_tuning_job_id) -> <a href="./src/openai/types/fine_tuning/fine_tuning_job.py">FineTuningJob</a></code>
+- <code title="post /fine_tuning/jobs/{fine_tuning_job_id}/resume">client.fine_tuning.jobs.<a href="./src/openai/resources/fine_tuning/jobs/jobs.py">resume</a>(fine_tuning_job_id) -> <a href="./src/openai/types/fine_tuning/fine_tuning_job.py">FineTuningJob</a></code>
 
 ### Checkpoints
 
@@ -253,6 +299,58 @@ Methods:
 
 - <code title="get /fine_tuning/jobs/{fine_tuning_job_id}/checkpoints">client.fine_tuning.jobs.checkpoints.<a href="./src/openai/resources/fine_tuning/jobs/checkpoints.py">list</a>(fine_tuning_job_id, \*\*<a href="src/openai/types/fine_tuning/jobs/checkpoint_list_params.py">params</a>) -> <a href="./src/openai/types/fine_tuning/jobs/fine_tuning_job_checkpoint.py">SyncCursorPage[FineTuningJobCheckpoint]</a></code>
 
+## Checkpoints
+
+### Permissions
+
+Types:
+
+```python
+from openai.types.fine_tuning.checkpoints import (
+    PermissionCreateResponse,
+    PermissionRetrieveResponse,
+    PermissionDeleteResponse,
+)
+```
+
+Methods:
+
+- <code title="post /fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions">client.fine_tuning.checkpoints.permissions.<a href="./src/openai/resources/fine_tuning/checkpoints/permissions.py">create</a>(fine_tuned_model_checkpoint, \*\*<a href="src/openai/types/fine_tuning/checkpoints/permission_create_params.py">params</a>) -> <a href="./src/openai/types/fine_tuning/checkpoints/permission_create_response.py">SyncPage[PermissionCreateResponse]</a></code>
+- <code title="get /fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions">client.fine_tuning.checkpoints.permissions.<a href="./src/openai/resources/fine_tuning/checkpoints/permissions.py">retrieve</a>(fine_tuned_model_checkpoint, \*\*<a href="src/openai/types/fine_tuning/checkpoints/permission_retrieve_params.py">params</a>) -> <a href="./src/openai/types/fine_tuning/checkpoints/permission_retrieve_response.py">PermissionRetrieveResponse</a></code>
+- <code title="delete /fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions/{permission_id}">client.fine_tuning.checkpoints.permissions.<a href="./src/openai/resources/fine_tuning/checkpoints/permissions.py">delete</a>(permission_id, \*, fine_tuned_model_checkpoint) -> <a href="./src/openai/types/fine_tuning/checkpoints/permission_delete_response.py">PermissionDeleteResponse</a></code>
+
+## Alpha
+
+### Graders
+
+Types:
+
+```python
+from openai.types.fine_tuning.alpha import GraderRunResponse, GraderValidateResponse
+```
+
+Methods:
+
+- <code title="post /fine_tuning/alpha/graders/run">client.fine_tuning.alpha.graders.<a href="./src/openai/resources/fine_tuning/alpha/graders.py">run</a>(\*\*<a href="src/openai/types/fine_tuning/alpha/grader_run_params.py">params</a>) -> <a href="./src/openai/types/fine_tuning/alpha/grader_run_response.py">GraderRunResponse</a></code>
+- <code title="post /fine_tuning/alpha/graders/validate">client.fine_tuning.alpha.graders.<a href="./src/openai/resources/fine_tuning/alpha/graders.py">validate</a>(\*\*<a href="src/openai/types/fine_tuning/alpha/grader_validate_params.py">params</a>) -> <a href="./src/openai/types/fine_tuning/alpha/grader_validate_response.py">GraderValidateResponse</a></code>
+
+# Graders
+
+## GraderModels
+
+Types:
+
+```python
+from openai.types.graders import (
+    LabelModelGrader,
+    MultiGrader,
+    PythonGrader,
+    ScoreModelGrader,
+    StringCheckGrader,
+    TextSimilarityGrader,
+)
+```
+
 # VectorStores
 
 Types:
@@ -320,6 +418,36 @@ Methods:
 - <code>client.vector_stores.file_batches.<a href="./src/openai/resources/vector_stores/file_batches.py">poll</a>(\*args) -> VectorStoreFileBatch</code>
 - <code>client.vector_stores.file_batches.<a href="./src/openai/resources/vector_stores/file_batches.py">upload_and_poll</a>(\*args) -> VectorStoreFileBatch</code>
 
+# Webhooks
+
+Types:
+
+```python
+from openai.types.webhooks import (
+    BatchCancelledWebhookEvent,
+    BatchCompletedWebhookEvent,
+    BatchExpiredWebhookEvent,
+    BatchFailedWebhookEvent,
+    EvalRunCanceledWebhookEvent,
+    EvalRunFailedWebhookEvent,
+    EvalRunSucceededWebhookEvent,
+    FineTuningJobCancelledWebhookEvent,
+    FineTuningJobFailedWebhookEvent,
+    FineTuningJobSucceededWebhookEvent,
+    RealtimeCallIncomingWebhookEvent,
+    ResponseCancelledWebhookEvent,
+    ResponseCompletedWebhookEvent,
+    ResponseFailedWebhookEvent,
+    ResponseIncompleteWebhookEvent,
+    UnwrapWebhookEvent,
+)
+```
+
+Methods:
+
+- <code>client.webhooks.<a href="./src/openai/resources/webhooks.py">unwrap</a>(payload, headers, \*, secret) -> UnwrapWebhookEvent</code>
+- <code>client.webhooks.<a href="./src/openai/resources/webhooks.py">verify_signature</a>(payload, headers, \*, secret, tolerance) -> None</code>
+
 # Beta
 
 ## Realtime
@@ -336,7 +464,9 @@ from openai.types.beta.realtime import (
     ConversationItemDeleteEvent,
     ConversationItemDeletedEvent,
     ConversationItemInputAudioTranscriptionCompletedEvent,
+    ConversationItemInputAudioTranscriptionDeltaEvent,
     ConversationItemInputAudioTranscriptionFailedEvent,
+    ConversationItemRetrieveEvent,
     ConversationItemTruncateEvent,
     ConversationItemTruncatedEvent,
     ConversationItemWithReference,
@@ -373,6 +503,8 @@ from openai.types.beta.realtime import (
     SessionCreatedEvent,
     SessionUpdateEvent,
     SessionUpdatedEvent,
+    TranscriptionSessionUpdate,
+    TranscriptionSessionUpdatedEvent,
 )
 ```
 
@@ -388,6 +520,18 @@ Methods:
 
 - <code title="post /realtime/sessions">client.beta.realtime.sessions.<a href="./src/openai/resources/beta/realtime/sessions.py">create</a>(\*\*<a href="src/openai/types/beta/realtime/session_create_params.py">params</a>) -> <a href="./src/openai/types/beta/realtime/session_create_response.py">SessionCreateResponse</a></code>
 
+### TranscriptionSessions
+
+Types:
+
+```python
+from openai.types.beta.realtime import TranscriptionSession
+```
+
+Methods:
+
+- <code title="post /realtime/transcription_sessions">client.beta.realtime.transcription_sessions.<a href="./src/openai/resources/beta/realtime/transcription_sessions.py">create</a>(\*\*<a href="src/openai/types/beta/realtime/transcription_session_create_params.py">params</a>) -> <a href="./src/openai/types/beta/realtime/transcription_session.py">TranscriptionSession</a></code>
+
 ## Assistants
 
 Types:
@@ -546,7 +690,7 @@ Methods:
 Types:
 
 ```python
-from openai.types import Batch, BatchError, BatchRequestCounts
+from openai.types import Batch, BatchError, BatchRequestCounts, BatchUsage
 ```
 
 Methods:
@@ -588,11 +732,16 @@ Types:
 
 ```python
 from openai.types.responses import (
+    ApplyPatchTool,
     ComputerTool,
+    CustomTool,
     EasyInputMessage,
     FileSearchTool,
+    FunctionShellTool,
     FunctionTool,
     Response,
+    ResponseApplyPatchToolCall,
+    ResponseApplyPatchToolCallOutput,
     ResponseAudioDeltaEvent,
     ResponseAudioDoneEvent,
     ResponseAudioTranscriptDeltaEvent,
@@ -605,10 +754,17 @@ from openai.types.responses import (
     ResponseCodeInterpreterToolCall,
     ResponseCompletedEvent,
     ResponseComputerToolCall,
+    ResponseComputerToolCallOutputItem,
+    ResponseComputerToolCallOutputScreenshot,
     ResponseContent,
     ResponseContentPartAddedEvent,
     ResponseContentPartDoneEvent,
+    ResponseConversationParam,
     ResponseCreatedEvent,
+    ResponseCustomToolCall,
+    ResponseCustomToolCallInputDeltaEvent,
+    ResponseCustomToolCallInputDoneEvent,
+    ResponseCustomToolCallOutput,
     ResponseError,
     ResponseErrorEvent,
     ResponseFailedEvent,
@@ -620,8 +776,19 @@ from openai.types.responses import (
     ResponseFormatTextJSONSchemaConfig,
     ResponseFunctionCallArgumentsDeltaEvent,
     ResponseFunctionCallArgumentsDoneEvent,
+    ResponseFunctionCallOutputItem,
+    ResponseFunctionCallOutputItemList,
+    ResponseFunctionShellCallOutputContent,
+    ResponseFunctionShellToolCall,
+    ResponseFunctionShellToolCallOutput,
     ResponseFunctionToolCall,
+    ResponseFunctionToolCallItem,
+    ResponseFunctionToolCallOutputItem,
     ResponseFunctionWebSearch,
+    ResponseImageGenCallCompletedEvent,
+    ResponseImageGenCallGeneratingEvent,
+    ResponseImageGenCallInProgressEvent,
+    ResponseImageGenCallPartialImageEvent,
     ResponseInProgressEvent,
     ResponseIncludable,
     ResponseIncompleteEvent,
@@ -629,10 +796,23 @@ from openai.types.responses import (
     ResponseInputAudio,
     ResponseInputContent,
     ResponseInputFile,
+    ResponseInputFileContent,
     ResponseInputImage,
+    ResponseInputImageContent,
     ResponseInputItem,
     ResponseInputMessageContentList,
+    ResponseInputMessageItem,
     ResponseInputText,
+    ResponseInputTextContent,
+    ResponseItem,
+    ResponseMcpCallArgumentsDeltaEvent,
+    ResponseMcpCallArgumentsDoneEvent,
+    ResponseMcpCallCompletedEvent,
+    ResponseMcpCallFailedEvent,
+    ResponseMcpCallInProgressEvent,
+    ResponseMcpListToolsCompletedEvent,
+    ResponseMcpListToolsFailedEvent,
+    ResponseMcpListToolsInProgressEvent,
     ResponseOutputAudio,
     ResponseOutputItem,
     ResponseOutputItemAddedEvent,
@@ -640,12 +820,20 @@ from openai.types.responses import (
     ResponseOutputMessage,
     ResponseOutputRefusal,
     ResponseOutputText,
+    ResponseOutputTextAnnotationAddedEvent,
+    ResponsePrompt,
+    ResponseQueuedEvent,
     ResponseReasoningItem,
+    ResponseReasoningSummaryPartAddedEvent,
+    ResponseReasoningSummaryPartDoneEvent,
+    ResponseReasoningSummaryTextDeltaEvent,
+    ResponseReasoningSummaryTextDoneEvent,
+    ResponseReasoningTextDeltaEvent,
+    ResponseReasoningTextDoneEvent,
     ResponseRefusalDeltaEvent,
     ResponseRefusalDoneEvent,
     ResponseStatus,
     ResponseStreamEvent,
-    ResponseTextAnnotationDeltaEvent,
     ResponseTextConfig,
     ResponseTextDeltaEvent,
     ResponseTextDoneEvent,
@@ -654,9 +842,15 @@ from openai.types.responses import (
     ResponseWebSearchCallInProgressEvent,
     ResponseWebSearchCallSearchingEvent,
     Tool,
+    ToolChoiceAllowed,
+    ToolChoiceApplyPatch,
+    ToolChoiceCustom,
     ToolChoiceFunction,
+    ToolChoiceMcp,
     ToolChoiceOptions,
+    ToolChoiceShell,
     ToolChoiceTypes,
+    WebSearchPreviewTool,
     WebSearchTool,
 )
 ```
@@ -666,6 +860,7 @@ Methods:
 - <code title="post /responses">client.responses.<a href="./src/openai/resources/responses/responses.py">create</a>(\*\*<a href="src/openai/types/responses/response_create_params.py">params</a>) -> <a href="./src/openai/types/responses/response.py">Response</a></code>
 - <code title="get /responses/{response_id}">client.responses.<a href="./src/openai/resources/responses/responses.py">retrieve</a>(response_id, \*\*<a href="src/openai/types/responses/response_retrieve_params.py">params</a>) -> <a href="./src/openai/types/responses/response.py">Response</a></code>
 - <code title="delete /responses/{response_id}">client.responses.<a href="./src/openai/resources/responses/responses.py">delete</a>(response_id) -> None</code>
+- <code title="post /responses/{response_id}/cancel">client.responses.<a href="./src/openai/resources/responses/responses.py">cancel</a>(response_id) -> <a href="./src/openai/types/responses/response.py">Response</a></code>
 
 ## InputItems
 
@@ -677,4 +872,320 @@ from openai.types.responses import ResponseItemList
 
 Methods:
 
-- <code title="get /responses/{response_id}/input_items">client.responses.input_items.<a href="./src/openai/resources/responses/input_items.py">list</a>(response_id, \*\*<a href="src/openai/types/responses/input_item_list_params.py">params</a>) -> SyncCursorPage[Data]</code>
+- <code title="get /responses/{response_id}/input_items">client.responses.input_items.<a href="./src/openai/resources/responses/input_items.py">list</a>(response_id, \*\*<a href="src/openai/types/responses/input_item_list_params.py">params</a>) -> <a href="./src/openai/types/responses/response_item.py">SyncCursorPage[ResponseItem]</a></code>
+
+## InputTokens
+
+Types:
+
+```python
+from openai.types.responses import InputTokenCountResponse
+```
+
+Methods:
+
+- <code title="post /responses/input_tokens">client.responses.input_tokens.<a href="./src/openai/resources/responses/input_tokens.py">count</a>(\*\*<a href="src/openai/types/responses/input_token_count_params.py">params</a>) -> <a href="./src/openai/types/responses/input_token_count_response.py">InputTokenCountResponse</a></code>
+
+# Realtime
+
+Types:
+
+```python
+from openai.types.realtime import (
+    AudioTranscription,
+    ConversationCreatedEvent,
+    ConversationItem,
+    ConversationItemAdded,
+    ConversationItemCreateEvent,
+    ConversationItemCreatedEvent,
+    ConversationItemDeleteEvent,
+    ConversationItemDeletedEvent,
+    ConversationItemDone,
+    ConversationItemInputAudioTranscriptionCompletedEvent,
+    ConversationItemInputAudioTranscriptionDeltaEvent,
+    ConversationItemInputAudioTranscriptionFailedEvent,
+    ConversationItemInputAudioTranscriptionSegment,
+    ConversationItemRetrieveEvent,
+    ConversationItemTruncateEvent,
+    ConversationItemTruncatedEvent,
+    ConversationItemWithReference,
+    InputAudioBufferAppendEvent,
+    InputAudioBufferClearEvent,
+    InputAudioBufferClearedEvent,
+    InputAudioBufferCommitEvent,
+    InputAudioBufferCommittedEvent,
+    InputAudioBufferSpeechStartedEvent,
+    InputAudioBufferSpeechStoppedEvent,
+    InputAudioBufferTimeoutTriggered,
+    LogProbProperties,
+    McpListToolsCompleted,
+    McpListToolsFailed,
+    McpListToolsInProgress,
+    NoiseReductionType,
+    OutputAudioBufferClearEvent,
+    RateLimitsUpdatedEvent,
+    RealtimeAudioConfig,
+    RealtimeAudioConfigInput,
+    RealtimeAudioConfigOutput,
+    RealtimeAudioFormats,
+    RealtimeAudioInputTurnDetection,
+    RealtimeClientEvent,
+    RealtimeConversationItemAssistantMessage,
+    RealtimeConversationItemFunctionCall,
+    RealtimeConversationItemFunctionCallOutput,
+    RealtimeConversationItemSystemMessage,
+    RealtimeConversationItemUserMessage,
+    RealtimeError,
+    RealtimeErrorEvent,
+    RealtimeFunctionTool,
+    RealtimeMcpApprovalRequest,
+    RealtimeMcpApprovalResponse,
+    RealtimeMcpListTools,
+    RealtimeMcpProtocolError,
+    RealtimeMcpToolCall,
+    RealtimeMcpToolExecutionError,
+    RealtimeMcphttpError,
+    RealtimeResponse,
+    RealtimeResponseCreateAudioOutput,
+    RealtimeResponseCreateMcpTool,
+    RealtimeResponseCreateParams,
+    RealtimeResponseStatus,
+    RealtimeResponseUsage,
+    RealtimeResponseUsageInputTokenDetails,
+    RealtimeResponseUsageOutputTokenDetails,
+    RealtimeServerEvent,
+    RealtimeSession,
+    RealtimeSessionCreateRequest,
+    RealtimeToolChoiceConfig,
+    RealtimeToolsConfig,
+    RealtimeToolsConfigUnion,
+    RealtimeTracingConfig,
+    RealtimeTranscriptionSessionAudio,
+    RealtimeTranscriptionSessionAudioInput,
+    RealtimeTranscriptionSessionAudioInputTurnDetection,
+    RealtimeTranscriptionSessionCreateRequest,
+    RealtimeTruncation,
+    RealtimeTruncationRetentionRatio,
+    ResponseAudioDeltaEvent,
+    ResponseAudioDoneEvent,
+    ResponseAudioTranscriptDeltaEvent,
+    ResponseAudioTranscriptDoneEvent,
+    ResponseCancelEvent,
+    ResponseContentPartAddedEvent,
+    ResponseContentPartDoneEvent,
+    ResponseCreateEvent,
+    ResponseCreatedEvent,
+    ResponseDoneEvent,
+    ResponseFunctionCallArgumentsDeltaEvent,
+    ResponseFunctionCallArgumentsDoneEvent,
+    ResponseMcpCallArgumentsDelta,
+    ResponseMcpCallArgumentsDone,
+    ResponseMcpCallCompleted,
+    ResponseMcpCallFailed,
+    ResponseMcpCallInProgress,
+    ResponseOutputItemAddedEvent,
+    ResponseOutputItemDoneEvent,
+    ResponseTextDeltaEvent,
+    ResponseTextDoneEvent,
+    SessionCreatedEvent,
+    SessionUpdateEvent,
+    SessionUpdatedEvent,
+    TranscriptionSessionUpdate,
+    TranscriptionSessionUpdatedEvent,
+)
+```
+
+## ClientSecrets
+
+Types:
+
+```python
+from openai.types.realtime import (
+    RealtimeSessionClientSecret,
+    RealtimeSessionCreateResponse,
+    RealtimeTranscriptionSessionCreateResponse,
+    RealtimeTranscriptionSessionTurnDetection,
+    ClientSecretCreateResponse,
+)
+```
+
+Methods:
+
+- <code title="post /realtime/client_secrets">client.realtime.client_secrets.<a href="./src/openai/resources/realtime/client_secrets.py">create</a>(\*\*<a href="src/openai/types/realtime/client_secret_create_params.py">params</a>) -> <a href="./src/openai/types/realtime/client_secret_create_response.py">ClientSecretCreateResponse</a></code>
+
+## Calls
+
+Methods:
+
+- <code title="post /realtime/calls">client.realtime.calls.<a href="./src/openai/resources/realtime/calls.py">create</a>(\*\*<a href="src/openai/types/realtime/call_create_params.py">params</a>) -> HttpxBinaryResponseContent</code>
+- <code title="post /realtime/calls/{call_id}/accept">client.realtime.calls.<a href="./src/openai/resources/realtime/calls.py">accept</a>(call_id, \*\*<a href="src/openai/types/realtime/call_accept_params.py">params</a>) -> None</code>
+- <code title="post /realtime/calls/{call_id}/hangup">client.realtime.calls.<a href="./src/openai/resources/realtime/calls.py">hangup</a>(call_id) -> None</code>
+- <code title="post /realtime/calls/{call_id}/refer">client.realtime.calls.<a href="./src/openai/resources/realtime/calls.py">refer</a>(call_id, \*\*<a href="src/openai/types/realtime/call_refer_params.py">params</a>) -> None</code>
+- <code title="post /realtime/calls/{call_id}/reject">client.realtime.calls.<a href="./src/openai/resources/realtime/calls.py">reject</a>(call_id, \*\*<a href="src/openai/types/realtime/call_reject_params.py">params</a>) -> None</code>
+
+# Conversations
+
+Types:
+
+```python
+from openai.types.conversations import (
+    ComputerScreenshotContent,
+    Conversation,
+    ConversationDeleted,
+    ConversationDeletedResource,
+    Message,
+    SummaryTextContent,
+    TextContent,
+    InputTextContent,
+    OutputTextContent,
+    RefusalContent,
+    InputImageContent,
+    InputFileContent,
+)
+```
+
+Methods:
+
+- <code title="post /conversations">client.conversations.<a href="./src/openai/resources/conversations/conversations.py">create</a>(\*\*<a href="src/openai/types/conversations/conversation_create_params.py">params</a>) -> <a href="./src/openai/types/conversations/conversation.py">Conversation</a></code>
+- <code title="get /conversations/{conversation_id}">client.conversations.<a href="./src/openai/resources/conversations/conversations.py">retrieve</a>(conversation_id) -> <a href="./src/openai/types/conversations/conversation.py">Conversation</a></code>
+- <code title="post /conversations/{conversation_id}">client.conversations.<a href="./src/openai/resources/conversations/conversations.py">update</a>(conversation_id, \*\*<a href="src/openai/types/conversations/conversation_update_params.py">params</a>) -> <a href="./src/openai/types/conversations/conversation.py">Conversation</a></code>
+- <code title="delete /conversations/{conversation_id}">client.conversations.<a href="./src/openai/resources/conversations/conversations.py">delete</a>(conversation_id) -> <a href="./src/openai/types/conversations/conversation_deleted_resource.py">ConversationDeletedResource</a></code>
+
+## Items
+
+Types:
+
+```python
+from openai.types.conversations import ConversationItem, ConversationItemList
+```
+
+Methods:
+
+- <code title="post /conversations/{conversation_id}/items">client.conversations.items.<a href="./src/openai/resources/conversations/items.py">create</a>(conversation_id, \*\*<a href="src/openai/types/conversations/item_create_params.py">params</a>) -> <a href="./src/openai/types/conversations/conversation_item_list.py">ConversationItemList</a></code>
+- <code title="get /conversations/{conversation_id}/items/{item_id}">client.conversations.items.<a href="./src/openai/resources/conversations/items.py">retrieve</a>(item_id, \*, conversation_id, \*\*<a href="src/openai/types/conversations/item_retrieve_params.py">params</a>) -> <a href="./src/openai/types/conversations/conversation_item.py">ConversationItem</a></code>
+- <code title="get /conversations/{conversation_id}/items">client.conversations.items.<a href="./src/openai/resources/conversations/items.py">list</a>(conversation_id, \*\*<a href="src/openai/types/conversations/item_list_params.py">params</a>) -> <a href="./src/openai/types/conversations/conversation_item.py">SyncConversationCursorPage[ConversationItem]</a></code>
+- <code title="delete /conversations/{conversation_id}/items/{item_id}">client.conversations.items.<a href="./src/openai/resources/conversations/items.py">delete</a>(item_id, \*, conversation_id) -> <a href="./src/openai/types/conversations/conversation.py">Conversation</a></code>
+
+# Evals
+
+Types:
+
+```python
+from openai.types import (
+    EvalCustomDataSourceConfig,
+    EvalStoredCompletionsDataSourceConfig,
+    EvalCreateResponse,
+    EvalRetrieveResponse,
+    EvalUpdateResponse,
+    EvalListResponse,
+    EvalDeleteResponse,
+)
+```
+
+Methods:
+
+- <code title="post /evals">client.evals.<a href="./src/openai/resources/evals/evals.py">create</a>(\*\*<a href="src/openai/types/eval_create_params.py">params</a>) -> <a href="./src/openai/types/eval_create_response.py">EvalCreateResponse</a></code>
+- <code title="get /evals/{eval_id}">client.evals.<a href="./src/openai/resources/evals/evals.py">retrieve</a>(eval_id) -> <a href="./src/openai/types/eval_retrieve_response.py">EvalRetrieveResponse</a></code>
+- <code title="post /evals/{eval_id}">client.evals.<a href="./src/openai/resources/evals/evals.py">update</a>(eval_id, \*\*<a href="src/openai/types/eval_update_params.py">params</a>) -> <a href="./src/openai/types/eval_update_response.py">EvalUpdateResponse</a></code>
+- <code title="get /evals">client.evals.<a href="./src/openai/resources/evals/evals.py">list</a>(\*\*<a href="src/openai/types/eval_list_params.py">params</a>) -> <a href="./src/openai/types/eval_list_response.py">SyncCursorPage[EvalListResponse]</a></code>
+- <code title="delete /evals/{eval_id}">client.evals.<a href="./src/openai/resources/evals/evals.py">delete</a>(eval_id) -> <a href="./src/openai/types/eval_delete_response.py">EvalDeleteResponse</a></code>
+
+## Runs
+
+Types:
+
+```python
+from openai.types.evals import (
+    CreateEvalCompletionsRunDataSource,
+    CreateEvalJSONLRunDataSource,
+    EvalAPIError,
+    RunCreateResponse,
+    RunRetrieveResponse,
+    RunListResponse,
+    RunDeleteResponse,
+    RunCancelResponse,
+)
+```
+
+Methods:
+
+- <code title="post /evals/{eval_id}/runs">client.evals.runs.<a href="./src/openai/resources/evals/runs/runs.py">create</a>(eval_id, \*\*<a href="src/openai/types/evals/run_create_params.py">params</a>) -> <a href="./src/openai/types/evals/run_create_response.py">RunCreateResponse</a></code>
+- <code title="get /evals/{eval_id}/runs/{run_id}">client.evals.runs.<a href="./src/openai/resources/evals/runs/runs.py">retrieve</a>(run_id, \*, eval_id) -> <a href="./src/openai/types/evals/run_retrieve_response.py">RunRetrieveResponse</a></code>
+- <code title="get /evals/{eval_id}/runs">client.evals.runs.<a href="./src/openai/resources/evals/runs/runs.py">list</a>(eval_id, \*\*<a href="src/openai/types/evals/run_list_params.py">params</a>) -> <a href="./src/openai/types/evals/run_list_response.py">SyncCursorPage[RunListResponse]</a></code>
+- <code title="delete /evals/{eval_id}/runs/{run_id}">client.evals.runs.<a href="./src/openai/resources/evals/runs/runs.py">delete</a>(run_id, \*, eval_id) -> <a href="./src/openai/types/evals/run_delete_response.py">RunDeleteResponse</a></code>
+- <code title="post /evals/{eval_id}/runs/{run_id}">client.evals.runs.<a href="./src/openai/resources/evals/runs/runs.py">cancel</a>(run_id, \*, eval_id) -> <a href="./src/openai/types/evals/run_cancel_response.py">RunCancelResponse</a></code>
+
+### OutputItems
+
+Types:
+
+```python
+from openai.types.evals.runs import OutputItemRetrieveResponse, OutputItemListResponse
+```
+
+Methods:
+
+- <code title="get /evals/{eval_id}/runs/{run_id}/output_items/{output_item_id}">client.evals.runs.output_items.<a href="./src/openai/resources/evals/runs/output_items.py">retrieve</a>(output_item_id, \*, eval_id, run_id) -> <a href="./src/openai/types/evals/runs/output_item_retrieve_response.py">OutputItemRetrieveResponse</a></code>
+- <code title="get /evals/{eval_id}/runs/{run_id}/output_items">client.evals.runs.output_items.<a href="./src/openai/resources/evals/runs/output_items.py">list</a>(run_id, \*, eval_id, \*\*<a href="src/openai/types/evals/runs/output_item_list_params.py">params</a>) -> <a href="./src/openai/types/evals/runs/output_item_list_response.py">SyncCursorPage[OutputItemListResponse]</a></code>
+
+# Containers
+
+Types:
+
+```python
+from openai.types import ContainerCreateResponse, ContainerRetrieveResponse, ContainerListResponse
+```
+
+Methods:
+
+- <code title="post /containers">client.containers.<a href="./src/openai/resources/containers/containers.py">create</a>(\*\*<a href="src/openai/types/container_create_params.py">params</a>) -> <a href="./src/openai/types/container_create_response.py">ContainerCreateResponse</a></code>
+- <code title="get /containers/{container_id}">client.containers.<a href="./src/openai/resources/containers/containers.py">retrieve</a>(container_id) -> <a href="./src/openai/types/container_retrieve_response.py">ContainerRetrieveResponse</a></code>
+- <code title="get /containers">client.containers.<a href="./src/openai/resources/containers/containers.py">list</a>(\*\*<a href="src/openai/types/container_list_params.py">params</a>) -> <a href="./src/openai/types/container_list_response.py">SyncCursorPage[ContainerListResponse]</a></code>
+- <code title="delete /containers/{container_id}">client.containers.<a href="./src/openai/resources/containers/containers.py">delete</a>(container_id) -> None</code>
+
+## Files
+
+Types:
+
+```python
+from openai.types.containers import FileCreateResponse, FileRetrieveResponse, FileListResponse
+```
+
+Methods:
+
+- <code title="post /containers/{container_id}/files">client.containers.files.<a href="./src/openai/resources/containers/files/files.py">create</a>(container_id, \*\*<a href="src/openai/types/containers/file_create_params.py">params</a>) -> <a href="./src/openai/types/containers/file_create_response.py">FileCreateResponse</a></code>
+- <code title="get /containers/{container_id}/files/{file_id}">client.containers.files.<a href="./src/openai/resources/containers/files/files.py">retrieve</a>(file_id, \*, container_id) -> <a href="./src/openai/types/containers/file_retrieve_response.py">FileRetrieveResponse</a></code>
+- <code title="get /containers/{container_id}/files">client.containers.files.<a href="./src/openai/resources/containers/files/files.py">list</a>(container_id, \*\*<a href="src/openai/types/containers/file_list_params.py">params</a>) -> <a href="./src/openai/types/containers/file_list_response.py">SyncCursorPage[FileListResponse]</a></code>
+- <code title="delete /containers/{container_id}/files/{file_id}">client.containers.files.<a href="./src/openai/resources/containers/files/files.py">delete</a>(file_id, \*, container_id) -> None</code>
+
+### Content
+
+Methods:
+
+- <code title="get /containers/{container_id}/files/{file_id}/content">client.containers.files.content.<a href="./src/openai/resources/containers/files/content.py">retrieve</a>(file_id, \*, container_id) -> HttpxBinaryResponseContent</code>
+
+# Videos
+
+Types:
+
+```python
+from openai.types import (
+    Video,
+    VideoCreateError,
+    VideoModel,
+    VideoSeconds,
+    VideoSize,
+    VideoDeleteResponse,
+)
+```
+
+Methods:
+
+- <code title="post /videos">client.videos.<a href="./src/openai/resources/videos.py">create</a>(\*\*<a href="src/openai/types/video_create_params.py">params</a>) -> <a href="./src/openai/types/video.py">Video</a></code>
+- <code title="get /videos/{video_id}">client.videos.<a href="./src/openai/resources/videos.py">retrieve</a>(video_id) -> <a href="./src/openai/types/video.py">Video</a></code>
+- <code title="get /videos">client.videos.<a href="./src/openai/resources/videos.py">list</a>(\*\*<a href="src/openai/types/video_list_params.py">params</a>) -> <a href="./src/openai/types/video.py">SyncConversationCursorPage[Video]</a></code>
+- <code title="delete /videos/{video_id}">client.videos.<a href="./src/openai/resources/videos.py">delete</a>(video_id) -> <a href="./src/openai/types/video_delete_response.py">VideoDeleteResponse</a></code>
+- <code title="get /videos/{video_id}/content">client.videos.<a href="./src/openai/resources/videos.py">download_content</a>(video_id, \*\*<a href="src/openai/types/video_download_content_params.py">params</a>) -> HttpxBinaryResponseContent</code>
+- <code title="post /videos/{video_id}/remix">client.videos.<a href="./src/openai/resources/videos.py">remix</a>(video_id, \*\*<a href="src/openai/types/video_remix_params.py">params</a>) -> <a href="./src/openai/types/video.py">Video</a></code>
+- <code>client.videos.<a href="./src/openai/resources/videos.py">create_and_poll</a>(\*args) -> Video</code>
+
diff --git a/bin/check-release-environment b/bin/check-release-environment
index 2cc5ad6352..044ed525d1 100644
--- a/bin/check-release-environment
+++ b/bin/check-release-environment
@@ -7,7 +7,7 @@ if [ -z "${STAINLESS_API_KEY}" ]; then
 fi
 
 if [ -z "${PYPI_TOKEN}" ]; then
-  errors+=("The OPENAI_PYPI_TOKEN secret has not been set. Please set it in either this repository's secrets or your organization secrets.")
+  errors+=("The PYPI_TOKEN secret has not been set. Please set it in either this repository's secrets or your organization secrets.")
 fi
 
 lenErrors=${#errors[@]}
diff --git a/bin/publish-pypi b/bin/publish-pypi
index 05bfccbb71..826054e924 100644
--- a/bin/publish-pypi
+++ b/bin/publish-pypi
@@ -3,7 +3,4 @@
 set -eux
 mkdir -p dist
 rye build --clean
-# Patching importlib-metadata version until upstream library version is updated
-# https://github.com/pypa/twine/issues/977#issuecomment-2189800841
-"$HOME/.rye/self/bin/python3" -m pip install 'importlib-metadata==7.2.1'
 rye publish --yes --token=$PYPI_TOKEN
diff --git a/examples/assistant.py b/examples/assistant.py
deleted file mode 100644
index f6924a0c7d..0000000000
--- a/examples/assistant.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import openai
-
-# gets API Key from environment variable OPENAI_API_KEY
-client = openai.OpenAI()
-
-assistant = client.beta.assistants.create(
-    name="Math Tutor",
-    instructions="You are a personal math tutor. Write and run code to answer math questions.",
-    tools=[{"type": "code_interpreter"}],
-    model="gpt-4-1106-preview",
-)
-
-thread = client.beta.threads.create()
-
-message = client.beta.threads.messages.create(
-    thread_id=thread.id,
-    role="user",
-    content="I need to solve the equation `3x + 11 = 14`. Can you help me?",
-)
-
-run = client.beta.threads.runs.create_and_poll(
-    thread_id=thread.id,
-    assistant_id=assistant.id,
-    instructions="Please address the user as Jane Doe. The user has a premium account.",
-)
-
-print("Run completed with status: " + run.status)
-
-if run.status == "completed":
-    messages = client.beta.threads.messages.list(thread_id=thread.id)
-
-    print("messages: ")
-    for message in messages:
-        assert message.content[0].type == "text"
-        print({"role": message.role, "message": message.content[0].text.value})
-
-    client.beta.assistants.delete(assistant.id)
diff --git a/examples/assistant_stream.py b/examples/assistant_stream.py
deleted file mode 100644
index 0465d3930f..0000000000
--- a/examples/assistant_stream.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import openai
-
-# gets API Key from environment variable OPENAI_API_KEY
-client = openai.OpenAI()
-
-assistant = client.beta.assistants.create(
-    name="Math Tutor",
-    instructions="You are a personal math tutor. Write and run code to answer math questions.",
-    tools=[{"type": "code_interpreter"}],
-    model="gpt-4-1106-preview",
-)
-
-thread = client.beta.threads.create()
-
-message = client.beta.threads.messages.create(
-    thread_id=thread.id,
-    role="user",
-    content="I need to solve the equation `3x + 11 = 14`. Can you help me?",
-)
-
-print("starting run stream")
-
-stream = client.beta.threads.runs.create(
-    thread_id=thread.id,
-    assistant_id=assistant.id,
-    instructions="Please address the user as Jane Doe. The user has a premium account.",
-    stream=True,
-)
-
-for event in stream:
-    print(event.model_dump_json(indent=2, exclude_unset=True))
-
-client.beta.assistants.delete(assistant.id)
diff --git a/examples/assistant_stream_helpers.py b/examples/assistant_stream_helpers.py
deleted file mode 100644
index 7baec77c72..0000000000
--- a/examples/assistant_stream_helpers.py
+++ /dev/null
@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-from typing_extensions import override
-
-import openai
-from openai import AssistantEventHandler
-from openai.types.beta import AssistantStreamEvent
-from openai.types.beta.threads import Text, TextDelta
-from openai.types.beta.threads.runs import RunStep, RunStepDelta
-
-
-class EventHandler(AssistantEventHandler):
-    @override
-    def on_event(self, event: AssistantStreamEvent) -> None:
-        if event.event == "thread.run.step.created":
-            details = event.data.step_details
-            if details.type == "tool_calls":
-                print("Generating code to interpret:\n\n```py")
-        elif event.event == "thread.message.created":
-            print("\nResponse:\n")
-
-    @override
-    def on_text_delta(self, delta: TextDelta, snapshot: Text) -> None:
-        print(delta.value, end="", flush=True)
-
-    @override
-    def on_run_step_done(self, run_step: RunStep) -> None:
-        details = run_step.step_details
-        if details.type == "tool_calls":
-            for tool in details.tool_calls:
-                if tool.type == "code_interpreter":
-                    print("\n```\nExecuting code...")
-
-    @override
-    def on_run_step_delta(self, delta: RunStepDelta, snapshot: RunStep) -> None:
-        details = delta.step_details
-        if details is not None and details.type == "tool_calls":
-            for tool in details.tool_calls or []:
-                if tool.type == "code_interpreter" and tool.code_interpreter and tool.code_interpreter.input:
-                    print(tool.code_interpreter.input, end="", flush=True)
-
-
-def main() -> None:
-    client = openai.OpenAI()
-
-    assistant = client.beta.assistants.create(
-        name="Math Tutor",
-        instructions="You are a personal math tutor. Write and run code to answer math questions.",
-        tools=[{"type": "code_interpreter"}],
-        model="gpt-4-1106-preview",
-    )
-
-    try:
-        question = "I need to solve the equation `3x + 11 = 14`. Can you help me?"
-
-        thread = client.beta.threads.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": question,
-                },
-            ]
-        )
-        print(f"Question: {question}\n")
-
-        with client.beta.threads.runs.stream(
-            thread_id=thread.id,
-            assistant_id=assistant.id,
-            instructions="Please address the user as Jane Doe. The user has a premium account.",
-            event_handler=EventHandler(),
-        ) as stream:
-            stream.until_done()
-            print()
-    finally:
-        client.beta.assistants.delete(assistant.id)
-
-
-main()
diff --git a/examples/audio.py b/examples/audio.py
index 85f47bfb06..af41fe601b 100755
--- a/examples/audio.py
+++ b/examples/audio.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env rye run python
 
-import time
 from pathlib import Path
 
 from openai import OpenAI
@@ -12,8 +11,6 @@
 
 
 def main() -> None:
-    stream_to_speakers()
-
     # Create text-to-speech audio file
     with openai.audio.speech.with_streaming_response.create(
         model="tts-1",
@@ -37,28 +34,5 @@ def main() -> None:
     print(translation.text)
 
 
-def stream_to_speakers() -> None:
-    import pyaudio
-
-    player_stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=24000, output=True)
-
-    start_time = time.time()
-
-    with openai.audio.speech.with_streaming_response.create(
-        model="tts-1",
-        voice="alloy",
-        response_format="pcm",  # similar to WAV, but without a header chunk at the start.
-        input="""I see skies of blue and clouds of white
-                The bright blessed days, the dark sacred nights
-                And I think to myself
-                What a wonderful world""",
-    ) as response:
-        print(f"Time to first byte: {int((time.time() - start_time) * 1000)}ms")
-        for chunk in response.iter_bytes(chunk_size=1024):
-            player_stream.write(chunk)
-
-    print(f"Done in {int((time.time() - start_time) * 1000)}ms.")
-
-
 if __name__ == "__main__":
     main()
diff --git a/examples/image_stream.py b/examples/image_stream.py
new file mode 100644
index 0000000000..eab5932534
--- /dev/null
+++ b/examples/image_stream.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+
+import base64
+from pathlib import Path
+
+from openai import OpenAI
+
+client = OpenAI()
+
+
+def main() -> None:
+    """Example of OpenAI image streaming with partial images."""
+    stream = client.images.generate(
+        model="gpt-image-1",
+        prompt="A cute baby sea otter",
+        n=1,
+        size="1024x1024",
+        stream=True,
+        partial_images=3,
+    )
+
+    for event in stream:
+        if event.type == "image_generation.partial_image":
+            print(f"  Partial image {event.partial_image_index + 1}/3 received")
+            print(f"   Size: {len(event.b64_json)} characters (base64)")
+
+            # Save partial image to file
+            filename = f"partial_{event.partial_image_index + 1}.png"
+            image_data = base64.b64decode(event.b64_json)
+            with open(filename, "wb") as f:
+                f.write(image_data)
+            print(f"   💾 Saved to: {Path(filename).resolve()}")
+
+        elif event.type == "image_generation.completed":
+            print(f"\n✅ Final image completed!")
+            print(f"   Size: {len(event.b64_json)} characters (base64)")
+
+            # Save final image to file
+            filename = "final_image.png"
+            image_data = base64.b64decode(event.b64_json)
+            with open(filename, "wb") as f:
+                f.write(image_data)
+            print(f"   💾 Saved to: {Path(filename).resolve()}")
+
+        else:
+            print(f"❓ Unknown event: {event}")  # type: ignore[unreachable]
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as error:
+        print(f"Error generating image: {error}")
diff --git a/examples/parsing.py b/examples/parsing.py
index 17e5db52ec..906ce974c1 100644
--- a/examples/parsing.py
+++ b/examples/parsing.py
@@ -18,7 +18,7 @@ class MathResponse(BaseModel):
 
 client = OpenAI()
 
-completion = client.beta.chat.completions.parse(
+completion = client.chat.completions.parse(
     model="gpt-4o-2024-08-06",
     messages=[
         {"role": "system", "content": "You are a helpful math tutor."},
diff --git a/examples/parsing_stream.py b/examples/parsing_stream.py
index 6c6f078f77..1be7853098 100644
--- a/examples/parsing_stream.py
+++ b/examples/parsing_stream.py
@@ -18,7 +18,7 @@ class MathResponse(BaseModel):
 
 client = OpenAI()
 
-with client.beta.chat.completions.stream(
+with client.chat.completions.stream(
     model="gpt-4o-2024-08-06",
     messages=[
         {"role": "system", "content": "You are a helpful math tutor."},
diff --git a/examples/parsing_tools.py b/examples/parsing_tools.py
index c6065eeb7a..26921b1df6 100644
--- a/examples/parsing_tools.py
+++ b/examples/parsing_tools.py
@@ -57,7 +57,7 @@ class Query(BaseModel):
 
 client = OpenAI()
 
-completion = client.beta.chat.completions.parse(
+completion = client.chat.completions.parse(
     model="gpt-4o-2024-08-06",
     messages=[
         {
diff --git a/examples/parsing_tools_stream.py b/examples/parsing_tools_stream.py
index eea6f6a43a..b7dcd3d230 100644
--- a/examples/parsing_tools_stream.py
+++ b/examples/parsing_tools_stream.py
@@ -15,7 +15,7 @@ class GetWeather(BaseModel):
 client = OpenAI()
 
 
-with client.beta.chat.completions.stream(
+with client.chat.completions.stream(
     model="gpt-4o-2024-08-06",
     messages=[
         {
diff --git a/examples/realtime/audio_util.py b/examples/realtime/audio_util.py
index b073cc45be..954a508675 100644
--- a/examples/realtime/audio_util.py
+++ b/examples/realtime/audio_util.py
@@ -11,7 +11,7 @@
 import sounddevice as sd
 from pydub import AudioSegment
 
-from openai.resources.beta.realtime.realtime import AsyncRealtimeConnection
+from openai.resources.realtime.realtime import AsyncRealtimeConnection
 
 CHUNK_LENGTH_S = 0.05  # 100ms
 SAMPLE_RATE = 24000
diff --git a/examples/realtime/azure_realtime.py b/examples/realtime/azure_realtime.py
index de88d47052..3cf64b8be9 100644
--- a/examples/realtime/azure_realtime.py
+++ b/examples/realtime/azure_realtime.py
@@ -26,10 +26,16 @@ async def main() -> None:
         azure_ad_token_provider=get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default"),
         api_version="2024-10-01-preview",
     )
-    async with client.beta.realtime.connect(
-        model="gpt-4o-realtime-preview",  # deployment name for your model
+    async with client.realtime.connect(
+        model="gpt-realtime",  # deployment name for your model
     ) as connection:
-        await connection.session.update(session={"modalities": ["text"]})  # type: ignore
+        await connection.session.update(
+            session={
+                "output_modalities": ["text"],
+                "model": "gpt-realtime",
+                "type": "realtime",
+            }
+        )
         while True:
             user_input = input("Enter a message: ")
             if user_input == "q":
@@ -44,9 +50,9 @@ async def main() -> None:
             )
             await connection.response.create()
             async for event in connection:
-                if event.type == "response.text.delta":
+                if event.type == "response.output_text.delta":
                     print(event.delta, flush=True, end="")
-                elif event.type == "response.text.done":
+                elif event.type == "response.output_text.done":
                     print()
                 elif event.type == "response.done":
                     break
diff --git a/examples/realtime/push_to_talk_app.py b/examples/realtime/push_to_talk_app.py
index 8dc303a83a..acf38995b2 100755
--- a/examples/realtime/push_to_talk_app.py
+++ b/examples/realtime/push_to_talk_app.py
@@ -5,6 +5,8 @@
 # environment variable set, you can run this example with just     #
 #                                                                  #
 # `./examples/realtime/push_to_talk_app.py`                        #
+#                                                                  #
+# On Mac, you'll also need `brew install portaudio ffmpeg`           #
 ####################################################################
 #
 # /// script
@@ -36,8 +38,8 @@
 from textual.containers import Container
 
 from openai import AsyncOpenAI
-from openai.types.beta.realtime.session import Session
-from openai.resources.beta.realtime.realtime import AsyncRealtimeConnection
+from openai.types.realtime.session import Session
+from openai.resources.realtime.realtime import AsyncRealtimeConnection
 
 
 class SessionDisplay(Static):
@@ -152,13 +154,21 @@ async def on_mount(self) -> None:
         self.run_worker(self.send_mic_audio())
 
     async def handle_realtime_connection(self) -> None:
-        async with self.client.beta.realtime.connect(model="gpt-4o-realtime-preview") as conn:
+        async with self.client.realtime.connect(model="gpt-realtime") as conn:
             self.connection = conn
             self.connected.set()
 
             # note: this is the default and can be omitted
             # if you want to manually handle VAD yourself, then set `'turn_detection': None`
-            await conn.session.update(session={"turn_detection": {"type": "server_vad"}})
+            await conn.session.update(
+                session={
+                    "audio": {
+                        "input": {"turn_detection": {"type": "server_vad"}},
+                    },
+                    "model": "gpt-realtime",
+                    "type": "realtime",
+                }
+            )
 
             acc_items: dict[str, Any] = {}
 
@@ -174,7 +184,7 @@ async def handle_realtime_connection(self) -> None:
                     self.session = event.session
                     continue
 
-                if event.type == "response.audio.delta":
+                if event.type == "response.output_audio.delta":
                     if event.item_id != self.last_audio_item_id:
                         self.audio_player.reset_frame_count()
                         self.last_audio_item_id = event.item_id
@@ -183,7 +193,7 @@ async def handle_realtime_connection(self) -> None:
                     self.audio_player.add_data(bytes_data)
                     continue
 
-                if event.type == "response.audio_transcript.delta":
+                if event.type == "response.output_audio_transcript.delta":
                     try:
                         text = acc_items[event.item_id]
                     except KeyError:
diff --git a/examples/realtime/realtime.py b/examples/realtime/realtime.py
new file mode 100755
index 0000000000..214961e54c
--- /dev/null
+++ b/examples/realtime/realtime.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env rye run python
+import asyncio
+
+from openai import AsyncOpenAI
+
+# Azure OpenAI Realtime Docs
+
+# How-to: https://learn.microsoft.com/azure/ai-services/openai/how-to/realtime-audio
+# Supported models and API versions: https://learn.microsoft.com/azure/ai-services/openai/how-to/realtime-audio#supported-models
+# Entra ID auth: https://learn.microsoft.com/azure/ai-services/openai/how-to/managed-identity
+
+
+async def main() -> None:
+    """The following example demonstrates how to configure OpenAI to use the Realtime API.
+    For an audio example, see push_to_talk_app.py and update the client and model parameter accordingly.
+
+    When prompted for user input, type a message and hit enter to send it to the model.
+    Enter "q" to quit the conversation.
+    """
+
+    client = AsyncOpenAI()
+    async with client.realtime.connect(
+        model="gpt-realtime",
+    ) as connection:
+        await connection.session.update(
+            session={
+                "output_modalities": ["text"],
+                "model": "gpt-realtime",
+                "type": "realtime",
+            }
+        )
+        while True:
+            user_input = input("Enter a message: ")
+            if user_input == "q":
+                break
+
+            await connection.conversation.item.create(
+                item={
+                    "type": "message",
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": user_input}],
+                }
+            )
+            await connection.response.create()
+            async for event in connection:
+                if event.type == "response.output_text.delta":
+                    print(event.delta, flush=True, end="")
+                elif event.type == "response.output_text.done":
+                    print()
+                elif event.type == "response.done":
+                    break
+
+
+asyncio.run(main())
diff --git a/examples/responses/background.py b/examples/responses/background.py
new file mode 100644
index 0000000000..37b00f19be
--- /dev/null
+++ b/examples/responses/background.py
@@ -0,0 +1,46 @@
+from typing import List
+
+import rich
+from pydantic import BaseModel
+
+from openai import OpenAI
+
+
+class Step(BaseModel):
+    explanation: str
+    output: str
+
+
+class MathResponse(BaseModel):
+    steps: List[Step]
+    final_answer: str
+
+
+client = OpenAI()
+id = None
+
+with client.responses.create(
+    input="solve 8x + 31 = 2",
+    model="gpt-4o-2024-08-06",
+    background=True,
+    stream=True,
+) as stream:
+    for event in stream:
+        if event.type == "response.created":
+            id = event.response.id
+        if "output_text" in event.type:
+            rich.print(event)
+        if event.sequence_number == 10:
+            break
+
+print("Interrupted. Continuing...")
+
+assert id is not None
+with client.responses.retrieve(
+    response_id=id,
+    stream=True,
+    starting_after=10,
+) as stream:
+    for event in stream:
+        if "output_text" in event.type:
+            rich.print(event)
diff --git a/examples/responses/background_async.py b/examples/responses/background_async.py
new file mode 100644
index 0000000000..9dbc78b784
--- /dev/null
+++ b/examples/responses/background_async.py
@@ -0,0 +1,52 @@
+import asyncio
+from typing import List
+
+import rich
+from pydantic import BaseModel
+
+from openai._client import AsyncOpenAI
+
+
+class Step(BaseModel):
+    explanation: str
+    output: str
+
+
+class MathResponse(BaseModel):
+    steps: List[Step]
+    final_answer: str
+
+
+async def main() -> None:
+    client = AsyncOpenAI()
+    id = None
+
+    async with await client.responses.create(
+        input="solve 8x + 31 = 2",
+        model="gpt-4o-2024-08-06",
+        background=True,
+        stream=True,
+    ) as stream:
+        async for event in stream:
+            if event.type == "response.created":
+                id = event.response.id
+            if "output_text" in event.type:
+                rich.print(event)
+            if event.sequence_number == 10:
+                break
+
+    print("Interrupted. Continuing...")
+
+    assert id is not None
+    async with await client.responses.retrieve(
+        response_id=id,
+        stream=True,
+        starting_after=10,
+    ) as stream:
+        async for event in stream:
+            if "output_text" in event.type:
+                rich.print(event)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/responses/background_streaming.py b/examples/responses/background_streaming.py
new file mode 100755
index 0000000000..ed830d9910
--- /dev/null
+++ b/examples/responses/background_streaming.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env -S rye run python
+from typing import List
+
+import rich
+from pydantic import BaseModel
+
+from openai import OpenAI
+
+
+class Step(BaseModel):
+    explanation: str
+    output: str
+
+
+class MathResponse(BaseModel):
+    steps: List[Step]
+    final_answer: str
+
+
+client = OpenAI()
+id = None
+with client.responses.stream(
+    input="solve 8x + 31 = 2",
+    model="gpt-4o-2024-08-06",
+    text_format=MathResponse,
+    background=True,
+) as stream:
+    for event in stream:
+        if event.type == "response.created":
+            id = event.response.id
+        if "output_text" in event.type:
+            rich.print(event)
+        if event.sequence_number == 10:
+            break
+
+print("Interrupted. Continuing...")
+
+assert id is not None
+with client.responses.stream(
+    response_id=id,
+    starting_after=10,
+    text_format=MathResponse,
+) as stream:
+    for event in stream:
+        if "output_text" in event.type:
+            rich.print(event)
+
+    rich.print(stream.get_final_response())
diff --git a/examples/responses/background_streaming_async.py b/examples/responses/background_streaming_async.py
new file mode 100644
index 0000000000..178150dc15
--- /dev/null
+++ b/examples/responses/background_streaming_async.py
@@ -0,0 +1,53 @@
+import asyncio
+from typing import List
+
+import rich
+from pydantic import BaseModel
+
+from openai import AsyncOpenAI
+
+
+class Step(BaseModel):
+    explanation: str
+    output: str
+
+
+class MathResponse(BaseModel):
+    steps: List[Step]
+    final_answer: str
+
+
+async def main() -> None:
+    client = AsyncOpenAI()
+    id = None
+    async with client.responses.stream(
+        input="solve 8x + 31 = 2",
+        model="gpt-4o-2024-08-06",
+        text_format=MathResponse,
+        background=True,
+    ) as stream:
+        async for event in stream:
+            if event.type == "response.created":
+                id = event.response.id
+            if "output_text" in event.type:
+                rich.print(event)
+            if event.sequence_number == 10:
+                break
+
+    print("Interrupted. Continuing...")
+
+    assert id is not None
+    async with client.responses.stream(
+        response_id=id,
+        starting_after=10,
+        text_format=MathResponse,
+    ) as stream:
+        async for event in stream:
+            if "output_text" in event.type:
+                rich.print(event)
+
+        rich.print(stream.get_final_response())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/responses_input_tokens.py b/examples/responses_input_tokens.py
new file mode 100644
index 0000000000..39809b928f
--- /dev/null
+++ b/examples/responses_input_tokens.py
@@ -0,0 +1,54 @@
+from typing import List
+
+from openai import OpenAI
+from openai.types.responses.tool_param import ToolParam
+from openai.types.responses.response_input_item_param import ResponseInputItemParam
+
+
+def main() -> None:
+    client = OpenAI()
+    tools: List[ToolParam] = [
+        {
+            "type": "function",
+            "name": "get_current_weather",
+            "description": "Get current weather in a given location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "City and state, e.g. San Francisco, CA",
+                    },
+                    "unit": {
+                        "type": "string",
+                        "enum": ["c", "f"],
+                        "description": "Temperature unit to use",
+                    },
+                },
+                "required": ["location", "unit"],
+                "additionalProperties": False,
+            },
+            "strict": True,
+        }
+    ]
+
+    input_items: List[ResponseInputItemParam] = [
+        {
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_text", "text": "What's the weather in San Francisco today?"}],
+        }
+    ]
+
+    response = client.responses.input_tokens.count(
+        model="gpt-5",
+        instructions="You are a concise assistant.",
+        input=input_items,
+        tools=tools,
+        tool_choice={"type": "function", "name": "get_current_weather"},
+    )
+    print(f"input tokens: {response.input_tokens}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/speech_to_text.py b/examples/speech_to_text.py
new file mode 100755
index 0000000000..cc3f56b424
--- /dev/null
+++ b/examples/speech_to_text.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env rye run python
+
+import asyncio
+
+from openai import AsyncOpenAI
+from openai.helpers import Microphone
+
+# gets OPENAI_API_KEY from your environment variables
+openai = AsyncOpenAI()
+
+
+async def main() -> None:
+    print("Recording for the next 10 seconds...")
+    recording = await Microphone(timeout=10).record()
+    print("Recording complete")
+    transcription = await openai.audio.transcriptions.create(
+        model="whisper-1",
+        file=recording,
+    )
+
+    print(transcription.text)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/text_to_speech.py b/examples/text_to_speech.py
new file mode 100755
index 0000000000..ac8b12b0ab
--- /dev/null
+++ b/examples/text_to_speech.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env rye run python
+
+import time
+import asyncio
+
+from openai import AsyncOpenAI
+from openai.helpers import LocalAudioPlayer
+
+# gets OPENAI_API_KEY from your environment variables
+openai = AsyncOpenAI()
+
+
+async def main() -> None:
+    start_time = time.time()
+
+    async with openai.audio.speech.with_streaming_response.create(
+        model="tts-1",
+        voice="alloy",
+        response_format="pcm",  # similar to WAV, but without a header chunk at the start.
+        input="""I see skies of blue and clouds of white
+                The bright blessed days, the dark sacred nights
+                And I think to myself
+                What a wonderful world""",
+    ) as response:
+        print(f"Time to first byte: {int((time.time() - start_time) * 1000)}ms")
+        await LocalAudioPlayer().play(response)
+        print(f"Time to play: {int((time.time() - start_time) * 1000)}ms")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/video.py b/examples/video.py
new file mode 100644
index 0000000000..ee89e64697
--- /dev/null
+++ b/examples/video.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env -S poetry run python
+
+import asyncio
+
+from openai import AsyncOpenAI
+
+client = AsyncOpenAI()
+
+
+async def main() -> None:
+    video = await client.videos.create_and_poll(
+        model="sora-2",
+        prompt="A video of the words 'Thank you' in sparkling letters",
+    )
+
+    if video.status == "completed":
+        print("Video successfully completed: ", video)
+    else:
+        print("Video creation failed. Status: ", video.status)
+
+
+asyncio.run(main())
diff --git a/helpers.md b/helpers.md
index 77823fa750..89ff4498cf 100644
--- a/helpers.md
+++ b/helpers.md
@@ -2,7 +2,7 @@
 
 The OpenAI API supports extracting JSON from the model with the `response_format` request param, for more details on the API, see [this guide](https://platform.openai.com/docs/guides/structured-outputs).
 
-The SDK provides a `client.beta.chat.completions.parse()` method which is a wrapper over the `client.chat.completions.create()` that
+The SDK provides a `client.chat.completions.parse()` method which is a wrapper over the `client.chat.completions.create()` that
 provides richer integrations with Python specific types & returns a `ParsedChatCompletion` object, which is a subclass of the standard `ChatCompletion` class.
 
 ## Auto-parsing response content with Pydantic models
@@ -24,7 +24,7 @@ class MathResponse(BaseModel):
     final_answer: str
 
 client = OpenAI()
-completion = client.beta.chat.completions.parse(
+completion = client.chat.completions.parse(
     model="gpt-4o-2024-08-06",
     messages=[
         {"role": "system", "content": "You are a helpful math tutor."},
@@ -44,6 +44,7 @@ else:
 ## Auto-parsing function tool calls
 
 The `.parse()` method will also automatically parse `function` tool calls if:
+
 - You use the `openai.pydantic_function_tool()` helper method
 - You mark your tool schema with `"strict": True`
 
@@ -96,7 +97,7 @@ class Query(BaseModel):
     order_by: OrderBy
 
 client = openai.OpenAI()
-completion = client.beta.chat.completions.parse(
+completion = client.chat.completions.parse(
     model="gpt-4o-2024-08-06",
     messages=[
         {
@@ -121,7 +122,7 @@ print(tool_call.function.parsed_arguments.table_name)
 
 ### Differences from `.create()`
 
-The `beta.chat.completions.parse()` method imposes some additional restrictions on it's usage that `chat.completions.create()` does not. 
+The `chat.completions.parse()` method imposes some additional restrictions on it's usage that `chat.completions.create()` does not.
 
 - If the completion completes with `finish_reason` set to `length` or `content_filter`, the `LengthFinishReasonError` / `ContentFilterFinishReasonError` errors will be raised.
 - Only strict function tools can be passed, e.g. `{'type': 'function', 'function': {..., 'strict': True}}`
@@ -132,7 +133,7 @@ OpenAI supports streaming responses when interacting with the [Chat Completion](
 
 ## Chat Completions API
 
-The SDK provides a `.beta.chat.completions.stream()` method that wraps the `.chat.completions.create(stream=True)` stream providing a more granular event API & automatic accumulation of each delta.
+The SDK provides a `.chat.completions.stream()` method that wraps the `.chat.completions.create(stream=True)` stream providing a more granular event API & automatic accumulation of each delta.
 
 It also supports all aforementioned [parsing helpers](#structured-outputs-parsing-helpers).
 
@@ -143,7 +144,7 @@ from openai import AsyncOpenAI
 
 client = AsyncOpenAI()
 
-async with client.beta.chat.completions.stream(
+async with client.chat.completions.stream(
     model='gpt-4o-2024-08-06',
     messages=[...],
 ) as stream:
@@ -263,7 +264,7 @@ A handful of helper methods are provided on the stream class for additional conv
 Returns the accumulated `ParsedChatCompletion` object
 
 ```py
-async with client.beta.chat.completions.stream(...) as stream:
+async with client.chat.completions.stream(...) as stream:
     ...
 
 completion = await stream.get_final_completion()
@@ -275,7 +276,7 @@ print(completion.choices[0].message)
 If you want to wait for the stream to complete, you can use the `.until_done()` method.
 
 ```py
-async with client.beta.chat.completions.stream(...) as stream:
+async with client.chat.completions.stream(...) as stream:
     await stream.until_done()
     # stream is now finished
 ```
@@ -513,4 +514,5 @@ client.beta.vector_stores.files.upload_and_poll(...)
 client.beta.vector_stores.files.create_and_poll(...)
 client.beta.vector_stores.file_batches.create_and_poll(...)
 client.beta.vector_stores.file_batches.upload_and_poll(...)
+client.videos.create_and_poll(...)
 ```
diff --git a/mypy.ini b/mypy.ini
deleted file mode 100644
index 660f1a086e..0000000000
--- a/mypy.ini
+++ /dev/null
@@ -1,53 +0,0 @@
-[mypy]
-pretty = True
-show_error_codes = True
-
-# Exclude _files.py and _logs.py because mypy isn't smart enough to apply
-# the correct type narrowing and as this is an internal module
-# it's fine to just use Pyright.
-#
-# We also exclude our `tests` as mypy doesn't always infer
-# types correctly and Pyright will still catch any type errors.
-
-# realtime examples use inline `uv` script dependencies
-# which means it can't be type checked
-exclude = ^(src/openai/_files\.py|_dev/.*\.py|tests/.*|src/openai/_utils/_logs\.py|examples/realtime/audio_util\.py|examples/realtime/push_to_talk_app\.py)$
-
-strict_equality = True
-implicit_reexport = True
-check_untyped_defs = True
-no_implicit_optional = True
-
-warn_return_any = True
-warn_unreachable = True
-warn_unused_configs = True
-
-# Turn these options off as it could cause conflicts
-# with the Pyright options.
-warn_unused_ignores = False
-warn_redundant_casts = False
-
-disallow_any_generics = True
-disallow_untyped_defs = True
-disallow_untyped_calls = True
-disallow_subclassing_any = True
-disallow_incomplete_defs = True
-disallow_untyped_decorators = True
-cache_fine_grained = True
-
-# By default, mypy reports an error if you assign a value to the result
-# of a function call that doesn't return anything. We do this in our test
-# cases:
-# ```
-# result = ...
-# assert result is None
-# ```
-# Changing this codegen to make mypy happy would increase complexity
-# and would not be worth it.
-disable_error_code = func-returns-value,overload-cannot-match
-
-# https://github.com/python/mypy/issues/12162
-[mypy.overrides]
-module = "black.files.*"
-ignore_errors = true
-ignore_missing_imports = true
diff --git a/pyproject.toml b/pyproject.toml
index 3088eb2fb2..75118d46be 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "openai"
-version = "1.66.3"
+version = "2.8.1"
 description = "The official Python library for the openai API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -15,17 +15,17 @@ dependencies = [
     "distro>=1.7.0, <2",
     "sniffio",
     "tqdm > 4",
-    "jiter>=0.4.0, <1",
+    "jiter>=0.10.0, <1",
 ]
-requires-python = ">= 3.8"
+requires-python = ">= 3.9"
 classifiers = [
   "Typing :: Typed",
   "Intended Audience :: Developers",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Operating System :: OS Independent",
   "Operating System :: POSIX",
   "Operating System :: MacOS",
@@ -43,14 +43,16 @@ Repository = "https://github.com/openai/openai-python"
 openai = "openai.cli:main"
 
 [project.optional-dependencies]
-realtime = ["websockets >= 13, < 15"]
+aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.9"]
+realtime = ["websockets >= 13, < 16"]
 datalib = ["numpy >= 1", "pandas >= 1.2.3", "pandas-stubs >= 1.1.0.11"]
+voice_helpers = ["sounddevice>=0.5.1", "numpy>=2.0.2"]
 
 [tool.rye]
 managed = true
 # version pins are in requirements-dev.lock
 dev-dependencies = [
-    "pyright>=1.1.359",
+    "pyright==1.1.399",
     "mypy",
     "respx",
     "pytest",
@@ -61,12 +63,14 @@ dev-dependencies = [
     "dirty-equals>=0.6.0",
     "importlib-metadata>=6.7.0",
     "rich>=13.7.1",
-    "inline-snapshot >=0.7.0",
+    "inline-snapshot>=0.28.0",
     "azure-identity >=1.14.1",
     "types-tqdm > 4",
     "types-pyaudio > 0",
     "trio >=0.22.2",
     "nest_asyncio==1.6.0",
+    "pytest-xdist>=3.6.1",
+    "griffe>=1",
 ]
 
 [tool.rye.scripts]
@@ -99,7 +103,7 @@ typecheck = { chain = [
 "typecheck:mypy" = "mypy ."
 
 [build-system]
-requires = ["hatchling", "hatch-fancy-pypi-readme"]
+requires = ["hatchling==1.26.3", "hatch-fancy-pypi-readme"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build]
@@ -138,7 +142,7 @@ replacement = '[\1](https://github.com/openai/openai-python/tree/main/\g<2>)'
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "--tb=short"
+addopts = "--tb=short -n auto"
 xfail_strict = true
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "session"
@@ -146,17 +150,21 @@ filterwarnings = [
   "error"
 ]
 
+[tool.inline-snapshot]
+format-command="ruff format --stdin-filename {filename}"
+
 [tool.pyright]
 # this enables practically every flag given by pyright.
 # there are a couple of flags that are still disabled by
 # default in strict mode as they are experimental and niche.
 typeCheckingMode = "strict"
-pythonVersion = "3.8"
+pythonVersion = "3.9"
 
 exclude = [
     "_dev",
     ".venv",
     ".nox",
+    ".git",
 
     # uses inline `uv` script dependencies
     # which means it can't be type checked
@@ -165,15 +173,76 @@ exclude = [
 ]
 
 reportImplicitOverride = true
+reportOverlappingOverload = false
 
 reportImportCycles = false
 reportPrivateUsage = false
 
+[tool.mypy]
+pretty = true
+show_error_codes = true
+
+# Exclude _files.py because mypy isn't smart enough to apply
+# the correct type narrowing and as this is an internal module
+# it's fine to just use Pyright.
+#
+# We also exclude our `tests` as mypy doesn't always infer
+# types correctly and Pyright will still catch any type errors.
+#
+# realtime examples use inline `uv` script dependencies
+# which means it can't be type checked
+exclude = [
+  'src/openai/_files.py',
+  '_dev/.*.py',
+  'tests/.*',
+  'src/openai/_utils/_logs.py',
+  'examples/realtime/audio_util.py',
+  'examples/realtime/push_to_talk_app.py',
+]
+
+strict_equality = true
+implicit_reexport = true
+check_untyped_defs = true
+no_implicit_optional = true
+
+warn_return_any = true
+warn_unreachable = true
+warn_unused_configs = true
+
+# Turn these options off as it could cause conflicts
+# with the Pyright options.
+warn_unused_ignores = false
+warn_redundant_casts = false
+
+disallow_any_generics = true
+disallow_untyped_defs = true
+disallow_untyped_calls = true
+disallow_subclassing_any = true
+disallow_incomplete_defs = true
+disallow_untyped_decorators = true
+cache_fine_grained = true
+
+# By default, mypy reports an error if you assign a value to the result
+# of a function call that doesn't return anything. We do this in our test
+# cases:
+# ```
+# result = ...
+# assert result is None
+# ```
+# Changing this codegen to make mypy happy would increase complexity
+# and would not be worth it.
+disable_error_code = "func-returns-value,overload-cannot-match"
+
+# https://github.com/python/mypy/issues/12162
+[[tool.mypy.overrides]]
+module = "black.files.*"
+ignore_errors = true
+ignore_missing_imports = true
 
 [tool.ruff]
 line-length = 120
 output-format = "grouped"
-target-version = "py37"
+target-version = "py38"
 
 [tool.ruff.format]
 docstring-code-format = true
@@ -186,6 +255,8 @@ select = [
   "B",
   # remove unused imports
   "F401",
+  # check for missing future annotations
+  "FA102",
   # bare except statements
   "E722",
   # unused arguments
@@ -208,6 +279,8 @@ unfixable = [
   "T203",
 ]
 
+extend-safe-fixes = ["FA102"]
+
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
 "functools.lru_cache".msg = "This function does not retain type information for the wrapped function's arguments; The `lru_cache` function from `_utils` should be used instead"
 
diff --git a/requirements-dev.lock b/requirements-dev.lock
index 5599057b66..b454537b96 100644
--- a/requirements-dev.lock
+++ b/requirements-dev.lock
@@ -7,8 +7,16 @@
 #   all-features: true
 #   with-sources: false
 #   generate-hashes: false
+#   universal: false
 
 -e file:.
+aiohappyeyeballs==2.6.1
+    # via aiohttp
+aiohttp==3.12.13
+    # via httpx-aiohttp
+    # via openai
+aiosignal==1.3.2
+    # via aiohttp
 annotated-types==0.6.0
     # via pydantic
 anyio==4.1.0
@@ -18,25 +26,26 @@ argcomplete==3.1.2
     # via nox
 asttokens==2.4.1
     # via inline-snapshot
+async-timeout==5.0.1
+    # via aiohttp
 attrs==24.2.0
+    # via aiohttp
     # via outcome
     # via trio
 azure-core==1.31.0
     # via azure-identity
 azure-identity==1.19.0
-black==24.10.0
-    # via inline-snapshot
 certifi==2023.7.22
     # via httpcore
     # via httpx
     # via requests
 cffi==1.16.0
     # via cryptography
+    # via sounddevice
 charset-normalizer==3.3.2
     # via requests
-click==8.1.7
-    # via black
-    # via inline-snapshot
+colorama==0.4.6
+    # via griffe
 colorlog==6.7.0
     # via nox
 cryptography==42.0.7
@@ -52,27 +61,37 @@ exceptiongroup==1.2.2
     # via anyio
     # via pytest
     # via trio
-executing==2.1.0
+execnet==2.1.1
+    # via pytest-xdist
+executing==2.2.0
     # via inline-snapshot
 filelock==3.12.4
     # via virtualenv
-h11==0.14.0
+frozenlist==1.7.0
+    # via aiohttp
+    # via aiosignal
+griffe==1.13.0
+h11==0.16.0
     # via httpcore
-httpcore==1.0.2
+httpcore==1.0.9
     # via httpx
 httpx==0.28.1
+    # via httpx-aiohttp
     # via openai
     # via respx
+httpx-aiohttp==0.1.9
+    # via openai
 idna==3.4
     # via anyio
     # via httpx
     # via requests
     # via trio
+    # via yarl
 importlib-metadata==7.0.0
 iniconfig==2.0.0
     # via pytest
-inline-snapshot==0.10.2
-jiter==0.5.0
+inline-snapshot==0.28.0
+jiter==0.11.0
     # via openai
 markdown-it-py==3.0.0
     # via rich
@@ -83,51 +102,56 @@ msal==1.31.0
     # via msal-extensions
 msal-extensions==1.2.0
     # via azure-identity
+multidict==6.5.0
+    # via aiohttp
+    # via yarl
 mypy==1.14.1
 mypy-extensions==1.0.0
-    # via black
     # via mypy
 nest-asyncio==1.6.0
 nodeenv==1.8.0
     # via pyright
 nox==2023.4.22
-numpy==1.26.3
+numpy==2.0.2
     # via openai
     # via pandas
     # via pandas-stubs
 outcome==1.3.0.post0
     # via trio
 packaging==23.2
-    # via black
     # via nox
     # via pytest
-pandas==2.1.4
+pandas==2.2.3
     # via openai
 pandas-stubs==2.1.4.231227
     # via openai
-pathspec==0.12.1
-    # via black
 platformdirs==3.11.0
-    # via black
     # via virtualenv
 pluggy==1.5.0
     # via pytest
 portalocker==2.10.1
     # via msal-extensions
-pycparser==2.22
+propcache==0.3.2
+    # via aiohttp
+    # via yarl
+pycparser==2.23
     # via cffi
-pydantic==2.10.3
+pydantic==2.11.9
     # via openai
-pydantic-core==2.27.1
+pydantic-core==2.33.2
     # via pydantic
 pygments==2.18.0
+    # via pytest
     # via rich
 pyjwt==2.8.0
     # via msal
-pyright==1.1.392.post0
-pytest==8.3.3
+pyright==1.1.399
+pytest==8.4.1
+    # via inline-snapshot
     # via pytest-asyncio
+    # via pytest-xdist
 pytest-asyncio==0.24.0
+pytest-xdist==3.7.0
 python-dateutil==2.8.2
     # via pandas
     # via time-machine
@@ -153,11 +177,11 @@ sniffio==1.3.0
     # via trio
 sortedcontainers==2.4.0
     # via trio
+sounddevice==0.5.1
+    # via openai
 time-machine==2.9.0
-toml==0.10.2
-    # via inline-snapshot
 tomli==2.0.2
-    # via black
+    # via inline-snapshot
     # via mypy
     # via pytest
 tqdm==4.66.5
@@ -166,25 +190,28 @@ trio==0.27.0
 types-pyaudio==0.2.16.20240516
 types-pytz==2024.2.0.20241003
     # via pandas-stubs
-types-toml==0.10.8.20240310
-    # via inline-snapshot
 types-tqdm==4.66.0.20240417
 typing-extensions==4.12.2
     # via azure-core
     # via azure-identity
-    # via black
+    # via multidict
     # via mypy
     # via openai
     # via pydantic
     # via pydantic-core
     # via pyright
+    # via typing-inspection
+typing-inspection==0.4.1
+    # via pydantic
 tzdata==2024.1
     # via pandas
 urllib3==2.2.1
     # via requests
 virtualenv==20.24.5
     # via nox
-websockets==14.2
+websockets==15.0.1
     # via openai
+yarl==1.20.1
+    # via aiohttp
 zipp==3.17.0
     # via importlib-metadata
diff --git a/requirements.lock b/requirements.lock
index cbdff94fa3..b047cb3f88 100644
--- a/requirements.lock
+++ b/requirements.lock
@@ -7,31 +7,55 @@
 #   all-features: true
 #   with-sources: false
 #   generate-hashes: false
+#   universal: false
 
 -e file:.
+aiohappyeyeballs==2.6.1
+    # via aiohttp
+aiohttp==3.12.13
+    # via httpx-aiohttp
+    # via openai
+aiosignal==1.3.2
+    # via aiohttp
 annotated-types==0.6.0
     # via pydantic
 anyio==4.1.0
     # via httpx
     # via openai
+async-timeout==5.0.1
+    # via aiohttp
+attrs==25.3.0
+    # via aiohttp
 certifi==2023.7.22
     # via httpcore
     # via httpx
+cffi==1.17.1
+    # via sounddevice
 distro==1.8.0
     # via openai
 exceptiongroup==1.2.2
     # via anyio
-h11==0.14.0
+frozenlist==1.7.0
+    # via aiohttp
+    # via aiosignal
+h11==0.16.0
     # via httpcore
-httpcore==1.0.2
+httpcore==1.0.9
     # via httpx
 httpx==0.28.1
+    # via httpx-aiohttp
+    # via openai
+httpx-aiohttp==0.1.9
     # via openai
 idna==3.4
     # via anyio
     # via httpx
-jiter==0.6.1
+    # via yarl
+jiter==0.11.0
     # via openai
+multidict==6.5.0
+    # via aiohttp
+    # via yarl
 numpy==2.0.2
     # via openai
     # via pandas
@@ -40,9 +64,14 @@ pandas==2.2.3
     # via openai
 pandas-stubs==2.2.2.240807
     # via openai
-pydantic==2.10.3
+propcache==0.3.2
+    # via aiohttp
+    # via yarl
+pycparser==2.23
+    # via cffi
+pydantic==2.11.9
     # via openai
-pydantic-core==2.27.1
+pydantic-core==2.33.2
     # via pydantic
 python-dateutil==2.9.0.post0
     # via pandas
@@ -53,15 +82,23 @@ six==1.16.0
 sniffio==1.3.0
     # via anyio
     # via openai
+sounddevice==0.5.1
+    # via openai
 tqdm==4.66.5
     # via openai
 types-pytz==2024.2.0.20241003
     # via pandas-stubs
 typing-extensions==4.12.2
+    # via multidict
     # via openai
     # via pydantic
     # via pydantic-core
-tzdata==2024.1
+    # via typing-inspection
+typing-inspection==0.4.1
+    # via pydantic
+tzdata==2025.2
     # via pandas
-websockets==14.2
+websockets==15.0.1
     # via openai
+yarl==1.20.1
+    # via aiohttp
diff --git a/scripts/bootstrap b/scripts/bootstrap
index 9910ec05fc..953993addb 100755
--- a/scripts/bootstrap
+++ b/scripts/bootstrap
@@ -4,10 +4,18 @@ set -e
 
 cd "$(dirname "$0")/.."
 
-if ! command -v rye >/dev/null 2>&1 && [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ]; then
+if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ] && [ "$SKIP_BREW" != "1" ] && [ -t 0 ]; then
   brew bundle check >/dev/null 2>&1 || {
-    echo "==> Installing Homebrew dependencies…"
-    brew bundle
+    echo -n "==> Install Homebrew dependencies? (y/N): "
+    read -r response
+    case "$response" in
+      [yY][eE][sS]|[yY])
+        brew bundle
+        ;;
+      *)
+        ;;
+    esac
+    echo
   }
 fi
 
diff --git a/scripts/detect-breaking-changes b/scripts/detect-breaking-changes
new file mode 100755
index 0000000000..833872ef3a
--- /dev/null
+++ b/scripts/detect-breaking-changes
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+echo "==> Detecting breaking changes"
+
+TEST_PATHS=(
+	tests/api_resources
+	tests/test_client.py
+	tests/test_response.py
+	tests/test_legacy_response.py
+)
+
+for PATHSPEC in "${TEST_PATHS[@]}"; do
+    # Try to check out previous versions of the test files
+    # with the current SDK.
+    git checkout "$1" -- "${PATHSPEC}" 2>/dev/null || true
+done
+
+# Instead of running the tests, use the linter to check if an
+# older test is no longer compatible with the latest SDK.
+./scripts/lint
diff --git a/scripts/detect-breaking-changes.py b/scripts/detect-breaking-changes.py
new file mode 100644
index 0000000000..3a30f3db2f
--- /dev/null
+++ b/scripts/detect-breaking-changes.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import sys
+from typing import Iterator
+from pathlib import Path
+
+import rich
+import griffe
+from rich.text import Text
+from rich.style import Style
+
+
+def public_members(obj: griffe.Object | griffe.Alias) -> dict[str, griffe.Object | griffe.Alias]:
+    if isinstance(obj, griffe.Alias):
+        # ignore imports for now, they're technically part of the public API
+        # but we don't have good preventative measures in place to prevent
+        # changing them
+        return {}
+
+    return {name: value for name, value in obj.all_members.items() if not name.startswith("_")}
+
+
+def find_breaking_changes(
+    new_obj: griffe.Object | griffe.Alias,
+    old_obj: griffe.Object | griffe.Alias,
+    *,
+    path: list[str],
+) -> Iterator[Text | str]:
+    new_members = public_members(new_obj)
+    old_members = public_members(old_obj)
+
+    for name, old_member in old_members.items():
+        if isinstance(old_member, griffe.Alias) and len(path) > 2:
+            # ignore imports in `/types/` for now, they're technically part of the public API
+            # but we don't have good preventative measures in place to prevent changing them
+            continue
+
+        new_member = new_members.get(name)
+        if new_member is None:
+            cls_name = old_member.__class__.__name__
+            yield Text(f"({cls_name})", style=Style(color="rgb(119, 119, 119)"))
+            yield from [" " for _ in range(10 - len(cls_name))]
+            yield f" {'.'.join(path)}.{name}"
+            yield "\n"
+            continue
+
+        yield from find_breaking_changes(new_member, old_member, path=[*path, name])
+
+
+def main() -> None:
+    try:
+        against_ref = sys.argv[1]
+    except IndexError as err:
+        raise RuntimeError("You must specify a base ref to run breaking change detection against") from err
+
+    package = griffe.load(
+        "openai",
+        search_paths=[Path(__file__).parent.parent.joinpath("src")],
+    )
+    old_package = griffe.load_git(
+        "openai",
+        ref=against_ref,
+        search_paths=["src"],
+    )
+    assert isinstance(package, griffe.Module)
+    assert isinstance(old_package, griffe.Module)
+
+    output = list(find_breaking_changes(package, old_package, path=["openai"]))
+    if output:
+        rich.print(Text("Breaking changes detected!", style=Style(color="rgb(165, 79, 87)")))
+        rich.print()
+
+        for text in output:
+            rich.print(text, end="")
+
+        sys.exit(1)
+
+
+main()
diff --git a/scripts/mock b/scripts/mock
index d2814ae6a0..0b28f6ea23 100755
--- a/scripts/mock
+++ b/scripts/mock
@@ -21,7 +21,7 @@ echo "==> Starting mock server with URL ${URL}"
 
 # Run prism mock on the given spec
 if [ "$1" == "--daemon" ]; then
-  npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" &> .prism.log &
+  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" &> .prism.log &
 
   # Wait for server to come online
   echo -n "Waiting for server"
@@ -37,5 +37,5 @@ if [ "$1" == "--daemon" ]; then
 
   echo
 else
-  npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL"
+  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL"
 fi
diff --git a/scripts/test b/scripts/test
index 2b87845670..dbeda2d217 100755
--- a/scripts/test
+++ b/scripts/test
@@ -43,7 +43,7 @@ elif ! prism_is_running ; then
   echo -e "To run the server, pass in the path or url of your OpenAPI"
   echo -e "spec to the prism command:"
   echo
-  echo -e "  \$ ${YELLOW}npm exec --package=@stoplight/prism-cli@~5.3.2 -- prism mock path/to/your.openapi.yml${NC}"
+  echo -e "  \$ ${YELLOW}npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock path/to/your.openapi.yml${NC}"
   echo
 
   exit 1
diff --git a/scripts/utils/upload-artifact.sh b/scripts/utils/upload-artifact.sh
new file mode 100755
index 0000000000..cd522975fc
--- /dev/null
+++ b/scripts/utils/upload-artifact.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -exuo pipefail
+
+FILENAME=$(basename dist/*.whl)
+
+RESPONSE=$(curl -X POST "$URL?filename=$FILENAME" \
+  -H "Authorization: Bearer $AUTH" \
+  -H "Content-Type: application/json")
+
+SIGNED_URL=$(echo "$RESPONSE" | jq -r '.url')
+
+if [[ "$SIGNED_URL" == "null" ]]; then
+  echo -e "\033[31mFailed to get signed URL.\033[0m"
+  exit 1
+fi
+
+UPLOAD_RESPONSE=$(curl -v -X PUT \
+  -H "Content-Type: binary/octet-stream" \
+  --data-binary "@dist/$FILENAME" "$SIGNED_URL" 2>&1)
+
+if echo "$UPLOAD_RESPONSE" | grep -q "HTTP/[0-9.]* 200"; then
+  echo -e "\033[32mUploaded build to Stainless storage.\033[0m"
+  echo -e "\033[32mInstallation: pip install 'https://pkg.stainless.com/s/openai-python/$SHA/$FILENAME'\033[0m"
+else
+  echo -e "\033[31mFailed to upload artifact.\033[0m"
+  exit 1
+fi
diff --git a/src/openai/__init__.py b/src/openai/__init__.py
index 7ce6df0817..e7411b3886 100644
--- a/src/openai/__init__.py
+++ b/src/openai/__init__.py
@@ -3,10 +3,11 @@
 from __future__ import annotations
 
 import os as _os
+import typing as _t
 from typing_extensions import override
 
 from . import types
-from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes
+from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes, omit, not_given
 from ._utils import file_from_path
 from ._client import Client, OpenAI, Stream, Timeout, Transport, AsyncClient, AsyncOpenAI, AsyncStream, RequestOptions
 from ._models import BaseModel
@@ -29,9 +30,10 @@
     LengthFinishReasonError,
     UnprocessableEntityError,
     APIResponseValidationError,
+    InvalidWebhookSignatureError,
     ContentFilterFinishReasonError,
 )
-from ._base_client import DefaultHttpxClient, DefaultAsyncHttpxClient
+from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
 from ._utils._logs import setup_logging as _setup_logging
 from ._legacy_response import HttpxBinaryResponseContent as HttpxBinaryResponseContent
 
@@ -44,7 +46,9 @@
     "ProxiesTypes",
     "NotGiven",
     "NOT_GIVEN",
+    "not_given",
     "Omit",
+    "omit",
     "OpenAIError",
     "APIError",
     "APIStatusError",
@@ -61,6 +65,7 @@
     "InternalServerError",
     "LengthFinishReasonError",
     "ContentFilterFinishReasonError",
+    "InvalidWebhookSignatureError",
     "Timeout",
     "RequestOptions",
     "Client",
@@ -76,8 +81,12 @@
     "DEFAULT_CONNECTION_LIMITS",
     "DefaultHttpxClient",
     "DefaultAsyncHttpxClient",
+    "DefaultAioHttpClient",
 ]
 
+if not _t.TYPE_CHECKING:
+    from ._utils._resources_proxy import resources as resources
+
 from .lib import azure as _azure, pydantic_function_tool as pydantic_function_tool
 from .version import VERSION as VERSION
 from .lib.azure import AzureOpenAI as AzureOpenAI, AsyncAzureOpenAI as AsyncAzureOpenAI
@@ -116,6 +125,8 @@
 
 project: str | None = None
 
+webhook_secret: str | None = None
+
 base_url: str | _httpx.URL | None = None
 
 timeout: float | Timeout | None = DEFAULT_TIMEOUT
@@ -178,6 +189,17 @@ def project(self, value: str | None) -> None:  # type: ignore
 
         project = value
 
+    @property  # type: ignore
+    @override
+    def webhook_secret(self) -> str | None:
+        return webhook_secret
+
+    @webhook_secret.setter  # type: ignore
+    def webhook_secret(self, value: str | None) -> None:  # type: ignore
+        global webhook_secret
+
+        webhook_secret = value
+
     @property
     @override
     def base_url(self) -> _httpx.URL:
@@ -330,6 +352,7 @@ def _load_client() -> OpenAI:  # type: ignore[reportUnusedFunction]
             api_key=api_key,
             organization=organization,
             project=project,
+            webhook_secret=webhook_secret,
             base_url=base_url,
             timeout=timeout,
             max_retries=max_retries,
@@ -352,15 +375,21 @@ def _reset_client() -> None:  # type: ignore[reportUnusedFunction]
     beta as beta,
     chat as chat,
     audio as audio,
+    evals as evals,
     files as files,
     images as images,
     models as models,
+    videos as videos,
     batches as batches,
     uploads as uploads,
+    realtime as realtime,
+    webhooks as webhooks,
     responses as responses,
+    containers as containers,
     embeddings as embeddings,
     completions as completions,
     fine_tuning as fine_tuning,
     moderations as moderations,
+    conversations as conversations,
     vector_stores as vector_stores,
 )
diff --git a/src/openai/_base_client.py b/src/openai/_base_client.py
index f31e5af54b..58490e4430 100644
--- a/src/openai/_base_client.py
+++ b/src/openai/_base_client.py
@@ -42,7 +42,6 @@
 from ._qs import Querystring
 from ._files import to_httpx_files, async_to_httpx_files
 from ._types import (
-    NOT_GIVEN,
     Body,
     Omit,
     Query,
@@ -57,9 +56,10 @@
     RequestOptions,
     HttpxRequestFiles,
     ModelBuilderProtocol,
+    not_given,
 )
 from ._utils import SensitiveHeadersFilter, is_dict, is_list, asyncify, is_given, lru_cache, is_mapping
-from ._compat import PYDANTIC_V2, model_copy, model_dump
+from ._compat import PYDANTIC_V1, model_copy, model_dump
 from ._models import GenericModel, FinalRequestOptions, validate_type, construct_type
 from ._response import (
     APIResponse,
@@ -100,7 +100,11 @@
 _AsyncStreamT = TypeVar("_AsyncStreamT", bound=AsyncStream[Any])
 
 if TYPE_CHECKING:
-    from httpx._config import DEFAULT_TIMEOUT_CONFIG as HTTPX_DEFAULT_TIMEOUT
+    from httpx._config import (
+        DEFAULT_TIMEOUT_CONFIG,  # pyright: ignore[reportPrivateImportUsage]
+    )
+
+    HTTPX_DEFAULT_TIMEOUT = DEFAULT_TIMEOUT_CONFIG
 else:
     try:
         from httpx._config import DEFAULT_TIMEOUT_CONFIG as HTTPX_DEFAULT_TIMEOUT
@@ -117,6 +121,7 @@ class PageInfo:
 
     url: URL | NotGiven
     params: Query | NotGiven
+    json: Body | NotGiven
 
     @overload
     def __init__(
@@ -132,19 +137,30 @@ def __init__(
         params: Query,
     ) -> None: ...
 
+    @overload
+    def __init__(
+        self,
+        *,
+        json: Body,
+    ) -> None: ...
+
     def __init__(
         self,
         *,
-        url: URL | NotGiven = NOT_GIVEN,
-        params: Query | NotGiven = NOT_GIVEN,
+        url: URL | NotGiven = not_given,
+        json: Body | NotGiven = not_given,
+        params: Query | NotGiven = not_given,
     ) -> None:
         self.url = url
+        self.json = json
         self.params = params
 
     @override
     def __repr__(self) -> str:
         if self.url:
             return f"{self.__class__.__name__}(url={self.url})"
+        if self.json:
+            return f"{self.__class__.__name__}(json={self.json})"
         return f"{self.__class__.__name__}(params={self.params})"
 
 
@@ -193,6 +209,19 @@ def _info_to_options(self, info: PageInfo) -> FinalRequestOptions:
             options.url = str(url)
             return options
 
+        if not isinstance(info.json, NotGiven):
+            if not is_mapping(info.json):
+                raise TypeError("Pagination is only supported with mappings")
+
+            if not options.json_data:
+                options.json_data = {**info.json}
+            else:
+                if not is_mapping(options.json_data):
+                    raise TypeError("Pagination is only supported with mappings")
+
+                options.json_data = {**options.json_data, **info.json}
+            return options
+
         raise ValueError("Unexpected PageInfo state")
 
 
@@ -205,7 +234,7 @@ def _set_private_attributes(
         model: Type[_T],
         options: FinalRequestOptions,
     ) -> None:
-        if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None:
+        if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None:
             self.__pydantic_private__ = {}
 
         self._model = model
@@ -293,7 +322,7 @@ def _set_private_attributes(
         client: AsyncAPIClient,
         options: FinalRequestOptions,
     ) -> None:
-        if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None:
+        if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None:
             self.__pydantic_private__ = {}
 
         self._model = model
@@ -410,8 +439,8 @@ def _build_headers(self, options: FinalRequestOptions, *, retries_taken: int = 0
         headers = httpx.Headers(headers_dict)
 
         idempotency_header = self._idempotency_header
-        if idempotency_header and options.method.lower() != "get" and idempotency_header not in headers:
-            headers[idempotency_header] = options.idempotency_key or self._idempotency_key()
+        if idempotency_header and options.idempotency_key and idempotency_header not in headers:
+            headers[idempotency_header] = options.idempotency_key
 
         # Don't set these headers if they were already set or removed by the caller. We check
         # `custom_headers`, which can contain `Omit()`, instead of `headers` to account for the removal case.
@@ -502,6 +531,18 @@ def _build_request(
             # work around https://github.com/encode/httpx/discussions/2880
             kwargs["extensions"] = {"sni_hostname": prepared_url.host.replace("_", "-")}
 
+        is_body_allowed = options.method.lower() != "get"
+
+        if is_body_allowed:
+            if isinstance(json_data, bytes):
+                kwargs["content"] = json_data
+            else:
+                kwargs["json"] = json_data if is_given(json_data) else None
+            kwargs["files"] = files
+        else:
+            headers.pop("Content-Type", None)
+            kwargs.pop("data", None)
+
         # TODO: report this error to httpx
         return self._client.build_request(  # pyright: ignore[reportUnknownMemberType]
             headers=headers,
@@ -513,8 +554,6 @@ def _build_request(
             # so that passing a `TypedDict` doesn't cause an error.
             # https://github.com/microsoft/pyright/issues/3526#event-6715453066
             params=self.qs.stringify(cast(Mapping[str, Any], params)) if params else None,
-            json=json_data if is_given(json_data) else None,
-            files=files,
             **kwargs,
         )
 
@@ -558,7 +597,7 @@ def _maybe_override_cast_to(self, cast_to: type[ResponseT], options: FinalReques
         # we internally support defining a temporary header to override the
         # default `cast_to` type for use with `.with_raw_response` and `.with_streaming_response`
         # see _response.py for implementation details
-        override_cast_to = headers.pop(OVERRIDE_CAST_TO_HEADER, NOT_GIVEN)
+        override_cast_to = headers.pop(OVERRIDE_CAST_TO_HEADER, not_given)
         if is_given(override_cast_to):
             options.headers = headers
             return cast(Type[ResponseT], override_cast_to)
@@ -788,7 +827,7 @@ def __init__(
         version: str,
         base_url: str | URL,
         max_retries: int = DEFAULT_MAX_RETRIES,
-        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.Client | None = None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
@@ -875,7 +914,6 @@ def request(
         self,
         cast_to: Type[ResponseT],
         options: FinalRequestOptions,
-        remaining_retries: Optional[int] = None,
         *,
         stream: Literal[True],
         stream_cls: Type[_StreamT],
@@ -886,7 +924,6 @@ def request(
         self,
         cast_to: Type[ResponseT],
         options: FinalRequestOptions,
-        remaining_retries: Optional[int] = None,
         *,
         stream: Literal[False] = False,
     ) -> ResponseT: ...
@@ -896,7 +933,6 @@ def request(
         self,
         cast_to: Type[ResponseT],
         options: FinalRequestOptions,
-        remaining_retries: Optional[int] = None,
         *,
         stream: bool = False,
         stream_cls: Type[_StreamT] | None = None,
@@ -906,122 +942,113 @@ def request(
         self,
         cast_to: Type[ResponseT],
         options: FinalRequestOptions,
-        remaining_retries: Optional[int] = None,
         *,
         stream: bool = False,
         stream_cls: type[_StreamT] | None = None,
     ) -> ResponseT | _StreamT:
-        if remaining_retries is not None:
-            retries_taken = options.get_max_retries(self.max_retries) - remaining_retries
-        else:
-            retries_taken = 0
-
-        return self._request(
-            cast_to=cast_to,
-            options=options,
-            stream=stream,
-            stream_cls=stream_cls,
-            retries_taken=retries_taken,
-        )
+        cast_to = self._maybe_override_cast_to(cast_to, options)
 
-    def _request(
-        self,
-        *,
-        cast_to: Type[ResponseT],
-        options: FinalRequestOptions,
-        retries_taken: int,
-        stream: bool,
-        stream_cls: type[_StreamT] | None,
-    ) -> ResponseT | _StreamT:
         # create a copy of the options we were given so that if the
         # options are mutated later & we then retry, the retries are
         # given the original options
         input_options = model_copy(options)
+        if input_options.idempotency_key is None and input_options.method.lower() != "get":
+            # ensure the idempotency key is reused between requests
+            input_options.idempotency_key = self._idempotency_key()
 
-        cast_to = self._maybe_override_cast_to(cast_to, options)
-        options = self._prepare_options(options)
-
-        remaining_retries = options.get_max_retries(self.max_retries) - retries_taken
-        request = self._build_request(options, retries_taken=retries_taken)
-        self._prepare_request(request)
+        response: httpx.Response | None = None
+        max_retries = input_options.get_max_retries(self.max_retries)
 
-        kwargs: HttpxSendArgs = {}
-        if self.custom_auth is not None:
-            kwargs["auth"] = self.custom_auth
+        retries_taken = 0
+        for retries_taken in range(max_retries + 1):
+            options = model_copy(input_options)
+            options = self._prepare_options(options)
 
-        log.debug("Sending HTTP Request: %s %s", request.method, request.url)
+            remaining_retries = max_retries - retries_taken
+            request = self._build_request(options, retries_taken=retries_taken)
+            self._prepare_request(request)
 
-        try:
-            response = self._client.send(
-                request,
-                stream=stream or self._should_stream_response_body(request=request),
-                **kwargs,
-            )
-        except httpx.TimeoutException as err:
-            log.debug("Encountered httpx.TimeoutException", exc_info=True)
+            kwargs: HttpxSendArgs = {}
+            if self.custom_auth is not None:
+                kwargs["auth"] = self.custom_auth
 
-            if remaining_retries > 0:
-                return self._retry_request(
-                    input_options,
-                    cast_to,
-                    retries_taken=retries_taken,
-                    stream=stream,
-                    stream_cls=stream_cls,
-                    response_headers=None,
-                )
+            if options.follow_redirects is not None:
+                kwargs["follow_redirects"] = options.follow_redirects
 
-            log.debug("Raising timeout error")
-            raise APITimeoutError(request=request) from err
-        except Exception as err:
-            log.debug("Encountered Exception", exc_info=True)
+            log.debug("Sending HTTP Request: %s %s", request.method, request.url)
 
-            if remaining_retries > 0:
-                return self._retry_request(
-                    input_options,
-                    cast_to,
-                    retries_taken=retries_taken,
-                    stream=stream,
-                    stream_cls=stream_cls,
-                    response_headers=None,
+            response = None
+            try:
+                response = self._client.send(
+                    request,
+                    stream=stream or self._should_stream_response_body(request=request),
+                    **kwargs,
                 )
+            except httpx.TimeoutException as err:
+                log.debug("Encountered httpx.TimeoutException", exc_info=True)
+
+                if remaining_retries > 0:
+                    self._sleep_for_retry(
+                        retries_taken=retries_taken,
+                        max_retries=max_retries,
+                        options=input_options,
+                        response=None,
+                    )
+                    continue
+
+                log.debug("Raising timeout error")
+                raise APITimeoutError(request=request) from err
+            except Exception as err:
+                log.debug("Encountered Exception", exc_info=True)
+
+                if remaining_retries > 0:
+                    self._sleep_for_retry(
+                        retries_taken=retries_taken,
+                        max_retries=max_retries,
+                        options=input_options,
+                        response=None,
+                    )
+                    continue
+
+                log.debug("Raising connection error")
+                raise APIConnectionError(request=request) from err
+
+            log.debug(
+                'HTTP Response: %s %s "%i %s" %s',
+                request.method,
+                request.url,
+                response.status_code,
+                response.reason_phrase,
+                response.headers,
+            )
+            log.debug("request_id: %s", response.headers.get("x-request-id"))
 
-            log.debug("Raising connection error")
-            raise APIConnectionError(request=request) from err
-
-        log.debug(
-            'HTTP Response: %s %s "%i %s" %s',
-            request.method,
-            request.url,
-            response.status_code,
-            response.reason_phrase,
-            response.headers,
-        )
-        log.debug("request_id: %s", response.headers.get("x-request-id"))
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as err:  # thrown on 4xx and 5xx status code
+                log.debug("Encountered httpx.HTTPStatusError", exc_info=True)
+
+                if remaining_retries > 0 and self._should_retry(err.response):
+                    err.response.close()
+                    self._sleep_for_retry(
+                        retries_taken=retries_taken,
+                        max_retries=max_retries,
+                        options=input_options,
+                        response=response,
+                    )
+                    continue
 
-        try:
-            response.raise_for_status()
-        except httpx.HTTPStatusError as err:  # thrown on 4xx and 5xx status code
-            log.debug("Encountered httpx.HTTPStatusError", exc_info=True)
-
-            if remaining_retries > 0 and self._should_retry(err.response):
-                err.response.close()
-                return self._retry_request(
-                    input_options,
-                    cast_to,
-                    retries_taken=retries_taken,
-                    response_headers=err.response.headers,
-                    stream=stream,
-                    stream_cls=stream_cls,
-                )
+                # If the response is streamed then we need to explicitly read the response
+                # to completion before attempting to access the response text.
+                if not err.response.is_closed:
+                    err.response.read()
 
-            # If the response is streamed then we need to explicitly read the response
-            # to completion before attempting to access the response text.
-            if not err.response.is_closed:
-                err.response.read()
+                log.debug("Re-raising status error")
+                raise self._make_status_error_from_response(err.response) from None
 
-            log.debug("Re-raising status error")
-            raise self._make_status_error_from_response(err.response) from None
+            break
 
+        assert response is not None, "could not resolve response (should never happen)"
         return self._process_response(
             cast_to=cast_to,
             options=options,
@@ -1031,37 +1058,20 @@ def _request(
             retries_taken=retries_taken,
         )
 
-    def _retry_request(
-        self,
-        options: FinalRequestOptions,
-        cast_to: Type[ResponseT],
-        *,
-        retries_taken: int,
-        response_headers: httpx.Headers | None,
-        stream: bool,
-        stream_cls: type[_StreamT] | None,
-    ) -> ResponseT | _StreamT:
-        remaining_retries = options.get_max_retries(self.max_retries) - retries_taken
+    def _sleep_for_retry(
+        self, *, retries_taken: int, max_retries: int, options: FinalRequestOptions, response: httpx.Response | None
+    ) -> None:
+        remaining_retries = max_retries - retries_taken
         if remaining_retries == 1:
             log.debug("1 retry left")
         else:
             log.debug("%i retries left", remaining_retries)
 
-        timeout = self._calculate_retry_timeout(remaining_retries, options, response_headers)
+        timeout = self._calculate_retry_timeout(remaining_retries, options, response.headers if response else None)
         log.info("Retrying request to %s in %f seconds", options.url, timeout)
 
-        # In a synchronous context we are blocking the entire thread. Up to the library user to run the client in a
-        # different thread if necessary.
         time.sleep(timeout)
 
-        return self._request(
-            options=options,
-            cast_to=cast_to,
-            retries_taken=retries_taken + 1,
-            stream=stream,
-            stream_cls=stream_cls,
-        )
-
     def _process_response(
         self,
         *,
@@ -1088,7 +1098,14 @@ def _process_response(
 
         origin = get_origin(cast_to) or cast_to
 
-        if inspect.isclass(origin) and issubclass(origin, BaseAPIResponse):
+        if (
+            inspect.isclass(origin)
+            and issubclass(origin, BaseAPIResponse)
+            # we only want to actually return the custom BaseAPIResponse class if we're
+            # returning the raw response, or if we're not streaming SSE, as if we're streaming
+            # SSE then `cast_to` doesn't actively reflect the type we need to parse into
+            and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER)))
+        ):
             if not issubclass(origin, APIResponse):
                 raise TypeError(f"API Response types must subclass {APIResponse}; Received {origin}")
 
@@ -1299,6 +1316,24 @@ def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
 
 
+try:
+    import httpx_aiohttp
+except ImportError:
+
+    class _DefaultAioHttpClient(httpx.AsyncClient):
+        def __init__(self, **_kwargs: Any) -> None:
+            raise RuntimeError("To use the aiohttp client you must have installed the package with the `aiohttp` extra")
+else:
+
+    class _DefaultAioHttpClient(httpx_aiohttp.HttpxAiohttpClient):  # type: ignore
+        def __init__(self, **kwargs: Any) -> None:
+            kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
+            kwargs.setdefault("limits", DEFAULT_CONNECTION_LIMITS)
+            kwargs.setdefault("follow_redirects", True)
+
+            super().__init__(**kwargs)
+
+
 if TYPE_CHECKING:
     DefaultAsyncHttpxClient = httpx.AsyncClient
     """An alias to `httpx.AsyncClient` that provides the same defaults that this SDK
@@ -1307,8 +1342,12 @@ def __init__(self, **kwargs: Any) -> None:
     This is useful because overriding the `http_client` with your own instance of
     `httpx.AsyncClient` will result in httpx's defaults being used, not ours.
     """
+
+    DefaultAioHttpClient = httpx.AsyncClient
+    """An alias to `httpx.AsyncClient` that changes the default HTTP transport to `aiohttp`."""
 else:
     DefaultAsyncHttpxClient = _DefaultAsyncHttpxClient
+    DefaultAioHttpClient = _DefaultAioHttpClient
 
 
 class AsyncHttpxClientWrapper(DefaultAsyncHttpxClient):
@@ -1334,7 +1373,7 @@ def __init__(
         base_url: str | URL,
         _strict_response_validation: bool,
         max_retries: int = DEFAULT_MAX_RETRIES,
-        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.AsyncClient | None = None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
@@ -1419,7 +1458,6 @@ async def request(
         options: FinalRequestOptions,
         *,
         stream: Literal[False] = False,
-        remaining_retries: Optional[int] = None,
     ) -> ResponseT: ...
 
     @overload
@@ -1430,7 +1468,6 @@ async def request(
         *,
         stream: Literal[True],
         stream_cls: type[_AsyncStreamT],
-        remaining_retries: Optional[int] = None,
     ) -> _AsyncStreamT: ...
 
     @overload
@@ -1441,7 +1478,6 @@ async def request(
         *,
         stream: bool,
         stream_cls: type[_AsyncStreamT] | None = None,
-        remaining_retries: Optional[int] = None,
     ) -> ResponseT | _AsyncStreamT: ...
 
     async def request(
@@ -1451,116 +1487,115 @@ async def request(
         *,
         stream: bool = False,
         stream_cls: type[_AsyncStreamT] | None = None,
-        remaining_retries: Optional[int] = None,
-    ) -> ResponseT | _AsyncStreamT:
-        if remaining_retries is not None:
-            retries_taken = options.get_max_retries(self.max_retries) - remaining_retries
-        else:
-            retries_taken = 0
-
-        return await self._request(
-            cast_to=cast_to,
-            options=options,
-            stream=stream,
-            stream_cls=stream_cls,
-            retries_taken=retries_taken,
-        )
-
-    async def _request(
-        self,
-        cast_to: Type[ResponseT],
-        options: FinalRequestOptions,
-        *,
-        stream: bool,
-        stream_cls: type[_AsyncStreamT] | None,
-        retries_taken: int,
     ) -> ResponseT | _AsyncStreamT:
         if self._platform is None:
             # `get_platform` can make blocking IO calls so we
             # execute it earlier while we are in an async context
             self._platform = await asyncify(get_platform)()
 
+        cast_to = self._maybe_override_cast_to(cast_to, options)
+
         # create a copy of the options we were given so that if the
         # options are mutated later & we then retry, the retries are
         # given the original options
         input_options = model_copy(options)
+        if input_options.idempotency_key is None and input_options.method.lower() != "get":
+            # ensure the idempotency key is reused between requests
+            input_options.idempotency_key = self._idempotency_key()
 
-        cast_to = self._maybe_override_cast_to(cast_to, options)
-        options = await self._prepare_options(options)
+        response: httpx.Response | None = None
+        max_retries = input_options.get_max_retries(self.max_retries)
 
-        remaining_retries = options.get_max_retries(self.max_retries) - retries_taken
-        request = self._build_request(options, retries_taken=retries_taken)
-        await self._prepare_request(request)
+        retries_taken = 0
+        for retries_taken in range(max_retries + 1):
+            options = model_copy(input_options)
+            options = await self._prepare_options(options)
 
-        kwargs: HttpxSendArgs = {}
-        if self.custom_auth is not None:
-            kwargs["auth"] = self.custom_auth
+            remaining_retries = max_retries - retries_taken
+            request = self._build_request(options, retries_taken=retries_taken)
+            await self._prepare_request(request)
 
-        try:
-            response = await self._client.send(
-                request,
-                stream=stream or self._should_stream_response_body(request=request),
-                **kwargs,
-            )
-        except httpx.TimeoutException as err:
-            log.debug("Encountered httpx.TimeoutException", exc_info=True)
+            kwargs: HttpxSendArgs = {}
+            if self.custom_auth is not None:
+                kwargs["auth"] = self.custom_auth
 
-            if remaining_retries > 0:
-                return await self._retry_request(
-                    input_options,
-                    cast_to,
-                    retries_taken=retries_taken,
-                    stream=stream,
-                    stream_cls=stream_cls,
-                    response_headers=None,
-                )
+            if options.follow_redirects is not None:
+                kwargs["follow_redirects"] = options.follow_redirects
 
-            log.debug("Raising timeout error")
-            raise APITimeoutError(request=request) from err
-        except Exception as err:
-            log.debug("Encountered Exception", exc_info=True)
+            log.debug("Sending HTTP Request: %s %s", request.method, request.url)
 
-            if remaining_retries > 0:
-                return await self._retry_request(
-                    input_options,
-                    cast_to,
-                    retries_taken=retries_taken,
-                    stream=stream,
-                    stream_cls=stream_cls,
-                    response_headers=None,
+            response = None
+            try:
+                response = await self._client.send(
+                    request,
+                    stream=stream or self._should_stream_response_body(request=request),
+                    **kwargs,
                 )
+            except httpx.TimeoutException as err:
+                log.debug("Encountered httpx.TimeoutException", exc_info=True)
+
+                if remaining_retries > 0:
+                    await self._sleep_for_retry(
+                        retries_taken=retries_taken,
+                        max_retries=max_retries,
+                        options=input_options,
+                        response=None,
+                    )
+                    continue
+
+                log.debug("Raising timeout error")
+                raise APITimeoutError(request=request) from err
+            except Exception as err:
+                log.debug("Encountered Exception", exc_info=True)
+
+                if remaining_retries > 0:
+                    await self._sleep_for_retry(
+                        retries_taken=retries_taken,
+                        max_retries=max_retries,
+                        options=input_options,
+                        response=None,
+                    )
+                    continue
+
+                log.debug("Raising connection error")
+                raise APIConnectionError(request=request) from err
+
+            log.debug(
+                'HTTP Response: %s %s "%i %s" %s',
+                request.method,
+                request.url,
+                response.status_code,
+                response.reason_phrase,
+                response.headers,
+            )
+            log.debug("request_id: %s", response.headers.get("x-request-id"))
 
-            log.debug("Raising connection error")
-            raise APIConnectionError(request=request) from err
-
-        log.debug(
-            'HTTP Request: %s %s "%i %s"', request.method, request.url, response.status_code, response.reason_phrase
-        )
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as err:  # thrown on 4xx and 5xx status code
+                log.debug("Encountered httpx.HTTPStatusError", exc_info=True)
+
+                if remaining_retries > 0 and self._should_retry(err.response):
+                    await err.response.aclose()
+                    await self._sleep_for_retry(
+                        retries_taken=retries_taken,
+                        max_retries=max_retries,
+                        options=input_options,
+                        response=response,
+                    )
+                    continue
 
-        try:
-            response.raise_for_status()
-        except httpx.HTTPStatusError as err:  # thrown on 4xx and 5xx status code
-            log.debug("Encountered httpx.HTTPStatusError", exc_info=True)
-
-            if remaining_retries > 0 and self._should_retry(err.response):
-                await err.response.aclose()
-                return await self._retry_request(
-                    input_options,
-                    cast_to,
-                    retries_taken=retries_taken,
-                    response_headers=err.response.headers,
-                    stream=stream,
-                    stream_cls=stream_cls,
-                )
+                # If the response is streamed then we need to explicitly read the response
+                # to completion before attempting to access the response text.
+                if not err.response.is_closed:
+                    await err.response.aread()
 
-            # If the response is streamed then we need to explicitly read the response
-            # to completion before attempting to access the response text.
-            if not err.response.is_closed:
-                await err.response.aread()
+                log.debug("Re-raising status error")
+                raise self._make_status_error_from_response(err.response) from None
 
-            log.debug("Re-raising status error")
-            raise self._make_status_error_from_response(err.response) from None
+            break
 
+        assert response is not None, "could not resolve response (should never happen)"
         return await self._process_response(
             cast_to=cast_to,
             options=options,
@@ -1570,35 +1605,20 @@ async def _request(
             retries_taken=retries_taken,
         )
 
-    async def _retry_request(
-        self,
-        options: FinalRequestOptions,
-        cast_to: Type[ResponseT],
-        *,
-        retries_taken: int,
-        response_headers: httpx.Headers | None,
-        stream: bool,
-        stream_cls: type[_AsyncStreamT] | None,
-    ) -> ResponseT | _AsyncStreamT:
-        remaining_retries = options.get_max_retries(self.max_retries) - retries_taken
+    async def _sleep_for_retry(
+        self, *, retries_taken: int, max_retries: int, options: FinalRequestOptions, response: httpx.Response | None
+    ) -> None:
+        remaining_retries = max_retries - retries_taken
         if remaining_retries == 1:
             log.debug("1 retry left")
         else:
             log.debug("%i retries left", remaining_retries)
 
-        timeout = self._calculate_retry_timeout(remaining_retries, options, response_headers)
+        timeout = self._calculate_retry_timeout(remaining_retries, options, response.headers if response else None)
         log.info("Retrying request to %s in %f seconds", options.url, timeout)
 
         await anyio.sleep(timeout)
 
-        return await self._request(
-            options=options,
-            cast_to=cast_to,
-            retries_taken=retries_taken + 1,
-            stream=stream,
-            stream_cls=stream_cls,
-        )
-
     async def _process_response(
         self,
         *,
@@ -1625,7 +1645,14 @@ async def _process_response(
 
         origin = get_origin(cast_to) or cast_to
 
-        if inspect.isclass(origin) and issubclass(origin, BaseAPIResponse):
+        if (
+            inspect.isclass(origin)
+            and issubclass(origin, BaseAPIResponse)
+            # we only want to actually return the custom BaseAPIResponse class if we're
+            # returning the raw response, or if we're not streaming SSE, as if we're streaming
+            # SSE then `cast_to` doesn't actively reflect the type we need to parse into
+            and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER)))
+        ):
             if not issubclass(origin, AsyncAPIResponse):
                 raise TypeError(f"API Response types must subclass {AsyncAPIResponse}; Received {origin}")
 
@@ -1823,8 +1850,8 @@ def make_request_options(
     extra_query: Query | None = None,
     extra_body: Body | None = None,
     idempotency_key: str | None = None,
-    timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    post_parser: PostParser | NotGiven = NOT_GIVEN,
+    timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    post_parser: PostParser | NotGiven = not_given,
 ) -> RequestOptions:
     """Create a dict of type RequestOptions without keys of NotGiven values."""
     options: RequestOptions = {}
diff --git a/src/openai/_client.py b/src/openai/_client.py
index 18d96da9a3..a3b01b2ce6 100644
--- a/src/openai/_client.py
+++ b/src/openai/_client.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Union, Mapping
+from typing import TYPE_CHECKING, Any, Mapping, Callable, Awaitable
 from typing_extensions import Self, override
 
 import httpx
@@ -11,21 +11,22 @@
 from . import _exceptions
 from ._qs import Querystring
 from ._types import (
-    NOT_GIVEN,
     Omit,
     Timeout,
     NotGiven,
     Transport,
     ProxiesTypes,
     RequestOptions,
+    not_given,
 )
 from ._utils import (
     is_given,
     is_mapping,
     get_async_library,
 )
+from ._compat import cached_property
+from ._models import FinalRequestOptions
 from ._version import __version__
-from .resources import files, images, models, batches, embeddings, completions, moderations
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import OpenAIError, APIStatusError
 from ._base_client import (
@@ -33,39 +34,59 @@
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.beta import beta
-from .resources.chat import chat
-from .resources.audio import audio
-from .resources.uploads import uploads
-from .resources.responses import responses
-from .resources.fine_tuning import fine_tuning
-from .resources.vector_stores import vector_stores
+
+if TYPE_CHECKING:
+    from .resources import (
+        beta,
+        chat,
+        audio,
+        evals,
+        files,
+        images,
+        models,
+        videos,
+        batches,
+        uploads,
+        realtime,
+        responses,
+        containers,
+        embeddings,
+        completions,
+        fine_tuning,
+        moderations,
+        conversations,
+        vector_stores,
+    )
+    from .resources.files import Files, AsyncFiles
+    from .resources.images import Images, AsyncImages
+    from .resources.models import Models, AsyncModels
+    from .resources.videos import Videos, AsyncVideos
+    from .resources.batches import Batches, AsyncBatches
+    from .resources.webhooks import Webhooks, AsyncWebhooks
+    from .resources.beta.beta import Beta, AsyncBeta
+    from .resources.chat.chat import Chat, AsyncChat
+    from .resources.embeddings import Embeddings, AsyncEmbeddings
+    from .resources.audio.audio import Audio, AsyncAudio
+    from .resources.completions import Completions, AsyncCompletions
+    from .resources.evals.evals import Evals, AsyncEvals
+    from .resources.moderations import Moderations, AsyncModerations
+    from .resources.uploads.uploads import Uploads, AsyncUploads
+    from .resources.realtime.realtime import Realtime, AsyncRealtime
+    from .resources.responses.responses import Responses, AsyncResponses
+    from .resources.containers.containers import Containers, AsyncContainers
+    from .resources.fine_tuning.fine_tuning import FineTuning, AsyncFineTuning
+    from .resources.conversations.conversations import Conversations, AsyncConversations
+    from .resources.vector_stores.vector_stores import VectorStores, AsyncVectorStores
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "OpenAI", "AsyncOpenAI", "Client", "AsyncClient"]
 
 
 class OpenAI(SyncAPIClient):
-    completions: completions.Completions
-    chat: chat.Chat
-    embeddings: embeddings.Embeddings
-    files: files.Files
-    images: images.Images
-    audio: audio.Audio
-    moderations: moderations.Moderations
-    models: models.Models
-    fine_tuning: fine_tuning.FineTuning
-    vector_stores: vector_stores.VectorStores
-    beta: beta.Beta
-    batches: batches.Batches
-    uploads: uploads.Uploads
-    responses: responses.Responses
-    with_raw_response: OpenAIWithRawResponse
-    with_streaming_response: OpenAIWithStreamedResponse
-
     # client options
     api_key: str
     organization: str | None
     project: str | None
+    webhook_secret: str | None
 
     websocket_base_url: str | httpx.URL | None
     """Base URL for WebSocket connections.
@@ -78,12 +99,13 @@ class OpenAI(SyncAPIClient):
     def __init__(
         self,
         *,
-        api_key: str | None = None,
+        api_key: str | None | Callable[[], str] = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         base_url: str | httpx.URL | None = None,
         websocket_base_url: str | httpx.URL | None = None,
-        timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN,
+        timeout: float | Timeout | None | NotGiven = not_given,
         max_retries: int = DEFAULT_MAX_RETRIES,
         default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
@@ -107,6 +129,7 @@ def __init__(
         - `api_key` from `OPENAI_API_KEY`
         - `organization` from `OPENAI_ORG_ID`
         - `project` from `OPENAI_PROJECT_ID`
+        - `webhook_secret` from `OPENAI_WEBHOOK_SECRET`
         """
         if api_key is None:
             api_key = os.environ.get("OPENAI_API_KEY")
@@ -114,7 +137,12 @@ def __init__(
             raise OpenAIError(
                 "The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable"
             )
-        self.api_key = api_key
+        if callable(api_key):
+            self.api_key = ""
+            self._api_key_provider: Callable[[], str] | None = api_key
+        else:
+            self.api_key = api_key
+            self._api_key_provider = None
 
         if organization is None:
             organization = os.environ.get("OPENAI_ORG_ID")
@@ -124,6 +152,10 @@ def __init__(
             project = os.environ.get("OPENAI_PROJECT_ID")
         self.project = project
 
+        if webhook_secret is None:
+            webhook_secret = os.environ.get("OPENAI_WEBHOOK_SECRET")
+        self.webhook_secret = webhook_secret
+
         self.websocket_base_url = websocket_base_url
 
         if base_url is None:
@@ -144,32 +176,155 @@ def __init__(
 
         self._default_stream_cls = Stream
 
-        self.completions = completions.Completions(self)
-        self.chat = chat.Chat(self)
-        self.embeddings = embeddings.Embeddings(self)
-        self.files = files.Files(self)
-        self.images = images.Images(self)
-        self.audio = audio.Audio(self)
-        self.moderations = moderations.Moderations(self)
-        self.models = models.Models(self)
-        self.fine_tuning = fine_tuning.FineTuning(self)
-        self.vector_stores = vector_stores.VectorStores(self)
-        self.beta = beta.Beta(self)
-        self.batches = batches.Batches(self)
-        self.uploads = uploads.Uploads(self)
-        self.responses = responses.Responses(self)
-        self.with_raw_response = OpenAIWithRawResponse(self)
-        self.with_streaming_response = OpenAIWithStreamedResponse(self)
+    @cached_property
+    def completions(self) -> Completions:
+        from .resources.completions import Completions
+
+        return Completions(self)
+
+    @cached_property
+    def chat(self) -> Chat:
+        from .resources.chat import Chat
+
+        return Chat(self)
+
+    @cached_property
+    def embeddings(self) -> Embeddings:
+        from .resources.embeddings import Embeddings
+
+        return Embeddings(self)
+
+    @cached_property
+    def files(self) -> Files:
+        from .resources.files import Files
+
+        return Files(self)
+
+    @cached_property
+    def images(self) -> Images:
+        from .resources.images import Images
+
+        return Images(self)
+
+    @cached_property
+    def audio(self) -> Audio:
+        from .resources.audio import Audio
+
+        return Audio(self)
+
+    @cached_property
+    def moderations(self) -> Moderations:
+        from .resources.moderations import Moderations
+
+        return Moderations(self)
+
+    @cached_property
+    def models(self) -> Models:
+        from .resources.models import Models
+
+        return Models(self)
+
+    @cached_property
+    def fine_tuning(self) -> FineTuning:
+        from .resources.fine_tuning import FineTuning
+
+        return FineTuning(self)
+
+    @cached_property
+    def vector_stores(self) -> VectorStores:
+        from .resources.vector_stores import VectorStores
+
+        return VectorStores(self)
+
+    @cached_property
+    def webhooks(self) -> Webhooks:
+        from .resources.webhooks import Webhooks
+
+        return Webhooks(self)
+
+    @cached_property
+    def beta(self) -> Beta:
+        from .resources.beta import Beta
+
+        return Beta(self)
+
+    @cached_property
+    def batches(self) -> Batches:
+        from .resources.batches import Batches
+
+        return Batches(self)
+
+    @cached_property
+    def uploads(self) -> Uploads:
+        from .resources.uploads import Uploads
+
+        return Uploads(self)
+
+    @cached_property
+    def responses(self) -> Responses:
+        from .resources.responses import Responses
+
+        return Responses(self)
+
+    @cached_property
+    def realtime(self) -> Realtime:
+        from .resources.realtime import Realtime
+
+        return Realtime(self)
+
+    @cached_property
+    def conversations(self) -> Conversations:
+        from .resources.conversations import Conversations
+
+        return Conversations(self)
+
+    @cached_property
+    def evals(self) -> Evals:
+        from .resources.evals import Evals
+
+        return Evals(self)
+
+    @cached_property
+    def containers(self) -> Containers:
+        from .resources.containers import Containers
+
+        return Containers(self)
+
+    @cached_property
+    def videos(self) -> Videos:
+        from .resources.videos import Videos
+
+        return Videos(self)
+
+    @cached_property
+    def with_raw_response(self) -> OpenAIWithRawResponse:
+        return OpenAIWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> OpenAIWithStreamedResponse:
+        return OpenAIWithStreamedResponse(self)
 
     @property
     @override
     def qs(self) -> Querystring:
         return Querystring(array_format="brackets")
 
+    def _refresh_api_key(self) -> None:
+        if self._api_key_provider:
+            self.api_key = self._api_key_provider()
+
+    @override
+    def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        self._refresh_api_key()
+        return super()._prepare_options(options)
+
     @property
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
+        if not api_key:
+            # if the api key is an empty string, encoding the header will fail
+            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -186,14 +341,15 @@ def default_headers(self) -> dict[str, str | Omit]:
     def copy(
         self,
         *,
-        api_key: str | None = None,
+        api_key: str | Callable[[], str] | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         base_url: str | httpx.URL | None = None,
-        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.Client | None = None,
-        max_retries: int | NotGiven = NOT_GIVEN,
+        max_retries: int | NotGiven = not_given,
         default_headers: Mapping[str, str] | None = None,
         set_default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
@@ -223,9 +379,10 @@ def copy(
 
         http_client = http_client or self._client
         return self.__class__(
-            api_key=api_key or self.api_key,
+            api_key=api_key or self._api_key_provider or self.api_key,
             organization=organization or self.organization,
             project=project or self.project,
+            webhook_secret=webhook_secret or self.webhook_secret,
             websocket_base_url=websocket_base_url or self.websocket_base_url,
             base_url=base_url or self.base_url,
             timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
@@ -276,27 +433,11 @@ def _make_status_error(
 
 
 class AsyncOpenAI(AsyncAPIClient):
-    completions: completions.AsyncCompletions
-    chat: chat.AsyncChat
-    embeddings: embeddings.AsyncEmbeddings
-    files: files.AsyncFiles
-    images: images.AsyncImages
-    audio: audio.AsyncAudio
-    moderations: moderations.AsyncModerations
-    models: models.AsyncModels
-    fine_tuning: fine_tuning.AsyncFineTuning
-    vector_stores: vector_stores.AsyncVectorStores
-    beta: beta.AsyncBeta
-    batches: batches.AsyncBatches
-    uploads: uploads.AsyncUploads
-    responses: responses.AsyncResponses
-    with_raw_response: AsyncOpenAIWithRawResponse
-    with_streaming_response: AsyncOpenAIWithStreamedResponse
-
     # client options
     api_key: str
     organization: str | None
     project: str | None
+    webhook_secret: str | None
 
     websocket_base_url: str | httpx.URL | None
     """Base URL for WebSocket connections.
@@ -309,12 +450,13 @@ class AsyncOpenAI(AsyncAPIClient):
     def __init__(
         self,
         *,
-        api_key: str | None = None,
+        api_key: str | Callable[[], Awaitable[str]] | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         base_url: str | httpx.URL | None = None,
         websocket_base_url: str | httpx.URL | None = None,
-        timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN,
+        timeout: float | Timeout | None | NotGiven = not_given,
         max_retries: int = DEFAULT_MAX_RETRIES,
         default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
@@ -338,6 +480,7 @@ def __init__(
         - `api_key` from `OPENAI_API_KEY`
         - `organization` from `OPENAI_ORG_ID`
         - `project` from `OPENAI_PROJECT_ID`
+        - `webhook_secret` from `OPENAI_WEBHOOK_SECRET`
         """
         if api_key is None:
             api_key = os.environ.get("OPENAI_API_KEY")
@@ -345,7 +488,12 @@ def __init__(
             raise OpenAIError(
                 "The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable"
             )
-        self.api_key = api_key
+        if callable(api_key):
+            self.api_key = ""
+            self._api_key_provider: Callable[[], Awaitable[str]] | None = api_key
+        else:
+            self.api_key = api_key
+            self._api_key_provider = None
 
         if organization is None:
             organization = os.environ.get("OPENAI_ORG_ID")
@@ -355,6 +503,10 @@ def __init__(
             project = os.environ.get("OPENAI_PROJECT_ID")
         self.project = project
 
+        if webhook_secret is None:
+            webhook_secret = os.environ.get("OPENAI_WEBHOOK_SECRET")
+        self.webhook_secret = webhook_secret
+
         self.websocket_base_url = websocket_base_url
 
         if base_url is None:
@@ -375,32 +527,155 @@ def __init__(
 
         self._default_stream_cls = AsyncStream
 
-        self.completions = completions.AsyncCompletions(self)
-        self.chat = chat.AsyncChat(self)
-        self.embeddings = embeddings.AsyncEmbeddings(self)
-        self.files = files.AsyncFiles(self)
-        self.images = images.AsyncImages(self)
-        self.audio = audio.AsyncAudio(self)
-        self.moderations = moderations.AsyncModerations(self)
-        self.models = models.AsyncModels(self)
-        self.fine_tuning = fine_tuning.AsyncFineTuning(self)
-        self.vector_stores = vector_stores.AsyncVectorStores(self)
-        self.beta = beta.AsyncBeta(self)
-        self.batches = batches.AsyncBatches(self)
-        self.uploads = uploads.AsyncUploads(self)
-        self.responses = responses.AsyncResponses(self)
-        self.with_raw_response = AsyncOpenAIWithRawResponse(self)
-        self.with_streaming_response = AsyncOpenAIWithStreamedResponse(self)
+    @cached_property
+    def completions(self) -> AsyncCompletions:
+        from .resources.completions import AsyncCompletions
+
+        return AsyncCompletions(self)
+
+    @cached_property
+    def chat(self) -> AsyncChat:
+        from .resources.chat import AsyncChat
+
+        return AsyncChat(self)
+
+    @cached_property
+    def embeddings(self) -> AsyncEmbeddings:
+        from .resources.embeddings import AsyncEmbeddings
+
+        return AsyncEmbeddings(self)
+
+    @cached_property
+    def files(self) -> AsyncFiles:
+        from .resources.files import AsyncFiles
+
+        return AsyncFiles(self)
+
+    @cached_property
+    def images(self) -> AsyncImages:
+        from .resources.images import AsyncImages
+
+        return AsyncImages(self)
+
+    @cached_property
+    def audio(self) -> AsyncAudio:
+        from .resources.audio import AsyncAudio
+
+        return AsyncAudio(self)
+
+    @cached_property
+    def moderations(self) -> AsyncModerations:
+        from .resources.moderations import AsyncModerations
+
+        return AsyncModerations(self)
+
+    @cached_property
+    def models(self) -> AsyncModels:
+        from .resources.models import AsyncModels
+
+        return AsyncModels(self)
+
+    @cached_property
+    def fine_tuning(self) -> AsyncFineTuning:
+        from .resources.fine_tuning import AsyncFineTuning
+
+        return AsyncFineTuning(self)
+
+    @cached_property
+    def vector_stores(self) -> AsyncVectorStores:
+        from .resources.vector_stores import AsyncVectorStores
+
+        return AsyncVectorStores(self)
+
+    @cached_property
+    def webhooks(self) -> AsyncWebhooks:
+        from .resources.webhooks import AsyncWebhooks
+
+        return AsyncWebhooks(self)
+
+    @cached_property
+    def beta(self) -> AsyncBeta:
+        from .resources.beta import AsyncBeta
+
+        return AsyncBeta(self)
+
+    @cached_property
+    def batches(self) -> AsyncBatches:
+        from .resources.batches import AsyncBatches
+
+        return AsyncBatches(self)
+
+    @cached_property
+    def uploads(self) -> AsyncUploads:
+        from .resources.uploads import AsyncUploads
+
+        return AsyncUploads(self)
+
+    @cached_property
+    def responses(self) -> AsyncResponses:
+        from .resources.responses import AsyncResponses
+
+        return AsyncResponses(self)
+
+    @cached_property
+    def realtime(self) -> AsyncRealtime:
+        from .resources.realtime import AsyncRealtime
+
+        return AsyncRealtime(self)
+
+    @cached_property
+    def conversations(self) -> AsyncConversations:
+        from .resources.conversations import AsyncConversations
+
+        return AsyncConversations(self)
+
+    @cached_property
+    def evals(self) -> AsyncEvals:
+        from .resources.evals import AsyncEvals
+
+        return AsyncEvals(self)
+
+    @cached_property
+    def containers(self) -> AsyncContainers:
+        from .resources.containers import AsyncContainers
+
+        return AsyncContainers(self)
+
+    @cached_property
+    def videos(self) -> AsyncVideos:
+        from .resources.videos import AsyncVideos
+
+        return AsyncVideos(self)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncOpenAIWithRawResponse:
+        return AsyncOpenAIWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncOpenAIWithStreamedResponse:
+        return AsyncOpenAIWithStreamedResponse(self)
 
     @property
     @override
     def qs(self) -> Querystring:
         return Querystring(array_format="brackets")
 
+    async def _refresh_api_key(self) -> None:
+        if self._api_key_provider:
+            self.api_key = await self._api_key_provider()
+
+    @override
+    async def _prepare_options(self, options: FinalRequestOptions) -> FinalRequestOptions:
+        await self._refresh_api_key()
+        return await super()._prepare_options(options)
+
     @property
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
+        if not api_key:
+            # if the api key is an empty string, encoding the header will fail
+            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -417,14 +692,15 @@ def default_headers(self) -> dict[str, str | Omit]:
     def copy(
         self,
         *,
-        api_key: str | None = None,
+        api_key: str | Callable[[], Awaitable[str]] | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         base_url: str | httpx.URL | None = None,
-        timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | Timeout | None | NotGiven = not_given,
         http_client: httpx.AsyncClient | None = None,
-        max_retries: int | NotGiven = NOT_GIVEN,
+        max_retries: int | NotGiven = not_given,
         default_headers: Mapping[str, str] | None = None,
         set_default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
@@ -454,9 +730,10 @@ def copy(
 
         http_client = http_client or self._client
         return self.__class__(
-            api_key=api_key or self.api_key,
+            api_key=api_key or self._api_key_provider or self.api_key,
             organization=organization or self.organization,
             project=project or self.project,
+            webhook_secret=webhook_secret or self.webhook_secret,
             websocket_base_url=websocket_base_url or self.websocket_base_url,
             base_url=base_url or self.base_url,
             timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
@@ -507,75 +784,487 @@ def _make_status_error(
 
 
 class OpenAIWithRawResponse:
+    _client: OpenAI
+
     def __init__(self, client: OpenAI) -> None:
-        self.completions = completions.CompletionsWithRawResponse(client.completions)
-        self.chat = chat.ChatWithRawResponse(client.chat)
-        self.embeddings = embeddings.EmbeddingsWithRawResponse(client.embeddings)
-        self.files = files.FilesWithRawResponse(client.files)
-        self.images = images.ImagesWithRawResponse(client.images)
-        self.audio = audio.AudioWithRawResponse(client.audio)
-        self.moderations = moderations.ModerationsWithRawResponse(client.moderations)
-        self.models = models.ModelsWithRawResponse(client.models)
-        self.fine_tuning = fine_tuning.FineTuningWithRawResponse(client.fine_tuning)
-        self.vector_stores = vector_stores.VectorStoresWithRawResponse(client.vector_stores)
-        self.beta = beta.BetaWithRawResponse(client.beta)
-        self.batches = batches.BatchesWithRawResponse(client.batches)
-        self.uploads = uploads.UploadsWithRawResponse(client.uploads)
-        self.responses = responses.ResponsesWithRawResponse(client.responses)
+        self._client = client
+
+    @cached_property
+    def completions(self) -> completions.CompletionsWithRawResponse:
+        from .resources.completions import CompletionsWithRawResponse
+
+        return CompletionsWithRawResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.ChatWithRawResponse:
+        from .resources.chat import ChatWithRawResponse
+
+        return ChatWithRawResponse(self._client.chat)
+
+    @cached_property
+    def embeddings(self) -> embeddings.EmbeddingsWithRawResponse:
+        from .resources.embeddings import EmbeddingsWithRawResponse
+
+        return EmbeddingsWithRawResponse(self._client.embeddings)
+
+    @cached_property
+    def files(self) -> files.FilesWithRawResponse:
+        from .resources.files import FilesWithRawResponse
+
+        return FilesWithRawResponse(self._client.files)
+
+    @cached_property
+    def images(self) -> images.ImagesWithRawResponse:
+        from .resources.images import ImagesWithRawResponse
+
+        return ImagesWithRawResponse(self._client.images)
+
+    @cached_property
+    def audio(self) -> audio.AudioWithRawResponse:
+        from .resources.audio import AudioWithRawResponse
+
+        return AudioWithRawResponse(self._client.audio)
+
+    @cached_property
+    def moderations(self) -> moderations.ModerationsWithRawResponse:
+        from .resources.moderations import ModerationsWithRawResponse
+
+        return ModerationsWithRawResponse(self._client.moderations)
+
+    @cached_property
+    def models(self) -> models.ModelsWithRawResponse:
+        from .resources.models import ModelsWithRawResponse
+
+        return ModelsWithRawResponse(self._client.models)
+
+    @cached_property
+    def fine_tuning(self) -> fine_tuning.FineTuningWithRawResponse:
+        from .resources.fine_tuning import FineTuningWithRawResponse
+
+        return FineTuningWithRawResponse(self._client.fine_tuning)
+
+    @cached_property
+    def vector_stores(self) -> vector_stores.VectorStoresWithRawResponse:
+        from .resources.vector_stores import VectorStoresWithRawResponse
+
+        return VectorStoresWithRawResponse(self._client.vector_stores)
+
+    @cached_property
+    def beta(self) -> beta.BetaWithRawResponse:
+        from .resources.beta import BetaWithRawResponse
+
+        return BetaWithRawResponse(self._client.beta)
+
+    @cached_property
+    def batches(self) -> batches.BatchesWithRawResponse:
+        from .resources.batches import BatchesWithRawResponse
+
+        return BatchesWithRawResponse(self._client.batches)
+
+    @cached_property
+    def uploads(self) -> uploads.UploadsWithRawResponse:
+        from .resources.uploads import UploadsWithRawResponse
+
+        return UploadsWithRawResponse(self._client.uploads)
+
+    @cached_property
+    def responses(self) -> responses.ResponsesWithRawResponse:
+        from .resources.responses import ResponsesWithRawResponse
+
+        return ResponsesWithRawResponse(self._client.responses)
+
+    @cached_property
+    def realtime(self) -> realtime.RealtimeWithRawResponse:
+        from .resources.realtime import RealtimeWithRawResponse
+
+        return RealtimeWithRawResponse(self._client.realtime)
+
+    @cached_property
+    def conversations(self) -> conversations.ConversationsWithRawResponse:
+        from .resources.conversations import ConversationsWithRawResponse
+
+        return ConversationsWithRawResponse(self._client.conversations)
+
+    @cached_property
+    def evals(self) -> evals.EvalsWithRawResponse:
+        from .resources.evals import EvalsWithRawResponse
+
+        return EvalsWithRawResponse(self._client.evals)
+
+    @cached_property
+    def containers(self) -> containers.ContainersWithRawResponse:
+        from .resources.containers import ContainersWithRawResponse
+
+        return ContainersWithRawResponse(self._client.containers)
+
+    @cached_property
+    def videos(self) -> videos.VideosWithRawResponse:
+        from .resources.videos import VideosWithRawResponse
+
+        return VideosWithRawResponse(self._client.videos)
 
 
 class AsyncOpenAIWithRawResponse:
+    _client: AsyncOpenAI
+
     def __init__(self, client: AsyncOpenAI) -> None:
-        self.completions = completions.AsyncCompletionsWithRawResponse(client.completions)
-        self.chat = chat.AsyncChatWithRawResponse(client.chat)
-        self.embeddings = embeddings.AsyncEmbeddingsWithRawResponse(client.embeddings)
-        self.files = files.AsyncFilesWithRawResponse(client.files)
-        self.images = images.AsyncImagesWithRawResponse(client.images)
-        self.audio = audio.AsyncAudioWithRawResponse(client.audio)
-        self.moderations = moderations.AsyncModerationsWithRawResponse(client.moderations)
-        self.models = models.AsyncModelsWithRawResponse(client.models)
-        self.fine_tuning = fine_tuning.AsyncFineTuningWithRawResponse(client.fine_tuning)
-        self.vector_stores = vector_stores.AsyncVectorStoresWithRawResponse(client.vector_stores)
-        self.beta = beta.AsyncBetaWithRawResponse(client.beta)
-        self.batches = batches.AsyncBatchesWithRawResponse(client.batches)
-        self.uploads = uploads.AsyncUploadsWithRawResponse(client.uploads)
-        self.responses = responses.AsyncResponsesWithRawResponse(client.responses)
+        self._client = client
+
+    @cached_property
+    def completions(self) -> completions.AsyncCompletionsWithRawResponse:
+        from .resources.completions import AsyncCompletionsWithRawResponse
+
+        return AsyncCompletionsWithRawResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.AsyncChatWithRawResponse:
+        from .resources.chat import AsyncChatWithRawResponse
+
+        return AsyncChatWithRawResponse(self._client.chat)
+
+    @cached_property
+    def embeddings(self) -> embeddings.AsyncEmbeddingsWithRawResponse:
+        from .resources.embeddings import AsyncEmbeddingsWithRawResponse
+
+        return AsyncEmbeddingsWithRawResponse(self._client.embeddings)
+
+    @cached_property
+    def files(self) -> files.AsyncFilesWithRawResponse:
+        from .resources.files import AsyncFilesWithRawResponse
+
+        return AsyncFilesWithRawResponse(self._client.files)
+
+    @cached_property
+    def images(self) -> images.AsyncImagesWithRawResponse:
+        from .resources.images import AsyncImagesWithRawResponse
+
+        return AsyncImagesWithRawResponse(self._client.images)
+
+    @cached_property
+    def audio(self) -> audio.AsyncAudioWithRawResponse:
+        from .resources.audio import AsyncAudioWithRawResponse
+
+        return AsyncAudioWithRawResponse(self._client.audio)
+
+    @cached_property
+    def moderations(self) -> moderations.AsyncModerationsWithRawResponse:
+        from .resources.moderations import AsyncModerationsWithRawResponse
+
+        return AsyncModerationsWithRawResponse(self._client.moderations)
+
+    @cached_property
+    def models(self) -> models.AsyncModelsWithRawResponse:
+        from .resources.models import AsyncModelsWithRawResponse
+
+        return AsyncModelsWithRawResponse(self._client.models)
+
+    @cached_property
+    def fine_tuning(self) -> fine_tuning.AsyncFineTuningWithRawResponse:
+        from .resources.fine_tuning import AsyncFineTuningWithRawResponse
+
+        return AsyncFineTuningWithRawResponse(self._client.fine_tuning)
+
+    @cached_property
+    def vector_stores(self) -> vector_stores.AsyncVectorStoresWithRawResponse:
+        from .resources.vector_stores import AsyncVectorStoresWithRawResponse
+
+        return AsyncVectorStoresWithRawResponse(self._client.vector_stores)
+
+    @cached_property
+    def beta(self) -> beta.AsyncBetaWithRawResponse:
+        from .resources.beta import AsyncBetaWithRawResponse
+
+        return AsyncBetaWithRawResponse(self._client.beta)
+
+    @cached_property
+    def batches(self) -> batches.AsyncBatchesWithRawResponse:
+        from .resources.batches import AsyncBatchesWithRawResponse
+
+        return AsyncBatchesWithRawResponse(self._client.batches)
+
+    @cached_property
+    def uploads(self) -> uploads.AsyncUploadsWithRawResponse:
+        from .resources.uploads import AsyncUploadsWithRawResponse
+
+        return AsyncUploadsWithRawResponse(self._client.uploads)
+
+    @cached_property
+    def responses(self) -> responses.AsyncResponsesWithRawResponse:
+        from .resources.responses import AsyncResponsesWithRawResponse
+
+        return AsyncResponsesWithRawResponse(self._client.responses)
+
+    @cached_property
+    def realtime(self) -> realtime.AsyncRealtimeWithRawResponse:
+        from .resources.realtime import AsyncRealtimeWithRawResponse
+
+        return AsyncRealtimeWithRawResponse(self._client.realtime)
+
+    @cached_property
+    def conversations(self) -> conversations.AsyncConversationsWithRawResponse:
+        from .resources.conversations import AsyncConversationsWithRawResponse
+
+        return AsyncConversationsWithRawResponse(self._client.conversations)
+
+    @cached_property
+    def evals(self) -> evals.AsyncEvalsWithRawResponse:
+        from .resources.evals import AsyncEvalsWithRawResponse
+
+        return AsyncEvalsWithRawResponse(self._client.evals)
+
+    @cached_property
+    def containers(self) -> containers.AsyncContainersWithRawResponse:
+        from .resources.containers import AsyncContainersWithRawResponse
+
+        return AsyncContainersWithRawResponse(self._client.containers)
+
+    @cached_property
+    def videos(self) -> videos.AsyncVideosWithRawResponse:
+        from .resources.videos import AsyncVideosWithRawResponse
+
+        return AsyncVideosWithRawResponse(self._client.videos)
 
 
 class OpenAIWithStreamedResponse:
+    _client: OpenAI
+
     def __init__(self, client: OpenAI) -> None:
-        self.completions = completions.CompletionsWithStreamingResponse(client.completions)
-        self.chat = chat.ChatWithStreamingResponse(client.chat)
-        self.embeddings = embeddings.EmbeddingsWithStreamingResponse(client.embeddings)
-        self.files = files.FilesWithStreamingResponse(client.files)
-        self.images = images.ImagesWithStreamingResponse(client.images)
-        self.audio = audio.AudioWithStreamingResponse(client.audio)
-        self.moderations = moderations.ModerationsWithStreamingResponse(client.moderations)
-        self.models = models.ModelsWithStreamingResponse(client.models)
-        self.fine_tuning = fine_tuning.FineTuningWithStreamingResponse(client.fine_tuning)
-        self.vector_stores = vector_stores.VectorStoresWithStreamingResponse(client.vector_stores)
-        self.beta = beta.BetaWithStreamingResponse(client.beta)
-        self.batches = batches.BatchesWithStreamingResponse(client.batches)
-        self.uploads = uploads.UploadsWithStreamingResponse(client.uploads)
-        self.responses = responses.ResponsesWithStreamingResponse(client.responses)
+        self._client = client
+
+    @cached_property
+    def completions(self) -> completions.CompletionsWithStreamingResponse:
+        from .resources.completions import CompletionsWithStreamingResponse
+
+        return CompletionsWithStreamingResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.ChatWithStreamingResponse:
+        from .resources.chat import ChatWithStreamingResponse
+
+        return ChatWithStreamingResponse(self._client.chat)
+
+    @cached_property
+    def embeddings(self) -> embeddings.EmbeddingsWithStreamingResponse:
+        from .resources.embeddings import EmbeddingsWithStreamingResponse
+
+        return EmbeddingsWithStreamingResponse(self._client.embeddings)
+
+    @cached_property
+    def files(self) -> files.FilesWithStreamingResponse:
+        from .resources.files import FilesWithStreamingResponse
+
+        return FilesWithStreamingResponse(self._client.files)
+
+    @cached_property
+    def images(self) -> images.ImagesWithStreamingResponse:
+        from .resources.images import ImagesWithStreamingResponse
+
+        return ImagesWithStreamingResponse(self._client.images)
+
+    @cached_property
+    def audio(self) -> audio.AudioWithStreamingResponse:
+        from .resources.audio import AudioWithStreamingResponse
+
+        return AudioWithStreamingResponse(self._client.audio)
+
+    @cached_property
+    def moderations(self) -> moderations.ModerationsWithStreamingResponse:
+        from .resources.moderations import ModerationsWithStreamingResponse
+
+        return ModerationsWithStreamingResponse(self._client.moderations)
+
+    @cached_property
+    def models(self) -> models.ModelsWithStreamingResponse:
+        from .resources.models import ModelsWithStreamingResponse
+
+        return ModelsWithStreamingResponse(self._client.models)
+
+    @cached_property
+    def fine_tuning(self) -> fine_tuning.FineTuningWithStreamingResponse:
+        from .resources.fine_tuning import FineTuningWithStreamingResponse
+
+        return FineTuningWithStreamingResponse(self._client.fine_tuning)
+
+    @cached_property
+    def vector_stores(self) -> vector_stores.VectorStoresWithStreamingResponse:
+        from .resources.vector_stores import VectorStoresWithStreamingResponse
+
+        return VectorStoresWithStreamingResponse(self._client.vector_stores)
+
+    @cached_property
+    def beta(self) -> beta.BetaWithStreamingResponse:
+        from .resources.beta import BetaWithStreamingResponse
+
+        return BetaWithStreamingResponse(self._client.beta)
+
+    @cached_property
+    def batches(self) -> batches.BatchesWithStreamingResponse:
+        from .resources.batches import BatchesWithStreamingResponse
+
+        return BatchesWithStreamingResponse(self._client.batches)
+
+    @cached_property
+    def uploads(self) -> uploads.UploadsWithStreamingResponse:
+        from .resources.uploads import UploadsWithStreamingResponse
+
+        return UploadsWithStreamingResponse(self._client.uploads)
+
+    @cached_property
+    def responses(self) -> responses.ResponsesWithStreamingResponse:
+        from .resources.responses import ResponsesWithStreamingResponse
+
+        return ResponsesWithStreamingResponse(self._client.responses)
+
+    @cached_property
+    def realtime(self) -> realtime.RealtimeWithStreamingResponse:
+        from .resources.realtime import RealtimeWithStreamingResponse
+
+        return RealtimeWithStreamingResponse(self._client.realtime)
+
+    @cached_property
+    def conversations(self) -> conversations.ConversationsWithStreamingResponse:
+        from .resources.conversations import ConversationsWithStreamingResponse
+
+        return ConversationsWithStreamingResponse(self._client.conversations)
+
+    @cached_property
+    def evals(self) -> evals.EvalsWithStreamingResponse:
+        from .resources.evals import EvalsWithStreamingResponse
+
+        return EvalsWithStreamingResponse(self._client.evals)
+
+    @cached_property
+    def containers(self) -> containers.ContainersWithStreamingResponse:
+        from .resources.containers import ContainersWithStreamingResponse
+
+        return ContainersWithStreamingResponse(self._client.containers)
+
+    @cached_property
+    def videos(self) -> videos.VideosWithStreamingResponse:
+        from .resources.videos import VideosWithStreamingResponse
+
+        return VideosWithStreamingResponse(self._client.videos)
 
 
 class AsyncOpenAIWithStreamedResponse:
+    _client: AsyncOpenAI
+
     def __init__(self, client: AsyncOpenAI) -> None:
-        self.completions = completions.AsyncCompletionsWithStreamingResponse(client.completions)
-        self.chat = chat.AsyncChatWithStreamingResponse(client.chat)
-        self.embeddings = embeddings.AsyncEmbeddingsWithStreamingResponse(client.embeddings)
-        self.files = files.AsyncFilesWithStreamingResponse(client.files)
-        self.images = images.AsyncImagesWithStreamingResponse(client.images)
-        self.audio = audio.AsyncAudioWithStreamingResponse(client.audio)
-        self.moderations = moderations.AsyncModerationsWithStreamingResponse(client.moderations)
-        self.models = models.AsyncModelsWithStreamingResponse(client.models)
-        self.fine_tuning = fine_tuning.AsyncFineTuningWithStreamingResponse(client.fine_tuning)
-        self.vector_stores = vector_stores.AsyncVectorStoresWithStreamingResponse(client.vector_stores)
-        self.beta = beta.AsyncBetaWithStreamingResponse(client.beta)
-        self.batches = batches.AsyncBatchesWithStreamingResponse(client.batches)
-        self.uploads = uploads.AsyncUploadsWithStreamingResponse(client.uploads)
-        self.responses = responses.AsyncResponsesWithStreamingResponse(client.responses)
+        self._client = client
+
+    @cached_property
+    def completions(self) -> completions.AsyncCompletionsWithStreamingResponse:
+        from .resources.completions import AsyncCompletionsWithStreamingResponse
+
+        return AsyncCompletionsWithStreamingResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.AsyncChatWithStreamingResponse:
+        from .resources.chat import AsyncChatWithStreamingResponse
+
+        return AsyncChatWithStreamingResponse(self._client.chat)
+
+    @cached_property
+    def embeddings(self) -> embeddings.AsyncEmbeddingsWithStreamingResponse:
+        from .resources.embeddings import AsyncEmbeddingsWithStreamingResponse
+
+        return AsyncEmbeddingsWithStreamingResponse(self._client.embeddings)
+
+    @cached_property
+    def files(self) -> files.AsyncFilesWithStreamingResponse:
+        from .resources.files import AsyncFilesWithStreamingResponse
+
+        return AsyncFilesWithStreamingResponse(self._client.files)
+
+    @cached_property
+    def images(self) -> images.AsyncImagesWithStreamingResponse:
+        from .resources.images import AsyncImagesWithStreamingResponse
+
+        return AsyncImagesWithStreamingResponse(self._client.images)
+
+    @cached_property
+    def audio(self) -> audio.AsyncAudioWithStreamingResponse:
+        from .resources.audio import AsyncAudioWithStreamingResponse
+
+        return AsyncAudioWithStreamingResponse(self._client.audio)
+
+    @cached_property
+    def moderations(self) -> moderations.AsyncModerationsWithStreamingResponse:
+        from .resources.moderations import AsyncModerationsWithStreamingResponse
+
+        return AsyncModerationsWithStreamingResponse(self._client.moderations)
+
+    @cached_property
+    def models(self) -> models.AsyncModelsWithStreamingResponse:
+        from .resources.models import AsyncModelsWithStreamingResponse
+
+        return AsyncModelsWithStreamingResponse(self._client.models)
+
+    @cached_property
+    def fine_tuning(self) -> fine_tuning.AsyncFineTuningWithStreamingResponse:
+        from .resources.fine_tuning import AsyncFineTuningWithStreamingResponse
+
+        return AsyncFineTuningWithStreamingResponse(self._client.fine_tuning)
+
+    @cached_property
+    def vector_stores(self) -> vector_stores.AsyncVectorStoresWithStreamingResponse:
+        from .resources.vector_stores import AsyncVectorStoresWithStreamingResponse
+
+        return AsyncVectorStoresWithStreamingResponse(self._client.vector_stores)
+
+    @cached_property
+    def beta(self) -> beta.AsyncBetaWithStreamingResponse:
+        from .resources.beta import AsyncBetaWithStreamingResponse
+
+        return AsyncBetaWithStreamingResponse(self._client.beta)
+
+    @cached_property
+    def batches(self) -> batches.AsyncBatchesWithStreamingResponse:
+        from .resources.batches import AsyncBatchesWithStreamingResponse
+
+        return AsyncBatchesWithStreamingResponse(self._client.batches)
+
+    @cached_property
+    def uploads(self) -> uploads.AsyncUploadsWithStreamingResponse:
+        from .resources.uploads import AsyncUploadsWithStreamingResponse
+
+        return AsyncUploadsWithStreamingResponse(self._client.uploads)
+
+    @cached_property
+    def responses(self) -> responses.AsyncResponsesWithStreamingResponse:
+        from .resources.responses import AsyncResponsesWithStreamingResponse
+
+        return AsyncResponsesWithStreamingResponse(self._client.responses)
+
+    @cached_property
+    def realtime(self) -> realtime.AsyncRealtimeWithStreamingResponse:
+        from .resources.realtime import AsyncRealtimeWithStreamingResponse
+
+        return AsyncRealtimeWithStreamingResponse(self._client.realtime)
+
+    @cached_property
+    def conversations(self) -> conversations.AsyncConversationsWithStreamingResponse:
+        from .resources.conversations import AsyncConversationsWithStreamingResponse
+
+        return AsyncConversationsWithStreamingResponse(self._client.conversations)
+
+    @cached_property
+    def evals(self) -> evals.AsyncEvalsWithStreamingResponse:
+        from .resources.evals import AsyncEvalsWithStreamingResponse
+
+        return AsyncEvalsWithStreamingResponse(self._client.evals)
+
+    @cached_property
+    def containers(self) -> containers.AsyncContainersWithStreamingResponse:
+        from .resources.containers import AsyncContainersWithStreamingResponse
+
+        return AsyncContainersWithStreamingResponse(self._client.containers)
+
+    @cached_property
+    def videos(self) -> videos.AsyncVideosWithStreamingResponse:
+        from .resources.videos import AsyncVideosWithStreamingResponse
+
+        return AsyncVideosWithStreamingResponse(self._client.videos)
 
 
 Client = OpenAI
diff --git a/src/openai/_compat.py b/src/openai/_compat.py
index 87fc370765..73a1f3ea93 100644
--- a/src/openai/_compat.py
+++ b/src/openai/_compat.py
@@ -12,14 +12,13 @@
 _T = TypeVar("_T")
 _ModelT = TypeVar("_ModelT", bound=pydantic.BaseModel)
 
-# --------------- Pydantic v2 compatibility ---------------
+# --------------- Pydantic v2, v3 compatibility ---------------
 
 # Pyright incorrectly reports some of our functions as overriding a method when they don't
 # pyright: reportIncompatibleMethodOverride=false
 
-PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
 
-# v1 re-exports
 if TYPE_CHECKING:
 
     def parse_date(value: date | StrBytesIntFloat) -> date:  # noqa: ARG001
@@ -44,90 +43,92 @@ def is_typeddict(type_: type[Any]) -> bool:  # noqa: ARG001
         ...
 
 else:
-    if PYDANTIC_V2:
-        from pydantic.v1.typing import (
+    # v1 re-exports
+    if PYDANTIC_V1:
+        from pydantic.typing import (
             get_args as get_args,
             is_union as is_union,
             get_origin as get_origin,
             is_typeddict as is_typeddict,
             is_literal_type as is_literal_type,
         )
-        from pydantic.v1.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
+        from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
     else:
-        from pydantic.typing import (
+        from ._utils import (
             get_args as get_args,
             is_union as is_union,
             get_origin as get_origin,
+            parse_date as parse_date,
             is_typeddict as is_typeddict,
+            parse_datetime as parse_datetime,
             is_literal_type as is_literal_type,
         )
-        from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
 
 
 # refactored config
 if TYPE_CHECKING:
     from pydantic import ConfigDict as ConfigDict
 else:
-    if PYDANTIC_V2:
-        from pydantic import ConfigDict
-    else:
+    if PYDANTIC_V1:
         # TODO: provide an error message here?
         ConfigDict = None
+    else:
+        from pydantic import ConfigDict as ConfigDict
 
 
 # renamed methods / properties
 def parse_obj(model: type[_ModelT], value: object) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_validate(value)
-    else:
+    if PYDANTIC_V1:
         return cast(_ModelT, model.parse_obj(value))  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
+    else:
+        return model.model_validate(value)
 
 
 def field_is_required(field: FieldInfo) -> bool:
-    if PYDANTIC_V2:
-        return field.is_required()
-    return field.required  # type: ignore
+    if PYDANTIC_V1:
+        return field.required  # type: ignore
+    return field.is_required()
 
 
 def field_get_default(field: FieldInfo) -> Any:
     value = field.get_default()
-    if PYDANTIC_V2:
-        from pydantic_core import PydanticUndefined
-
-        if value == PydanticUndefined:
-            return None
+    if PYDANTIC_V1:
         return value
+    from pydantic_core import PydanticUndefined
+
+    if value == PydanticUndefined:
+        return None
     return value
 
 
 def field_outer_type(field: FieldInfo) -> Any:
-    if PYDANTIC_V2:
-        return field.annotation
-    return field.outer_type_  # type: ignore
+    if PYDANTIC_V1:
+        return field.outer_type_  # type: ignore
+    return field.annotation
 
 
 def get_model_config(model: type[pydantic.BaseModel]) -> Any:
-    if PYDANTIC_V2:
-        return model.model_config
-    return model.__config__  # type: ignore
+    if PYDANTIC_V1:
+        return model.__config__  # type: ignore
+    return model.model_config
 
 
 def get_model_fields(model: type[pydantic.BaseModel]) -> dict[str, FieldInfo]:
-    if PYDANTIC_V2:
-        return model.model_fields
-    return model.__fields__  # type: ignore
+    if PYDANTIC_V1:
+        return model.__fields__  # type: ignore
+    return model.model_fields
 
 
 def model_copy(model: _ModelT, *, deep: bool = False) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_copy(deep=deep)
-    return model.copy(deep=deep)  # type: ignore
+    if PYDANTIC_V1:
+        return model.copy(deep=deep)  # type: ignore
+    return model.model_copy(deep=deep)
 
 
 def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str:
-    if PYDANTIC_V2:
-        return model.model_dump_json(indent=indent)
-    return model.json(indent=indent)  # type: ignore
+    if PYDANTIC_V1:
+        return model.json(indent=indent)  # type: ignore
+    return model.model_dump_json(indent=indent)
 
 
 def model_dump(
@@ -139,14 +140,14 @@ def model_dump(
     warnings: bool = True,
     mode: Literal["json", "python"] = "python",
 ) -> dict[str, Any]:
-    if PYDANTIC_V2 or hasattr(model, "model_dump"):
+    if (not PYDANTIC_V1) or hasattr(model, "model_dump"):
         return model.model_dump(
             mode=mode,
             exclude=exclude,
             exclude_unset=exclude_unset,
             exclude_defaults=exclude_defaults,
             # warnings are not supported in Pydantic v1
-            warnings=warnings if PYDANTIC_V2 else True,
+            warnings=True if PYDANTIC_V1 else warnings,
         )
     return cast(
         "dict[str, Any]",
@@ -159,21 +160,21 @@ def model_dump(
 
 
 def model_parse(model: type[_ModelT], data: Any) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_validate(data)
-    return model.parse_obj(data)  # pyright: ignore[reportDeprecated]
+    if PYDANTIC_V1:
+        return model.parse_obj(data)  # pyright: ignore[reportDeprecated]
+    return model.model_validate(data)
 
 
 def model_parse_json(model: type[_ModelT], data: str | bytes) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_validate_json(data)
-    return model.parse_raw(data)  # pyright: ignore[reportDeprecated]
+    if PYDANTIC_V1:
+        return model.parse_raw(data)  # pyright: ignore[reportDeprecated]
+    return model.model_validate_json(data)
 
 
 def model_json_schema(model: type[_ModelT]) -> dict[str, Any]:
-    if PYDANTIC_V2:
-        return model.model_json_schema()
-    return model.schema()  # pyright: ignore[reportDeprecated]
+    if PYDANTIC_V1:
+        return model.schema()  # pyright: ignore[reportDeprecated]
+    return model.model_json_schema()
 
 
 # generic models
@@ -182,17 +183,16 @@ def model_json_schema(model: type[_ModelT]) -> dict[str, Any]:
     class GenericModel(pydantic.BaseModel): ...
 
 else:
-    if PYDANTIC_V2:
+    if PYDANTIC_V1:
+        import pydantic.generics
+
+        class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ...
+    else:
         # there no longer needs to be a distinction in v2 but
         # we still have to create our own subclass to avoid
         # inconsistent MRO ordering errors
         class GenericModel(pydantic.BaseModel): ...
 
-    else:
-        import pydantic.generics
-
-        class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ...
-
 
 # cached properties
 if TYPE_CHECKING:
diff --git a/src/openai/_exceptions.py b/src/openai/_exceptions.py
index e326ed9578..09016dfedb 100644
--- a/src/openai/_exceptions.py
+++ b/src/openai/_exceptions.py
@@ -24,6 +24,7 @@
     "InternalServerError",
     "LengthFinishReasonError",
     "ContentFilterFinishReasonError",
+    "InvalidWebhookSignatureError",
 ]
 
 
@@ -154,3 +155,7 @@ def __init__(self) -> None:
         super().__init__(
             f"Could not parse response content as the request was rejected by the content filter",
         )
+
+
+class InvalidWebhookSignatureError(ValueError):
+    """Raised when a webhook signature is invalid, meaning the computed signature does not match the expected signature."""
diff --git a/src/openai/_extras/__init__.py b/src/openai/_extras/__init__.py
index 864dac4171..692de248c0 100644
--- a/src/openai/_extras/__init__.py
+++ b/src/openai/_extras/__init__.py
@@ -1,2 +1,3 @@
 from .numpy_proxy import numpy as numpy, has_numpy as has_numpy
 from .pandas_proxy import pandas as pandas
+from .sounddevice_proxy import sounddevice as sounddevice
diff --git a/src/openai/_extras/numpy_proxy.py b/src/openai/_extras/numpy_proxy.py
index 27880bf132..2b0669576e 100644
--- a/src/openai/_extras/numpy_proxy.py
+++ b/src/openai/_extras/numpy_proxy.py
@@ -10,7 +10,7 @@
     import numpy as numpy
 
 
-NUMPY_INSTRUCTIONS = format_instructions(library="numpy", extra="datalib")
+NUMPY_INSTRUCTIONS = format_instructions(library="numpy", extra="voice_helpers")
 
 
 class NumpyProxy(LazyProxy[Any]):
diff --git a/src/openai/_extras/sounddevice_proxy.py b/src/openai/_extras/sounddevice_proxy.py
new file mode 100644
index 0000000000..482d4c6874
--- /dev/null
+++ b/src/openai/_extras/sounddevice_proxy.py
@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from typing_extensions import override
+
+from .._utils import LazyProxy
+from ._common import MissingDependencyError, format_instructions
+
+if TYPE_CHECKING:
+    import sounddevice as sounddevice  # type: ignore
+
+
+SOUNDDEVICE_INSTRUCTIONS = format_instructions(library="sounddevice", extra="voice_helpers")
+
+
+class SounddeviceProxy(LazyProxy[Any]):
+    @override
+    def __load__(self) -> Any:
+        try:
+            import sounddevice  # type: ignore
+        except ImportError as err:
+            raise MissingDependencyError(SOUNDDEVICE_INSTRUCTIONS) from err
+
+        return sounddevice
+
+
+if not TYPE_CHECKING:
+    sounddevice = SounddeviceProxy()
diff --git a/src/openai/_files.py b/src/openai/_files.py
index 801a0d2928..7b23ca084a 100644
--- a/src/openai/_files.py
+++ b/src/openai/_files.py
@@ -69,12 +69,12 @@ def _transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], _read_file_content(file[1]), *file[2:])
+        return (file[0], read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-def _read_file_content(file: FileContent) -> HttpxFileContent:
+def read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return pathlib.Path(file).read_bytes()
     return file
@@ -111,12 +111,12 @@ async def _async_transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], await _async_read_file_content(file[1]), *file[2:])
+        return (file[0], await async_read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-async def _async_read_file_content(file: FileContent) -> HttpxFileContent:
+async def async_read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return await anyio.Path(file).read_bytes()
 
diff --git a/src/openai/_legacy_response.py b/src/openai/_legacy_response.py
index 8880e5f104..cfabaa2fc2 100644
--- a/src/openai/_legacy_response.py
+++ b/src/openai/_legacy_response.py
@@ -304,7 +304,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T:
         # split is required to handle cases where additional information is included
         # in the response, e.g. application/json; charset=utf-8
         content_type, *_ = response.headers.get("content-type", "*").split(";")
-        if content_type != "application/json":
+        if not content_type.endswith("json"):
             if is_basemodel(cast_to):
                 try:
                     data = response.json()
diff --git a/src/openai/_models.py b/src/openai/_models.py
index 92986bfdf5..fac59c2cb8 100644
--- a/src/openai/_models.py
+++ b/src/openai/_models.py
@@ -2,9 +2,11 @@
 
 import os
 import inspect
+import weakref
 from typing import TYPE_CHECKING, Any, Type, Tuple, Union, Generic, TypeVar, Callable, Optional, cast
 from datetime import date, datetime
 from typing_extensions import (
+    List,
     Unpack,
     Literal,
     ClassVar,
@@ -20,7 +22,6 @@
 )
 
 import pydantic
-import pydantic.generics
 from pydantic.fields import FieldInfo
 
 from ._types import (
@@ -51,7 +52,7 @@
     strip_annotated_type,
 )
 from ._compat import (
-    PYDANTIC_V2,
+    PYDANTIC_V1,
     ConfigDict,
     GenericModel as BaseGenericModel,
     get_args,
@@ -66,7 +67,7 @@
 from ._constants import RAW_RESPONSE_HEADER
 
 if TYPE_CHECKING:
-    from pydantic_core.core_schema import ModelField, LiteralSchema, ModelFieldsSchema
+    from pydantic_core.core_schema import ModelField, ModelSchema, LiteralSchema, ModelFieldsSchema
 
 __all__ = ["BaseModel", "GenericModel"]
 
@@ -84,11 +85,7 @@ class _ConfigProtocol(Protocol):
 
 
 class BaseModel(pydantic.BaseModel):
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(
-            extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true"))
-        )
-    else:
+    if PYDANTIC_V1:
 
         @property
         @override
@@ -103,6 +100,10 @@ class Config(pydantic.BaseConfig):  # pyright: ignore[reportDeprecated]
         def __repr_args__(self) -> ReprArgs:
             # we don't want these attributes to be included when something like `rich.print` is used
             return [arg for arg in super().__repr_args__() if arg[0] not in {"_request_id", "__exclude_fields__"}]
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(
+            extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true"))
+        )
 
     if TYPE_CHECKING:
         _request_id: Optional[str] = None
@@ -233,28 +234,32 @@ def construct(  # pyright: ignore[reportIncompatibleMethodOverride]
             else:
                 fields_values[name] = field_get_default(field)
 
+        extra_field_type = _get_extra_fields_type(__cls)
+
         _extra = {}
         for key, value in values.items():
             if key not in model_fields:
-                if PYDANTIC_V2:
-                    _extra[key] = value
-                else:
+                parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value
+
+                if PYDANTIC_V1:
                     _fields_set.add(key)
-                    fields_values[key] = value
+                    fields_values[key] = parsed
+                else:
+                    _extra[key] = parsed
 
         object.__setattr__(m, "__dict__", fields_values)
 
-        if PYDANTIC_V2:
-            # these properties are copied from Pydantic's `model_construct()` method
-            object.__setattr__(m, "__pydantic_private__", None)
-            object.__setattr__(m, "__pydantic_extra__", _extra)
-            object.__setattr__(m, "__pydantic_fields_set__", _fields_set)
-        else:
+        if PYDANTIC_V1:
             # init_private_attributes() does not exist in v2
             m._init_private_attributes()  # type: ignore
 
             # copied from Pydantic v1's `construct()` method
             object.__setattr__(m, "__fields_set__", _fields_set)
+        else:
+            # these properties are copied from Pydantic's `model_construct()` method
+            object.__setattr__(m, "__pydantic_private__", None)
+            object.__setattr__(m, "__pydantic_extra__", _extra)
+            object.__setattr__(m, "__pydantic_fields_set__", _fields_set)
 
         return m
 
@@ -264,7 +269,7 @@ def construct(  # pyright: ignore[reportIncompatibleMethodOverride]
         # although not in practice
         model_construct = construct
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         # we define aliases for some of the new pydantic v2 methods so
         # that we can just document these methods without having to specify
         # a specific pydantic version as some users may not know which
@@ -277,13 +282,15 @@ def model_dump(
             mode: Literal["json", "python"] | str = "python",
             include: IncEx | None = None,
             exclude: IncEx | None = None,
-            by_alias: bool = False,
+            context: Any | None = None,
+            by_alias: bool | None = None,
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
-            context: dict[str, Any] | None = None,
+            fallback: Callable[[Any], Any] | None = None,
             serialize_as_any: bool = False,
         ) -> dict[str, Any]:
             """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump
@@ -292,16 +299,24 @@ def model_dump(
 
             Args:
                 mode: The mode in which `to_python` should run.
-                    If mode is 'json', the dictionary will only contain JSON serializable types.
-                    If mode is 'python', the dictionary may contain any Python objects.
-                include: A list of fields to include in the output.
-                exclude: A list of fields to exclude from the output.
+                    If mode is 'json', the output will only contain JSON serializable types.
+                    If mode is 'python', the output may contain non-JSON-serializable Python objects.
+                include: A set of fields to include in the output.
+                exclude: A set of fields to exclude from the output.
+                context: Additional context to pass to the serializer.
                 by_alias: Whether to use the field's alias in the dictionary key if defined.
-                exclude_unset: Whether to exclude fields that are unset or None from the output.
-                exclude_defaults: Whether to exclude fields that are set to their default value from the output.
-                exclude_none: Whether to exclude fields that have a value of `None` from the output.
-                round_trip: Whether to enable serialization and deserialization round-trip support.
-                warnings: Whether to log warnings when invalid fields are encountered.
+                exclude_unset: Whether to exclude fields that have not been explicitly set.
+                exclude_defaults: Whether to exclude fields that are set to their default value.
+                exclude_none: Whether to exclude fields that have a value of `None`.
+                exclude_computed_fields: Whether to exclude computed fields.
+                    While this can be useful for round-tripping, it is usually recommended to use the dedicated
+                    `round_trip` parameter instead.
+                round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+                warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+                    "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
+                fallback: A function to call when an unknown value is encountered. If not provided,
+                    a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+                serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 
             Returns:
                 A dictionary representation of the model.
@@ -316,31 +331,38 @@ def model_dump(
                 raise ValueError("context is only supported in Pydantic v2")
             if serialize_as_any != False:
                 raise ValueError("serialize_as_any is only supported in Pydantic v2")
+            if fallback is not None:
+                raise ValueError("fallback is only supported in Pydantic v2")
+            if exclude_computed_fields != False:
+                raise ValueError("exclude_computed_fields is only supported in Pydantic v2")
             dumped = super().dict(  # pyright: ignore[reportDeprecated]
                 include=include,
                 exclude=exclude,
-                by_alias=by_alias,
+                by_alias=by_alias if by_alias is not None else False,
                 exclude_unset=exclude_unset,
                 exclude_defaults=exclude_defaults,
                 exclude_none=exclude_none,
             )
 
-            return cast(dict[str, Any], json_safe(dumped)) if mode == "json" else dumped
+            return cast("dict[str, Any]", json_safe(dumped)) if mode == "json" else dumped
 
         @override
         def model_dump_json(
             self,
             *,
             indent: int | None = None,
+            ensure_ascii: bool = False,
             include: IncEx | None = None,
             exclude: IncEx | None = None,
-            by_alias: bool = False,
+            context: Any | None = None,
+            by_alias: bool | None = None,
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
-            context: dict[str, Any] | None = None,
+            fallback: Callable[[Any], Any] | None = None,
             serialize_as_any: bool = False,
         ) -> str:
             """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump_json
@@ -369,11 +391,17 @@ def model_dump_json(
                 raise ValueError("context is only supported in Pydantic v2")
             if serialize_as_any != False:
                 raise ValueError("serialize_as_any is only supported in Pydantic v2")
+            if fallback is not None:
+                raise ValueError("fallback is only supported in Pydantic v2")
+            if ensure_ascii != False:
+                raise ValueError("ensure_ascii is only supported in Pydantic v2")
+            if exclude_computed_fields != False:
+                raise ValueError("exclude_computed_fields is only supported in Pydantic v2")
             return super().json(  # type: ignore[reportDeprecated]
                 indent=indent,
                 include=include,
                 exclude=exclude,
-                by_alias=by_alias,
+                by_alias=by_alias if by_alias is not None else False,
                 exclude_unset=exclude_unset,
                 exclude_defaults=exclude_defaults,
                 exclude_none=exclude_none,
@@ -384,15 +412,32 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     if value is None:
         return field_get_default(field)
 
-    if PYDANTIC_V2:
-        type_ = field.annotation
-    else:
+    if PYDANTIC_V1:
         type_ = cast(type, field.outer_type_)  # type: ignore
+    else:
+        type_ = field.annotation  # type: ignore
 
     if type_ is None:
         raise RuntimeError(f"Unexpected field type is None for {key}")
 
-    return construct_type(value=value, type_=type_)
+    return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None))
+
+
+def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None:
+    if PYDANTIC_V1:
+        # TODO
+        return None
+
+    schema = cls.__pydantic_core_schema__
+    if schema["type"] == "model":
+        fields = schema["schema"]
+        if fields["type"] == "model-fields":
+            extras = fields.get("extras_schema")
+            if extras and "cls" in extras:
+                # mypy can't narrow the type
+                return extras["cls"]  # type: ignore[no-any-return]
+
+    return None
 
 
 def is_basemodel(type_: type) -> bool:
@@ -446,7 +491,7 @@ def construct_type_unchecked(*, value: object, type_: type[_T]) -> _T:
     return cast(_T, construct_type(value=value, type_=type_))
 
 
-def construct_type(*, value: object, type_: object) -> object:
+def construct_type(*, value: object, type_: object, metadata: Optional[List[Any]] = None) -> object:
     """Loose coercion to the expected type with construction of nested values.
 
     If the given value does not match the expected type then it is returned as-is.
@@ -464,8 +509,10 @@ def construct_type(*, value: object, type_: object) -> object:
         type_ = type_.__value__  # type: ignore[unreachable]
 
     # unwrap `Annotated[T, ...]` -> `T`
-    if is_annotated_type(type_):
-        meta: tuple[Any, ...] = get_args(type_)[1:]
+    if metadata is not None and len(metadata) > 0:
+        meta: tuple[Any, ...] = tuple(metadata)
+    elif is_annotated_type(type_):
+        meta = get_args(type_)[1:]
         type_ = extract_type_arg(type_, 0)
     else:
         meta = tuple()
@@ -569,6 +616,9 @@ class CachedDiscriminatorType(Protocol):
     __discriminator__: DiscriminatorDetails
 
 
+DISCRIMINATOR_CACHE: weakref.WeakKeyDictionary[type, DiscriminatorDetails] = weakref.WeakKeyDictionary()
+
+
 class DiscriminatorDetails:
     field_name: str
     """The name of the discriminator field in the variant class, e.g.
@@ -611,8 +661,9 @@ def __init__(
 
 
 def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any, ...]) -> DiscriminatorDetails | None:
-    if isinstance(union, CachedDiscriminatorType):
-        return union.__discriminator__
+    cached = DISCRIMINATOR_CACHE.get(union)
+    if cached is not None:
+        return cached
 
     discriminator_field_name: str | None = None
 
@@ -630,30 +681,30 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any,
     for variant in get_args(union):
         variant = strip_annotated_type(variant)
         if is_basemodel_type(variant):
-            if PYDANTIC_V2:
-                field = _extract_field_schema_pv2(variant, discriminator_field_name)
-                if not field:
+            if PYDANTIC_V1:
+                field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name)  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
+                if not field_info:
                     continue
 
                 # Note: if one variant defines an alias then they all should
-                discriminator_alias = field.get("serialization_alias")
-
-                field_schema = field["schema"]
+                discriminator_alias = field_info.alias
 
-                if field_schema["type"] == "literal":
-                    for entry in cast("LiteralSchema", field_schema)["expected"]:
+                if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation):
+                    for entry in get_args(annotation):
                         if isinstance(entry, str):
                             mapping[entry] = variant
             else:
-                field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name)  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-                if not field_info:
+                field = _extract_field_schema_pv2(variant, discriminator_field_name)
+                if not field:
                     continue
 
                 # Note: if one variant defines an alias then they all should
-                discriminator_alias = field_info.alias
+                discriminator_alias = field.get("serialization_alias")
 
-                if field_info.annotation and is_literal_type(field_info.annotation):
-                    for entry in get_args(field_info.annotation):
+                field_schema = field["schema"]
+
+                if field_schema["type"] == "literal":
+                    for entry in cast("LiteralSchema", field_schema)["expected"]:
                         if isinstance(entry, str):
                             mapping[entry] = variant
 
@@ -665,21 +716,24 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any,
         discriminator_field=discriminator_field_name,
         discriminator_alias=discriminator_alias,
     )
-    cast(CachedDiscriminatorType, union).__discriminator__ = details
+    DISCRIMINATOR_CACHE.setdefault(union, details)
     return details
 
 
 def _extract_field_schema_pv2(model: type[BaseModel], field_name: str) -> ModelField | None:
     schema = model.__pydantic_core_schema__
+    if schema["type"] == "definitions":
+        schema = schema["schema"]
+
     if schema["type"] != "model":
         return None
 
+    schema = cast("ModelSchema", schema)
     fields_schema = schema["schema"]
     if fields_schema["type"] != "model-fields":
         return None
 
     fields_schema = cast("ModelFieldsSchema", fields_schema)
-
     field = fields_schema["fields"].get(field_name)
     if not field:
         return None
@@ -709,7 +763,7 @@ def add_request_id(obj: BaseModel, request_id: str | None) -> None:
     # in Pydantic v1, using setattr like we do above causes the attribute
     # to be included when serializing the model which we don't want in this
     # case so we need to explicitly exclude it
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         try:
             exclude_fields = obj.__exclude_fields__  # type: ignore
         except AttributeError:
@@ -718,7 +772,7 @@ def add_request_id(obj: BaseModel, request_id: str | None) -> None:
             cast(Any, obj).__exclude_fields__ = {*(exclude_fields or {}), "_request_id", "__exclude_fields__"}
 
 
-# our use of subclasssing here causes weirdness for type checkers,
+# our use of subclassing here causes weirdness for type checkers,
 # so we just pretend that we don't subclass
 if TYPE_CHECKING:
     GenericModel = BaseModel
@@ -728,7 +782,7 @@ class GenericModel(BaseGenericModel, BaseModel):
         pass
 
 
-if PYDANTIC_V2:
+if not PYDANTIC_V1:
     from pydantic import TypeAdapter as _TypeAdapter
 
     _CachedTypeAdapter = cast("TypeAdapter[object]", lru_cache(maxsize=None)(_TypeAdapter))
@@ -775,6 +829,7 @@ class FinalRequestOptionsInput(TypedDict, total=False):
     idempotency_key: str
     json_data: Body
     extra_json: AnyMapping
+    follow_redirects: bool
 
 
 @final
@@ -788,18 +843,19 @@ class FinalRequestOptions(pydantic.BaseModel):
     files: Union[HttpxRequestFiles, None] = None
     idempotency_key: Union[str, None] = None
     post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven()
+    follow_redirects: Union[bool, None] = None
 
     # It should be noted that we cannot use `json` here as that would override
     # a BaseModel method in an incompatible fashion.
     json_data: Union[Body, None] = None
     extra_json: Union[AnyMapping, None] = None
 
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
-    else:
+    if PYDANTIC_V1:
 
         class Config(pydantic.BaseConfig):  # pyright: ignore[reportDeprecated]
             arbitrary_types_allowed: bool = True
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
 
     def get_max_retries(self, max_retries: int) -> int:
         if isinstance(self.max_retries, NotGiven):
@@ -832,9 +888,9 @@ def construct(  # type: ignore
             key: strip_not_given(value)
             for key, value in values.items()
         }
-        if PYDANTIC_V2:
-            return super().model_construct(_fields_set, **kwargs)
-        return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs))  # pyright: ignore[reportDeprecated]
+        if PYDANTIC_V1:
+            return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs))  # pyright: ignore[reportDeprecated]
+        return super().model_construct(_fields_set, **kwargs)
 
     if not TYPE_CHECKING:
         # type checkers incorrectly complain about this assignment
diff --git a/src/openai/_module_client.py b/src/openai/_module_client.py
index e7d2657860..d0d721887b 100644
--- a/src/openai/_module_client.py
+++ b/src/openai/_module_client.py
@@ -1,106 +1,173 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 from typing_extensions import override
 
-from . import resources, _load_client
+if TYPE_CHECKING:
+    from .resources.files import Files
+    from .resources.images import Images
+    from .resources.models import Models
+    from .resources.videos import Videos
+    from .resources.batches import Batches
+    from .resources.webhooks import Webhooks
+    from .resources.beta.beta import Beta
+    from .resources.chat.chat import Chat
+    from .resources.embeddings import Embeddings
+    from .resources.audio.audio import Audio
+    from .resources.completions import Completions
+    from .resources.evals.evals import Evals
+    from .resources.moderations import Moderations
+    from .resources.uploads.uploads import Uploads
+    from .resources.realtime.realtime import Realtime
+    from .resources.responses.responses import Responses
+    from .resources.containers.containers import Containers
+    from .resources.fine_tuning.fine_tuning import FineTuning
+    from .resources.conversations.conversations import Conversations
+    from .resources.vector_stores.vector_stores import VectorStores
+
+from . import _load_client
 from ._utils import LazyProxy
 
 
-class ChatProxy(LazyProxy[resources.Chat]):
+class ChatProxy(LazyProxy["Chat"]):
     @override
-    def __load__(self) -> resources.Chat:
+    def __load__(self) -> Chat:
         return _load_client().chat
 
 
-class BetaProxy(LazyProxy[resources.Beta]):
+class BetaProxy(LazyProxy["Beta"]):
     @override
-    def __load__(self) -> resources.Beta:
+    def __load__(self) -> Beta:
         return _load_client().beta
 
 
-class FilesProxy(LazyProxy[resources.Files]):
+class FilesProxy(LazyProxy["Files"]):
     @override
-    def __load__(self) -> resources.Files:
+    def __load__(self) -> Files:
         return _load_client().files
 
 
-class AudioProxy(LazyProxy[resources.Audio]):
+class AudioProxy(LazyProxy["Audio"]):
     @override
-    def __load__(self) -> resources.Audio:
+    def __load__(self) -> Audio:
         return _load_client().audio
 
 
-class ImagesProxy(LazyProxy[resources.Images]):
+class EvalsProxy(LazyProxy["Evals"]):
     @override
-    def __load__(self) -> resources.Images:
+    def __load__(self) -> Evals:
+        return _load_client().evals
+
+
+class ImagesProxy(LazyProxy["Images"]):
+    @override
+    def __load__(self) -> Images:
         return _load_client().images
 
 
-class ModelsProxy(LazyProxy[resources.Models]):
+class ModelsProxy(LazyProxy["Models"]):
     @override
-    def __load__(self) -> resources.Models:
+    def __load__(self) -> Models:
         return _load_client().models
 
 
-class BatchesProxy(LazyProxy[resources.Batches]):
+class VideosProxy(LazyProxy["Videos"]):
     @override
-    def __load__(self) -> resources.Batches:
+    def __load__(self) -> Videos:
+        return _load_client().videos
+
+
+class BatchesProxy(LazyProxy["Batches"]):
+    @override
+    def __load__(self) -> Batches:
         return _load_client().batches
 
 
-class UploadsProxy(LazyProxy[resources.Uploads]):
+class UploadsProxy(LazyProxy["Uploads"]):
     @override
-    def __load__(self) -> resources.Uploads:
+    def __load__(self) -> Uploads:
         return _load_client().uploads
 
 
-class ResponsesProxy(LazyProxy[resources.Responses]):
+class WebhooksProxy(LazyProxy["Webhooks"]):
     @override
-    def __load__(self) -> resources.Responses:
+    def __load__(self) -> Webhooks:
+        return _load_client().webhooks
+
+
+class RealtimeProxy(LazyProxy["Realtime"]):
+    @override
+    def __load__(self) -> Realtime:
+        return _load_client().realtime
+
+
+class ResponsesProxy(LazyProxy["Responses"]):
+    @override
+    def __load__(self) -> Responses:
         return _load_client().responses
 
 
-class EmbeddingsProxy(LazyProxy[resources.Embeddings]):
+class EmbeddingsProxy(LazyProxy["Embeddings"]):
     @override
-    def __load__(self) -> resources.Embeddings:
+    def __load__(self) -> Embeddings:
         return _load_client().embeddings
 
 
-class CompletionsProxy(LazyProxy[resources.Completions]):
+class ContainersProxy(LazyProxy["Containers"]):
     @override
-    def __load__(self) -> resources.Completions:
+    def __load__(self) -> Containers:
+        return _load_client().containers
+
+
+class CompletionsProxy(LazyProxy["Completions"]):
+    @override
+    def __load__(self) -> Completions:
         return _load_client().completions
 
 
-class ModerationsProxy(LazyProxy[resources.Moderations]):
+class ModerationsProxy(LazyProxy["Moderations"]):
     @override
-    def __load__(self) -> resources.Moderations:
+    def __load__(self) -> Moderations:
         return _load_client().moderations
 
 
-class FineTuningProxy(LazyProxy[resources.FineTuning]):
+class FineTuningProxy(LazyProxy["FineTuning"]):
     @override
-    def __load__(self) -> resources.FineTuning:
+    def __load__(self) -> FineTuning:
         return _load_client().fine_tuning
 
 
-class VectorStoresProxy(LazyProxy[resources.VectorStores]):
+class VectorStoresProxy(LazyProxy["VectorStores"]):
     @override
-    def __load__(self) -> resources.VectorStores:
+    def __load__(self) -> VectorStores:
         return _load_client().vector_stores
 
 
-chat: resources.Chat = ChatProxy().__as_proxied__()
-beta: resources.Beta = BetaProxy().__as_proxied__()
-files: resources.Files = FilesProxy().__as_proxied__()
-audio: resources.Audio = AudioProxy().__as_proxied__()
-images: resources.Images = ImagesProxy().__as_proxied__()
-models: resources.Models = ModelsProxy().__as_proxied__()
-batches: resources.Batches = BatchesProxy().__as_proxied__()
-uploads: resources.Uploads = UploadsProxy().__as_proxied__()
-responses: resources.Responses = ResponsesProxy().__as_proxied__()
-embeddings: resources.Embeddings = EmbeddingsProxy().__as_proxied__()
-completions: resources.Completions = CompletionsProxy().__as_proxied__()
-moderations: resources.Moderations = ModerationsProxy().__as_proxied__()
-fine_tuning: resources.FineTuning = FineTuningProxy().__as_proxied__()
-vector_stores: resources.VectorStores = VectorStoresProxy().__as_proxied__()
+class ConversationsProxy(LazyProxy["Conversations"]):
+    @override
+    def __load__(self) -> Conversations:
+        return _load_client().conversations
+
+
+chat: Chat = ChatProxy().__as_proxied__()
+beta: Beta = BetaProxy().__as_proxied__()
+files: Files = FilesProxy().__as_proxied__()
+audio: Audio = AudioProxy().__as_proxied__()
+evals: Evals = EvalsProxy().__as_proxied__()
+images: Images = ImagesProxy().__as_proxied__()
+models: Models = ModelsProxy().__as_proxied__()
+videos: Videos = VideosProxy().__as_proxied__()
+batches: Batches = BatchesProxy().__as_proxied__()
+uploads: Uploads = UploadsProxy().__as_proxied__()
+webhooks: Webhooks = WebhooksProxy().__as_proxied__()
+realtime: Realtime = RealtimeProxy().__as_proxied__()
+responses: Responses = ResponsesProxy().__as_proxied__()
+embeddings: Embeddings = EmbeddingsProxy().__as_proxied__()
+containers: Containers = ContainersProxy().__as_proxied__()
+completions: Completions = CompletionsProxy().__as_proxied__()
+moderations: Moderations = ModerationsProxy().__as_proxied__()
+fine_tuning: FineTuning = FineTuningProxy().__as_proxied__()
+vector_stores: VectorStores = VectorStoresProxy().__as_proxied__()
+conversations: Conversations = ConversationsProxy().__as_proxied__()
diff --git a/src/openai/_qs.py b/src/openai/_qs.py
index 274320ca5e..ada6fd3f72 100644
--- a/src/openai/_qs.py
+++ b/src/openai/_qs.py
@@ -4,7 +4,7 @@
 from urllib.parse import parse_qs, urlencode
 from typing_extensions import Literal, get_args
 
-from ._types import NOT_GIVEN, NotGiven, NotGivenOr
+from ._types import NotGiven, not_given
 from ._utils import flatten
 
 _T = TypeVar("_T")
@@ -41,8 +41,8 @@ def stringify(
         self,
         params: Params,
         *,
-        array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN,
-        nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN,
+        array_format: ArrayFormat | NotGiven = not_given,
+        nested_format: NestedFormat | NotGiven = not_given,
     ) -> str:
         return urlencode(
             self.stringify_items(
@@ -56,8 +56,8 @@ def stringify_items(
         self,
         params: Params,
         *,
-        array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN,
-        nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN,
+        array_format: ArrayFormat | NotGiven = not_given,
+        nested_format: NestedFormat | NotGiven = not_given,
     ) -> list[tuple[str, str]]:
         opts = Options(
             qs=self,
@@ -143,8 +143,8 @@ def __init__(
         self,
         qs: Querystring = _qs,
         *,
-        array_format: NotGivenOr[ArrayFormat] = NOT_GIVEN,
-        nested_format: NotGivenOr[NestedFormat] = NOT_GIVEN,
+        array_format: ArrayFormat | NotGiven = not_given,
+        nested_format: NestedFormat | NotGiven = not_given,
     ) -> None:
         self.array_format = qs.array_format if isinstance(array_format, NotGiven) else array_format
         self.nested_format = qs.nested_format if isinstance(nested_format, NotGiven) else nested_format
diff --git a/src/openai/_response.py b/src/openai/_response.py
index 95e94e6537..350da38dd4 100644
--- a/src/openai/_response.py
+++ b/src/openai/_response.py
@@ -237,7 +237,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T:
         # split is required to handle cases where additional information is included
         # in the response, e.g. application/json; charset=utf-8
         content_type, *_ = response.headers.get("content-type", "*").split(";")
-        if content_type != "application/json":
+        if not content_type.endswith("json"):
             if is_basemodel(cast_to):
                 try:
                     data = response.json()
diff --git a/src/openai/_streaming.py b/src/openai/_streaming.py
index 9cb72ffe17..05c284a2be 100644
--- a/src/openai/_streaming.py
+++ b/src/openai/_streaming.py
@@ -59,9 +59,11 @@ def __stream__(self) -> Iterator[_T]:
             if sse.data.startswith("[DONE]"):
                 break
 
-            if sse.event is None or sse.event.startswith("response."):
+            # we have to special case the Assistants `thread.` events since we won't have an "event" key in the data
+            if sse.event and sse.event.startswith("thread."):
                 data = sse.json()
-                if is_mapping(data) and data.get("error"):
+
+                if sse.event == "error" and is_mapping(data) and data.get("error"):
                     message = None
                     error = data.get("error")
                     if is_mapping(error):
@@ -75,12 +77,10 @@ def __stream__(self) -> Iterator[_T]:
                         body=data["error"],
                     )
 
-                yield process_data(data=data, cast_to=cast_to, response=response)
-
+                yield process_data(data={"data": data, "event": sse.event}, cast_to=cast_to, response=response)
             else:
                 data = sse.json()
-
-                if sse.event == "error" and is_mapping(data) and data.get("error"):
+                if is_mapping(data) and data.get("error"):
                     message = None
                     error = data.get("error")
                     if is_mapping(error):
@@ -94,11 +94,10 @@ def __stream__(self) -> Iterator[_T]:
                         body=data["error"],
                     )
 
-                yield process_data(data={"data": data, "event": sse.event}, cast_to=cast_to, response=response)
+                yield process_data(data=data, cast_to=cast_to, response=response)
 
-        # Ensure the entire stream is consumed
-        for _sse in iterator:
-            ...
+        # As we might not fully consume the response stream, we need to close it explicitly
+        response.close()
 
     def __enter__(self) -> Self:
         return self
@@ -161,9 +160,11 @@ async def __stream__(self) -> AsyncIterator[_T]:
             if sse.data.startswith("[DONE]"):
                 break
 
-            if sse.event is None or sse.event.startswith("response."):
+            # we have to special case the Assistants `thread.` events since we won't have an "event" key in the data
+            if sse.event and sse.event.startswith("thread."):
                 data = sse.json()
-                if is_mapping(data) and data.get("error"):
+
+                if sse.event == "error" and is_mapping(data) and data.get("error"):
                     message = None
                     error = data.get("error")
                     if is_mapping(error):
@@ -177,12 +178,10 @@ async def __stream__(self) -> AsyncIterator[_T]:
                         body=data["error"],
                     )
 
-                yield process_data(data=data, cast_to=cast_to, response=response)
-
+                yield process_data(data={"data": data, "event": sse.event}, cast_to=cast_to, response=response)
             else:
                 data = sse.json()
-
-                if sse.event == "error" and is_mapping(data) and data.get("error"):
+                if is_mapping(data) and data.get("error"):
                     message = None
                     error = data.get("error")
                     if is_mapping(error):
@@ -196,11 +195,10 @@ async def __stream__(self) -> AsyncIterator[_T]:
                         body=data["error"],
                     )
 
-                yield process_data(data={"data": data, "event": sse.event}, cast_to=cast_to, response=response)
+                yield process_data(data=data, cast_to=cast_to, response=response)
 
-        # Ensure the entire stream is consumed
-        async for _sse in iterator:
-            ...
+        # As we might not fully consume the response stream, we need to close it explicitly
+        await response.aclose()
 
     async def __aenter__(self) -> Self:
         return self
diff --git a/src/openai/_types.py b/src/openai/_types.py
index a5cf207aa3..2387d7e01c 100644
--- a/src/openai/_types.py
+++ b/src/openai/_types.py
@@ -13,10 +13,21 @@
     Mapping,
     TypeVar,
     Callable,
+    Iterator,
     Optional,
     Sequence,
 )
-from typing_extensions import Set, Literal, Protocol, TypeAlias, TypedDict, override, runtime_checkable
+from typing_extensions import (
+    Set,
+    Literal,
+    Protocol,
+    TypeAlias,
+    TypedDict,
+    SupportsIndex,
+    overload,
+    override,
+    runtime_checkable,
+)
 
 import httpx
 import pydantic
@@ -101,23 +112,27 @@ class RequestOptions(TypedDict, total=False):
     params: Query
     extra_json: AnyMapping
     idempotency_key: str
+    follow_redirects: bool
 
 
 # Sentinel class used until PEP 0661 is accepted
 class NotGiven:
     """
-    A sentinel singleton class used to distinguish omitted keyword arguments
-    from those passed in with the value None (which may have different behavior).
+    For parameters with a meaningful None value, we need to distinguish between
+    the user explicitly passing None, and the user not passing the parameter at
+    all.
+
+    User code shouldn't need to use not_given directly.
 
     For example:
 
     ```py
-    def get(timeout: Union[int, NotGiven, None] = NotGiven()) -> Response: ...
+    def create(timeout: Timeout | None | NotGiven = not_given): ...
 
 
-    get(timeout=1)  # 1s timeout
-    get(timeout=None)  # No timeout
-    get()  # Default timeout behavior, which may not be statically known at the method definition.
+    create(timeout=1)  # 1s timeout
+    create(timeout=None)  # No timeout
+    create()  # Default timeout behavior
     ```
     """
 
@@ -129,13 +144,14 @@ def __repr__(self) -> str:
         return "NOT_GIVEN"
 
 
-NotGivenOr = Union[_T, NotGiven]
+not_given = NotGiven()
+# for backwards compatibility:
 NOT_GIVEN = NotGiven()
 
 
 class Omit:
-    """In certain situations you need to be able to represent a case where a default value has
-    to be explicitly removed and `None` is not an appropriate substitute, for example:
+    """
+    To explicitly omit something from being sent in a request, use `omit`.
 
     ```py
     # as the default `Content-Type` header is `application/json` that will be sent
@@ -145,8 +161,8 @@ class Omit:
     # to look something like: 'multipart/form-data; boundary=0d8382fcf5f8c3be01ca2e11002d2983'
     client.post(..., headers={"Content-Type": "multipart/form-data"})
 
-    # instead you can remove the default `application/json` header by passing Omit
-    client.post(..., headers={"Content-Type": Omit()})
+    # instead you can remove the default `application/json` header by passing omit
+    client.post(..., headers={"Content-Type": omit})
     ```
     """
 
@@ -154,6 +170,11 @@ def __bool__(self) -> Literal[False]:
         return False
 
 
+omit = Omit()
+
+Omittable = Union[_T, Omit]
+
+
 @runtime_checkable
 class ModelBuilderProtocol(Protocol):
     @classmethod
@@ -217,3 +238,27 @@ class _GenericAlias(Protocol):
 
 class HttpxSendArgs(TypedDict, total=False):
     auth: httpx.Auth
+    follow_redirects: bool
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+
+
+if TYPE_CHECKING:
+    # This works because str.__contains__ does not accept object (either in typeshed or at runtime)
+    # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285
+    class SequenceNotStr(Protocol[_T_co]):
+        @overload
+        def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
+        @overload
+        def __getitem__(self, index: slice, /) -> Sequence[_T_co]: ...
+        def __contains__(self, value: object, /) -> bool: ...
+        def __len__(self) -> int: ...
+        def __iter__(self) -> Iterator[_T_co]: ...
+        def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ...
+        def count(self, value: Any, /) -> int: ...
+        def __reversed__(self) -> Iterator[_T_co]: ...
+else:
+    # just point this to a normal `Sequence` at runtime to avoid having to special case
+    # deserializing our custom sequence type
+    SequenceNotStr = Sequence
diff --git a/src/openai/_utils/__init__.py b/src/openai/_utils/__init__.py
index bd01c088dc..963c83b6d4 100644
--- a/src/openai/_utils/__init__.py
+++ b/src/openai/_utils/__init__.py
@@ -11,7 +11,6 @@
     lru_cache as lru_cache,
     is_mapping as is_mapping,
     is_tuple_t as is_tuple_t,
-    parse_date as parse_date,
     is_iterable as is_iterable,
     is_sequence as is_sequence,
     coerce_float as coerce_float,
@@ -24,7 +23,6 @@
     coerce_boolean as coerce_boolean,
     coerce_integer as coerce_integer,
     file_from_path as file_from_path,
-    parse_datetime as parse_datetime,
     is_azure_client as is_azure_client,
     strip_not_given as strip_not_given,
     deepcopy_minimal as deepcopy_minimal,
@@ -35,12 +33,20 @@
     maybe_coerce_integer as maybe_coerce_integer,
     is_async_azure_client as is_async_azure_client,
 )
+from ._compat import (
+    get_args as get_args,
+    is_union as is_union,
+    get_origin as get_origin,
+    is_typeddict as is_typeddict,
+    is_literal_type as is_literal_type,
+)
 from ._typing import (
     is_list_type as is_list_type,
     is_union_type as is_union_type,
     extract_type_arg as extract_type_arg,
     is_iterable_type as is_iterable_type,
     is_required_type as is_required_type,
+    is_sequence_type as is_sequence_type,
     is_annotated_type as is_annotated_type,
     is_type_alias_type as is_type_alias_type,
     strip_annotated_type as strip_annotated_type,
@@ -58,3 +64,4 @@
     function_has_argument as function_has_argument,
     assert_signatures_in_sync as assert_signatures_in_sync,
 )
+from ._datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
diff --git a/src/openai/_utils/_compat.py b/src/openai/_utils/_compat.py
new file mode 100644
index 0000000000..dd703233c5
--- /dev/null
+++ b/src/openai/_utils/_compat.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import sys
+import typing_extensions
+from typing import Any, Type, Union, Literal, Optional
+from datetime import date, datetime
+from typing_extensions import get_args as _get_args, get_origin as _get_origin
+
+from .._types import StrBytesIntFloat
+from ._datetime_parse import parse_date as _parse_date, parse_datetime as _parse_datetime
+
+_LITERAL_TYPES = {Literal, typing_extensions.Literal}
+
+
+def get_args(tp: type[Any]) -> tuple[Any, ...]:
+    return _get_args(tp)
+
+
+def get_origin(tp: type[Any]) -> type[Any] | None:
+    return _get_origin(tp)
+
+
+def is_union(tp: Optional[Type[Any]]) -> bool:
+    if sys.version_info < (3, 10):
+        return tp is Union  # type: ignore[comparison-overlap]
+    else:
+        import types
+
+        return tp is Union or tp is types.UnionType
+
+
+def is_typeddict(tp: Type[Any]) -> bool:
+    return typing_extensions.is_typeddict(tp)
+
+
+def is_literal_type(tp: Type[Any]) -> bool:
+    return get_origin(tp) in _LITERAL_TYPES
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    return _parse_date(value)
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    return _parse_datetime(value)
diff --git a/src/openai/_utils/_datetime_parse.py b/src/openai/_utils/_datetime_parse.py
new file mode 100644
index 0000000000..7cb9d9e668
--- /dev/null
+++ b/src/openai/_utils/_datetime_parse.py
@@ -0,0 +1,136 @@
+"""
+This file contains code from https://github.com/pydantic/pydantic/blob/main/pydantic/v1/datetime_parse.py
+without the Pydantic v1 specific errors.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, Union, Optional
+from datetime import date, datetime, timezone, timedelta
+
+from .._types import StrBytesIntFloat
+
+date_expr = r"(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})"
+time_expr = (
+    r"(?P<hour>\d{1,2}):(?P<minute>\d{1,2})"
+    r"(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?"
+    r"(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$"
+)
+
+date_re = re.compile(f"{date_expr}$")
+datetime_re = re.compile(f"{date_expr}[T ]{time_expr}")
+
+
+EPOCH = datetime(1970, 1, 1)
+# if greater than this, the number is in ms, if less than or equal it's in seconds
+# (in seconds this is 11th October 2603, in ms it's 20th August 1970)
+MS_WATERSHED = int(2e10)
+# slightly more than datetime.max in ns - (datetime.max - EPOCH).total_seconds() * 1e9
+MAX_NUMBER = int(3e20)
+
+
+def _get_numeric(value: StrBytesIntFloat, native_expected_type: str) -> Union[None, int, float]:
+    if isinstance(value, (int, float)):
+        return value
+    try:
+        return float(value)
+    except ValueError:
+        return None
+    except TypeError:
+        raise TypeError(f"invalid type; expected {native_expected_type}, string, bytes, int or float") from None
+
+
+def _from_unix_seconds(seconds: Union[int, float]) -> datetime:
+    if seconds > MAX_NUMBER:
+        return datetime.max
+    elif seconds < -MAX_NUMBER:
+        return datetime.min
+
+    while abs(seconds) > MS_WATERSHED:
+        seconds /= 1000
+    dt = EPOCH + timedelta(seconds=seconds)
+    return dt.replace(tzinfo=timezone.utc)
+
+
+def _parse_timezone(value: Optional[str]) -> Union[None, int, timezone]:
+    if value == "Z":
+        return timezone.utc
+    elif value is not None:
+        offset_mins = int(value[-2:]) if len(value) > 3 else 0
+        offset = 60 * int(value[1:3]) + offset_mins
+        if value[0] == "-":
+            offset = -offset
+        return timezone(timedelta(minutes=offset))
+    else:
+        return None
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    """
+    Parse a datetime/int/float/string and return a datetime.datetime.
+
+    This function supports time zone offsets. When the input contains one,
+    the output uses a timezone with a fixed offset from UTC.
+
+    Raise ValueError if the input is well formatted but not a valid datetime.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, datetime):
+        return value
+
+    number = _get_numeric(value, "datetime")
+    if number is not None:
+        return _from_unix_seconds(number)
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+
+    match = datetime_re.match(value)
+    if match is None:
+        raise ValueError("invalid datetime format")
+
+    kw = match.groupdict()
+    if kw["microsecond"]:
+        kw["microsecond"] = kw["microsecond"].ljust(6, "0")
+
+    tzinfo = _parse_timezone(kw.pop("tzinfo"))
+    kw_: Dict[str, Union[None, int, timezone]] = {k: int(v) for k, v in kw.items() if v is not None}
+    kw_["tzinfo"] = tzinfo
+
+    return datetime(**kw_)  # type: ignore
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    """
+    Parse a date/int/float/string and return a datetime.date.
+
+    Raise ValueError if the input is well formatted but not a valid date.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, date):
+        if isinstance(value, datetime):
+            return value.date()
+        else:
+            return value
+
+    number = _get_numeric(value, "date")
+    if number is not None:
+        return _from_unix_seconds(number).date()
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+    match = date_re.match(value)
+    if match is None:
+        raise ValueError("invalid date format")
+
+    kw = {k: int(v) for k, v in match.groupdict().items()}
+
+    try:
+        return date(**kw)
+    except ValueError:
+        raise ValueError("invalid date format") from None
diff --git a/src/openai/_utils/_proxy.py b/src/openai/_utils/_proxy.py
index ffd883e9dd..0f239a33c6 100644
--- a/src/openai/_utils/_proxy.py
+++ b/src/openai/_utils/_proxy.py
@@ -46,7 +46,10 @@ def __dir__(self) -> Iterable[str]:
     @property  # type: ignore
     @override
     def __class__(self) -> type:  # pyright: ignore
-        proxied = self.__get_proxied__()
+        try:
+            proxied = self.__get_proxied__()
+        except Exception:
+            return type(self)
         if issubclass(type(proxied), LazyProxy):
             return type(proxied)
         return proxied.__class__
diff --git a/src/openai/_utils/_resources_proxy.py b/src/openai/_utils/_resources_proxy.py
new file mode 100644
index 0000000000..e5b9ec7a37
--- /dev/null
+++ b/src/openai/_utils/_resources_proxy.py
@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+from typing_extensions import override
+
+from ._proxy import LazyProxy
+
+
+class ResourcesProxy(LazyProxy[Any]):
+    """A proxy for the `openai.resources` module.
+
+    This is used so that we can lazily import `openai.resources` only when
+    needed *and* so that users can just import `openai` and reference `openai.resources`
+    """
+
+    @override
+    def __load__(self) -> Any:
+        import importlib
+
+        mod = importlib.import_module("openai.resources")
+        return mod
+
+
+resources = ResourcesProxy().__as_proxied__()
diff --git a/src/openai/_utils/_sync.py b/src/openai/_utils/_sync.py
index ad7ec71b76..f6027c183d 100644
--- a/src/openai/_utils/_sync.py
+++ b/src/openai/_utils/_sync.py
@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-import sys
 import asyncio
 import functools
-import contextvars
-from typing import Any, TypeVar, Callable, Awaitable
+from typing import TypeVar, Callable, Awaitable
 from typing_extensions import ParamSpec
 
 import anyio
@@ -15,34 +13,11 @@
 T_ParamSpec = ParamSpec("T_ParamSpec")
 
 
-if sys.version_info >= (3, 9):
-    _asyncio_to_thread = asyncio.to_thread
-else:
-    # backport of https://docs.python.org/3/library/asyncio-task.html#asyncio.to_thread
-    # for Python 3.8 support
-    async def _asyncio_to_thread(
-        func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs
-    ) -> Any:
-        """Asynchronously run function *func* in a separate thread.
-
-        Any *args and **kwargs supplied for this function are directly passed
-        to *func*. Also, the current :class:`contextvars.Context` is propagated,
-        allowing context variables from the main thread to be accessed in the
-        separate thread.
-
-        Returns a coroutine that can be awaited to get the eventual result of *func*.
-        """
-        loop = asyncio.events.get_running_loop()
-        ctx = contextvars.copy_context()
-        func_call = functools.partial(ctx.run, func, *args, **kwargs)
-        return await loop.run_in_executor(None, func_call)
-
-
 async def to_thread(
     func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs
 ) -> T_Retval:
     if sniffio.current_async_library() == "asyncio":
-        return await _asyncio_to_thread(func, *args, **kwargs)
+        return await asyncio.to_thread(func, *args, **kwargs)
 
     return await anyio.to_thread.run_sync(
         functools.partial(func, *args, **kwargs),
@@ -53,10 +28,7 @@ async def to_thread(
 def asyncify(function: Callable[T_ParamSpec, T_Retval]) -> Callable[T_ParamSpec, Awaitable[T_Retval]]:
     """
     Take a blocking function and create an async one that receives the same
-    positional and keyword arguments. For python version 3.9 and above, it uses
-    asyncio.to_thread to run the function in a separate thread. For python version
-    3.8, it uses locally defined copy of the asyncio.to_thread function which was
-    introduced in python 3.9.
+    positional and keyword arguments.
 
     Usage:
 
diff --git a/src/openai/_utils/_transform.py b/src/openai/_utils/_transform.py
index 18afd9d8bd..414f38c340 100644
--- a/src/openai/_utils/_transform.py
+++ b/src/openai/_utils/_transform.py
@@ -5,27 +5,31 @@
 import pathlib
 from typing import Any, Mapping, TypeVar, cast
 from datetime import date, datetime
-from typing_extensions import Literal, get_args, override, get_type_hints
+from typing_extensions import Literal, get_args, override, get_type_hints as _get_type_hints
 
 import anyio
 import pydantic
 
 from ._utils import (
     is_list,
+    is_given,
+    lru_cache,
     is_mapping,
     is_iterable,
+    is_sequence,
 )
 from .._files import is_base64_file_input
+from ._compat import get_origin, is_typeddict
 from ._typing import (
     is_list_type,
     is_union_type,
     extract_type_arg,
     is_iterable_type,
     is_required_type,
+    is_sequence_type,
     is_annotated_type,
     strip_annotated_type,
 )
-from .._compat import get_origin, model_dump, is_typeddict
 
 _T = TypeVar("_T")
 
@@ -108,6 +112,7 @@ class Params(TypedDict, total=False):
     return cast(_T, transformed)
 
 
+@lru_cache(maxsize=8096)
 def _get_annotated_type(type_: type) -> type | None:
     """If the given type is an `Annotated` type then it is returned, if not `None` is returned.
 
@@ -126,7 +131,7 @@ def _get_annotated_type(type_: type) -> type | None:
 def _maybe_transform_key(key: str, type_: type) -> str:
     """Transform the given `data` based on the annotations provided in `type_`.
 
-    Note: this function only looks at `Annotated` types that contain `PropertInfo` metadata.
+    Note: this function only looks at `Annotated` types that contain `PropertyInfo` metadata.
     """
     annotated_type = _get_annotated_type(type_)
     if annotated_type is None:
@@ -142,6 +147,10 @@ def _maybe_transform_key(key: str, type_: type) -> str:
     return key
 
 
+def _no_transform_needed(annotation: type) -> bool:
+    return annotation == float or annotation == int
+
+
 def _transform_recursive(
     data: object,
     *,
@@ -160,6 +169,8 @@ def _transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -177,6 +188,8 @@ def _transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.
@@ -184,6 +197,15 @@ def _transform_recursive(
             return cast(object, data)
 
         inner_type = extract_type_arg(stripped_type, 0)
+        if _no_transform_needed(inner_type):
+            # for some types there is no need to transform anything, so we can get a small
+            # perf boost from skipping that work.
+            #
+            # but we still need to convert to a list to ensure the data is json-serializable
+            if is_list(data):
+                return data
+            return list(data)
+
         return [_transform_recursive(d, annotation=annotation, inner_type=inner_type) for d in data]
 
     if is_union_type(stripped_type):
@@ -196,7 +218,7 @@ def _transform_recursive(
         return data
 
     if isinstance(data, pydantic.BaseModel):
-        return model_dump(data, exclude_unset=True, mode="json")
+        return model_dump(data, exclude_unset=True, mode="json", exclude=getattr(data, "__api_exclude__", None))
 
     annotated_type = _get_annotated_type(annotation)
     if annotated_type is None:
@@ -245,6 +267,11 @@ def _transform_typeddict(
     result: dict[str, object] = {}
     annotations = get_type_hints(expected_type, include_extras=True)
     for key, value in data.items():
+        if not is_given(value):
+            # we don't need to include omitted values here as they'll
+            # be stripped out before the request is sent anyway
+            continue
+
         type_ = annotations.get(key)
         if type_ is None:
             # we do not have a type annotation for this field, leave it as is
@@ -308,6 +335,8 @@ async def _async_transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -325,6 +354,8 @@ async def _async_transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.
@@ -332,6 +363,15 @@ async def _async_transform_recursive(
             return cast(object, data)
 
         inner_type = extract_type_arg(stripped_type, 0)
+        if _no_transform_needed(inner_type):
+            # for some types there is no need to transform anything, so we can get a small
+            # perf boost from skipping that work.
+            #
+            # but we still need to convert to a list to ensure the data is json-serializable
+            if is_list(data):
+                return data
+            return list(data)
+
         return [await _async_transform_recursive(d, annotation=annotation, inner_type=inner_type) for d in data]
 
     if is_union_type(stripped_type):
@@ -393,6 +433,11 @@ async def _async_transform_typeddict(
     result: dict[str, object] = {}
     annotations = get_type_hints(expected_type, include_extras=True)
     for key, value in data.items():
+        if not is_given(value):
+            # we don't need to include omitted values here as they'll
+            # be stripped out before the request is sent anyway
+            continue
+
         type_ = annotations.get(key)
         if type_ is None:
             # we do not have a type annotation for this field, leave it as is
@@ -400,3 +445,13 @@ async def _async_transform_typeddict(
         else:
             result[_maybe_transform_key(key, type_)] = await _async_transform_recursive(value, annotation=type_)
     return result
+
+
+@lru_cache(maxsize=8096)
+def get_type_hints(
+    obj: Any,
+    globalns: dict[str, Any] | None = None,
+    localns: Mapping[str, Any] | None = None,
+    include_extras: bool = False,
+) -> dict[str, Any]:
+    return _get_type_hints(obj, globalns=globalns, localns=localns, include_extras=include_extras)
diff --git a/src/openai/_utils/_typing.py b/src/openai/_utils/_typing.py
index 278749b147..193109f3ad 100644
--- a/src/openai/_utils/_typing.py
+++ b/src/openai/_utils/_typing.py
@@ -13,8 +13,9 @@
     get_origin,
 )
 
+from ._utils import lru_cache
 from .._types import InheritsGeneric
-from .._compat import is_union as _is_union
+from ._compat import is_union as _is_union
 
 
 def is_annotated_type(typ: type) -> bool:
@@ -25,6 +26,11 @@ def is_list_type(typ: type) -> bool:
     return (get_origin(typ) or typ) == list
 
 
+def is_sequence_type(typ: type) -> bool:
+    origin = get_origin(typ) or typ
+    return origin == typing_extensions.Sequence or origin == typing.Sequence or origin == _c_abc.Sequence
+
+
 def is_iterable_type(typ: type) -> bool:
     """If the given type is `typing.Iterable[T]`"""
     origin = get_origin(typ) or typ
@@ -66,6 +72,7 @@ def is_type_alias_type(tp: Any, /) -> TypeIs[typing_extensions.TypeAliasType]:
 
 
 # Extracts T from Annotated[T, ...] or from Required[Annotated[T, ...]]
+@lru_cache(maxsize=8096)
 def strip_annotated_type(typ: type) -> type:
     if is_required_type(typ) or is_annotated_type(typ):
         return strip_annotated_type(cast(type, get_args(typ)[0]))
@@ -108,7 +115,7 @@ class MyResponse(Foo[_T]):
     ```
     """
     cls = cast(object, get_origin(typ) or typ)
-    if cls in generic_bases:
+    if cls in generic_bases:  # pyright: ignore[reportUnnecessaryContains]
         # we're given the class directly
         return extract_type_arg(typ, index)
 
diff --git a/src/openai/_utils/_utils.py b/src/openai/_utils/_utils.py
index d6734e6b8f..90494748cc 100644
--- a/src/openai/_utils/_utils.py
+++ b/src/openai/_utils/_utils.py
@@ -22,8 +22,7 @@
 
 import sniffio
 
-from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike
-from .._compat import parse_date as parse_date, parse_datetime as parse_datetime
+from .._types import Omit, NotGiven, FileTypes, HeadersLike
 
 _T = TypeVar("_T")
 _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...])
@@ -68,7 +67,7 @@ def _extract_items(
     try:
         key = path[index]
     except IndexError:
-        if isinstance(obj, NotGiven):
+        if not is_given(obj):
             # no value was provided - we can safely ignore
             return []
 
@@ -76,8 +75,16 @@ def _extract_items(
         from .._files import assert_is_file_content
 
         # We have exhausted the path, return the entry we found.
-        assert_is_file_content(obj, key=flattened_key)
         assert flattened_key is not None
+
+        if is_list(obj):
+            files: list[tuple[str, FileTypes]] = []
+            for entry in obj:
+                assert_is_file_content(entry, key=flattened_key + "[]" if flattened_key else "")
+                files.append((flattened_key + "[]", cast(FileTypes, entry)))
+            return files
+
+        assert_is_file_content(obj, key=flattened_key)
         return [(flattened_key, cast(FileTypes, obj))]
 
     index += 1
@@ -123,14 +130,14 @@ def _extract_items(
     return []
 
 
-def is_given(obj: NotGivenOr[_T]) -> TypeGuard[_T]:
-    return not isinstance(obj, NotGiven)
+def is_given(obj: _T | NotGiven | Omit) -> TypeGuard[_T]:
+    return not isinstance(obj, NotGiven) and not isinstance(obj, Omit)
 
 
 # Type safe methods for narrowing types with TypeVars.
 # The default narrowing for isinstance(obj, dict) is dict[unknown, unknown],
 # however this cause Pyright to rightfully report errors. As we know we don't
-# care about the contained types we can safely use `object` in it's place.
+# care about the contained types we can safely use `object` in its place.
 #
 # There are two separate functions defined, `is_*` and `is_*_t` for different use cases.
 # `is_*` is for when you're dealing with an unknown input
diff --git a/src/openai/_version.py b/src/openai/_version.py
index 6c4a192efc..6109cebf91 100644
--- a/src/openai/_version.py
+++ b/src/openai/_version.py
@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "openai"
-__version__ = "1.66.3"  # x-release-please-version
+__version__ = "2.8.1"  # x-release-please-version
diff --git a/src/openai/cli/_api/_main.py b/src/openai/cli/_api/_main.py
index fe5a5e6fc0..b04a3e52a4 100644
--- a/src/openai/cli/_api/_main.py
+++ b/src/openai/cli/_api/_main.py
@@ -2,7 +2,7 @@
 
 from argparse import ArgumentParser
 
-from . import chat, audio, files, image, models, completions
+from . import chat, audio, files, image, models, completions, fine_tuning
 
 
 def register_commands(parser: ArgumentParser) -> None:
@@ -14,3 +14,4 @@ def register_commands(parser: ArgumentParser) -> None:
     files.register(subparsers)
     models.register(subparsers)
     completions.register(subparsers)
+    fine_tuning.register(subparsers)
diff --git a/src/openai/cli/_api/audio.py b/src/openai/cli/_api/audio.py
index 269c67df28..e7c3734e75 100644
--- a/src/openai/cli/_api/audio.py
+++ b/src/openai/cli/_api/audio.py
@@ -5,7 +5,7 @@
 from argparse import ArgumentParser
 
 from .._utils import get_client, print_model
-from ..._types import NOT_GIVEN
+from ..._types import omit
 from .._models import BaseModel
 from .._progress import BufferReader
 from ...types.audio import Transcription
@@ -72,9 +72,9 @@ def transcribe(args: CLITranscribeArgs) -> None:
             get_client().audio.transcriptions.create(
                 file=(args.file, buffer_reader),
                 model=args.model,
-                language=args.language or NOT_GIVEN,
-                temperature=args.temperature or NOT_GIVEN,
-                prompt=args.prompt or NOT_GIVEN,
+                language=args.language or omit,
+                temperature=args.temperature or omit,
+                prompt=args.prompt or omit,
                 # casts required because the API is typed for enums
                 # but we don't want to validate that here for forwards-compat
                 response_format=cast(Any, args.response_format),
@@ -95,8 +95,8 @@ def translate(args: CLITranslationArgs) -> None:
             get_client().audio.translations.create(
                 file=(args.file, buffer_reader),
                 model=args.model,
-                temperature=args.temperature or NOT_GIVEN,
-                prompt=args.prompt or NOT_GIVEN,
+                temperature=args.temperature or omit,
+                prompt=args.prompt or omit,
                 # casts required because the API is typed for enums
                 # but we don't want to validate that here for forwards-compat
                 response_format=cast(Any, args.response_format),
diff --git a/src/openai/cli/_api/completions.py b/src/openai/cli/_api/completions.py
index cbdb35bf3a..b22ecde9ef 100644
--- a/src/openai/cli/_api/completions.py
+++ b/src/openai/cli/_api/completions.py
@@ -8,7 +8,7 @@
 from openai.types.completion import Completion
 
 from .._utils import get_client
-from ..._types import NOT_GIVEN, NotGivenOr
+from ..._types import Omittable, omit
 from ..._utils import is_given
 from .._errors import CLIError
 from .._models import BaseModel
@@ -95,18 +95,18 @@ class CLICompletionCreateArgs(BaseModel):
     stream: bool = False
 
     prompt: Optional[str] = None
-    n: NotGivenOr[int] = NOT_GIVEN
-    stop: NotGivenOr[str] = NOT_GIVEN
-    user: NotGivenOr[str] = NOT_GIVEN
-    echo: NotGivenOr[bool] = NOT_GIVEN
-    suffix: NotGivenOr[str] = NOT_GIVEN
-    best_of: NotGivenOr[int] = NOT_GIVEN
-    top_p: NotGivenOr[float] = NOT_GIVEN
-    logprobs: NotGivenOr[int] = NOT_GIVEN
-    max_tokens: NotGivenOr[int] = NOT_GIVEN
-    temperature: NotGivenOr[float] = NOT_GIVEN
-    presence_penalty: NotGivenOr[float] = NOT_GIVEN
-    frequency_penalty: NotGivenOr[float] = NOT_GIVEN
+    n: Omittable[int] = omit
+    stop: Omittable[str] = omit
+    user: Omittable[str] = omit
+    echo: Omittable[bool] = omit
+    suffix: Omittable[str] = omit
+    best_of: Omittable[int] = omit
+    top_p: Omittable[float] = omit
+    logprobs: Omittable[int] = omit
+    max_tokens: Omittable[int] = omit
+    temperature: Omittable[float] = omit
+    presence_penalty: Omittable[float] = omit
+    frequency_penalty: Omittable[float] = omit
 
 
 class CLICompletions:
diff --git a/src/openai/cli/_api/fine_tuning/__init__.py b/src/openai/cli/_api/fine_tuning/__init__.py
new file mode 100644
index 0000000000..11a2dfccbd
--- /dev/null
+++ b/src/openai/cli/_api/fine_tuning/__init__.py
@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from argparse import ArgumentParser
+
+from . import jobs
+
+if TYPE_CHECKING:
+    from argparse import _SubParsersAction
+
+
+def register(subparser: _SubParsersAction[ArgumentParser]) -> None:
+    jobs.register(subparser)
diff --git a/src/openai/cli/_api/fine_tuning/jobs.py b/src/openai/cli/_api/fine_tuning/jobs.py
new file mode 100644
index 0000000000..a4e429108a
--- /dev/null
+++ b/src/openai/cli/_api/fine_tuning/jobs.py
@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+from argparse import ArgumentParser
+
+from ..._utils import get_client, print_model
+from ...._types import Omittable, omit
+from ...._utils import is_given
+from ..._models import BaseModel
+from ....pagination import SyncCursorPage
+from ....types.fine_tuning import (
+    FineTuningJob,
+    FineTuningJobEvent,
+)
+
+if TYPE_CHECKING:
+    from argparse import _SubParsersAction
+
+
+def register(subparser: _SubParsersAction[ArgumentParser]) -> None:
+    sub = subparser.add_parser("fine_tuning.jobs.create")
+    sub.add_argument(
+        "-m",
+        "--model",
+        help="The model to fine-tune.",
+        required=True,
+    )
+    sub.add_argument(
+        "-F",
+        "--training-file",
+        help="The training file to fine-tune the model on.",
+        required=True,
+    )
+    sub.add_argument(
+        "-H",
+        "--hyperparameters",
+        help="JSON string of hyperparameters to use for fine-tuning.",
+        type=str,
+    )
+    sub.add_argument(
+        "-s",
+        "--suffix",
+        help="A suffix to add to the fine-tuned model name.",
+    )
+    sub.add_argument(
+        "-V",
+        "--validation-file",
+        help="The validation file to use for fine-tuning.",
+    )
+    sub.set_defaults(func=CLIFineTuningJobs.create, args_model=CLIFineTuningJobsCreateArgs)
+
+    sub = subparser.add_parser("fine_tuning.jobs.retrieve")
+    sub.add_argument(
+        "-i",
+        "--id",
+        help="The ID of the fine-tuning job to retrieve.",
+        required=True,
+    )
+    sub.set_defaults(func=CLIFineTuningJobs.retrieve, args_model=CLIFineTuningJobsRetrieveArgs)
+
+    sub = subparser.add_parser("fine_tuning.jobs.list")
+    sub.add_argument(
+        "-a",
+        "--after",
+        help="Identifier for the last job from the previous pagination request. If provided, only jobs created after this job will be returned.",
+    )
+    sub.add_argument(
+        "-l",
+        "--limit",
+        help="Number of fine-tuning jobs to retrieve.",
+        type=int,
+    )
+    sub.set_defaults(func=CLIFineTuningJobs.list, args_model=CLIFineTuningJobsListArgs)
+
+    sub = subparser.add_parser("fine_tuning.jobs.cancel")
+    sub.add_argument(
+        "-i",
+        "--id",
+        help="The ID of the fine-tuning job to cancel.",
+        required=True,
+    )
+    sub.set_defaults(func=CLIFineTuningJobs.cancel, args_model=CLIFineTuningJobsCancelArgs)
+
+    sub = subparser.add_parser("fine_tuning.jobs.list_events")
+    sub.add_argument(
+        "-i",
+        "--id",
+        help="The ID of the fine-tuning job to list events for.",
+        required=True,
+    )
+    sub.add_argument(
+        "-a",
+        "--after",
+        help="Identifier for the last event from the previous pagination request. If provided, only events created after this event will be returned.",
+    )
+    sub.add_argument(
+        "-l",
+        "--limit",
+        help="Number of fine-tuning job events to retrieve.",
+        type=int,
+    )
+    sub.set_defaults(func=CLIFineTuningJobs.list_events, args_model=CLIFineTuningJobsListEventsArgs)
+
+
+class CLIFineTuningJobsCreateArgs(BaseModel):
+    model: str
+    training_file: str
+    hyperparameters: Omittable[str] = omit
+    suffix: Omittable[str] = omit
+    validation_file: Omittable[str] = omit
+
+
+class CLIFineTuningJobsRetrieveArgs(BaseModel):
+    id: str
+
+
+class CLIFineTuningJobsListArgs(BaseModel):
+    after: Omittable[str] = omit
+    limit: Omittable[int] = omit
+
+
+class CLIFineTuningJobsCancelArgs(BaseModel):
+    id: str
+
+
+class CLIFineTuningJobsListEventsArgs(BaseModel):
+    id: str
+    after: Omittable[str] = omit
+    limit: Omittable[int] = omit
+
+
+class CLIFineTuningJobs:
+    @staticmethod
+    def create(args: CLIFineTuningJobsCreateArgs) -> None:
+        hyperparameters = json.loads(str(args.hyperparameters)) if is_given(args.hyperparameters) else omit
+        fine_tuning_job: FineTuningJob = get_client().fine_tuning.jobs.create(
+            model=args.model,
+            training_file=args.training_file,
+            hyperparameters=hyperparameters,
+            suffix=args.suffix,
+            validation_file=args.validation_file,
+        )
+        print_model(fine_tuning_job)
+
+    @staticmethod
+    def retrieve(args: CLIFineTuningJobsRetrieveArgs) -> None:
+        fine_tuning_job: FineTuningJob = get_client().fine_tuning.jobs.retrieve(fine_tuning_job_id=args.id)
+        print_model(fine_tuning_job)
+
+    @staticmethod
+    def list(args: CLIFineTuningJobsListArgs) -> None:
+        fine_tuning_jobs: SyncCursorPage[FineTuningJob] = get_client().fine_tuning.jobs.list(
+            after=args.after or omit, limit=args.limit or omit
+        )
+        print_model(fine_tuning_jobs)
+
+    @staticmethod
+    def cancel(args: CLIFineTuningJobsCancelArgs) -> None:
+        fine_tuning_job: FineTuningJob = get_client().fine_tuning.jobs.cancel(fine_tuning_job_id=args.id)
+        print_model(fine_tuning_job)
+
+    @staticmethod
+    def list_events(args: CLIFineTuningJobsListEventsArgs) -> None:
+        fine_tuning_job_events: SyncCursorPage[FineTuningJobEvent] = get_client().fine_tuning.jobs.list_events(
+            fine_tuning_job_id=args.id,
+            after=args.after or omit,
+            limit=args.limit or omit,
+        )
+        print_model(fine_tuning_job_events)
diff --git a/src/openai/cli/_api/image.py b/src/openai/cli/_api/image.py
index 3e2a0a90f1..1d0cf810c1 100644
--- a/src/openai/cli/_api/image.py
+++ b/src/openai/cli/_api/image.py
@@ -4,7 +4,7 @@
 from argparse import ArgumentParser
 
 from .._utils import get_client, print_model
-from ..._types import NOT_GIVEN, NotGiven, NotGivenOr
+from ..._types import Omit, Omittable, omit
 from .._models import BaseModel
 from .._progress import BufferReader
 
@@ -63,7 +63,7 @@ class CLIImageCreateArgs(BaseModel):
     num_images: int
     size: str
     response_format: str
-    model: NotGivenOr[str] = NOT_GIVEN
+    model: Omittable[str] = omit
 
 
 class CLIImageCreateVariationArgs(BaseModel):
@@ -71,7 +71,7 @@ class CLIImageCreateVariationArgs(BaseModel):
     num_images: int
     size: str
     response_format: str
-    model: NotGivenOr[str] = NOT_GIVEN
+    model: Omittable[str] = omit
 
 
 class CLIImageEditArgs(BaseModel):
@@ -80,8 +80,8 @@ class CLIImageEditArgs(BaseModel):
     size: str
     response_format: str
     prompt: str
-    mask: NotGivenOr[str] = NOT_GIVEN
-    model: NotGivenOr[str] = NOT_GIVEN
+    mask: Omittable[str] = omit
+    model: Omittable[str] = omit
 
 
 class CLIImage:
@@ -119,8 +119,8 @@ def edit(args: CLIImageEditArgs) -> None:
         with open(args.image, "rb") as file_reader:
             buffer_reader = BufferReader(file_reader.read(), desc="Image upload progress")
 
-        if isinstance(args.mask, NotGiven):
-            mask: NotGivenOr[BufferReader] = NOT_GIVEN
+        if isinstance(args.mask, Omit):
+            mask: Omittable[BufferReader] = omit
         else:
             with open(args.mask, "rb") as file_reader:
                 mask = BufferReader(file_reader.read(), desc="Mask progress")
@@ -130,7 +130,7 @@ def edit(args: CLIImageEditArgs) -> None:
             prompt=args.prompt,
             image=("image", buffer_reader),
             n=args.num_images,
-            mask=("mask", mask) if not isinstance(mask, NotGiven) else mask,
+            mask=("mask", mask) if not isinstance(mask, Omit) else mask,
             # casts required because the API is typed for enums
             # but we don't want to validate that here for forwards-compat
             size=cast(Any, args.size),
diff --git a/src/openai/cli/_cli.py b/src/openai/cli/_cli.py
index fd165f48ab..d31196da50 100644
--- a/src/openai/cli/_cli.py
+++ b/src/openai/cli/_cli.py
@@ -16,7 +16,7 @@
 from ._api import register_commands
 from ._utils import can_use_http2
 from ._errors import CLIError, display_error
-from .._compat import PYDANTIC_V2, ConfigDict, model_parse
+from .._compat import PYDANTIC_V1, ConfigDict, model_parse
 from .._models import BaseModel
 from .._exceptions import APIError
 
@@ -28,14 +28,14 @@
 
 
 class Arguments(BaseModel):
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(
-            extra="ignore",
-        )
-    else:
+    if PYDANTIC_V1:
 
         class Config(pydantic.BaseConfig):  # type: ignore
             extra: Any = pydantic.Extra.ignore  # type: ignore
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(
+            extra="ignore",
+        )
 
     verbosity: int
     version: Optional[str] = None
diff --git a/src/openai/cli/_models.py b/src/openai/cli/_models.py
index 5583db2609..a88608961b 100644
--- a/src/openai/cli/_models.py
+++ b/src/openai/cli/_models.py
@@ -4,14 +4,14 @@
 import pydantic
 
 from .. import _models
-from .._compat import PYDANTIC_V2, ConfigDict
+from .._compat import PYDANTIC_V1, ConfigDict
 
 
 class BaseModel(_models.BaseModel):
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore", arbitrary_types_allowed=True)
-    else:
+    if PYDANTIC_V1:
 
         class Config(pydantic.BaseConfig):  # type: ignore
             extra: Any = pydantic.Extra.ignore  # type: ignore
             arbitrary_types_allowed: bool = True
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore", arbitrary_types_allowed=True)
diff --git a/src/openai/helpers/__init__.py b/src/openai/helpers/__init__.py
new file mode 100644
index 0000000000..ab3044da59
--- /dev/null
+++ b/src/openai/helpers/__init__.py
@@ -0,0 +1,4 @@
+from .microphone import Microphone
+from .local_audio_player import LocalAudioPlayer
+
+__all__ = ["Microphone", "LocalAudioPlayer"]
diff --git a/src/openai/helpers/local_audio_player.py b/src/openai/helpers/local_audio_player.py
new file mode 100644
index 0000000000..8f12c27a56
--- /dev/null
+++ b/src/openai/helpers/local_audio_player.py
@@ -0,0 +1,165 @@
+# mypy: ignore-errors
+from __future__ import annotations
+
+import queue
+import asyncio
+from typing import Any, Union, Callable, AsyncGenerator, cast
+from typing_extensions import TYPE_CHECKING
+
+from .. import _legacy_response
+from .._extras import numpy as np, sounddevice as sd
+from .._response import StreamedBinaryAPIResponse, AsyncStreamedBinaryAPIResponse
+
+if TYPE_CHECKING:
+    import numpy.typing as npt
+
+SAMPLE_RATE = 24000
+
+
+class LocalAudioPlayer:
+    def __init__(
+        self,
+        should_stop: Union[Callable[[], bool], None] = None,
+    ):
+        self.channels = 1
+        self.dtype = np.float32
+        self.should_stop = should_stop
+
+    async def _tts_response_to_buffer(
+        self,
+        response: Union[
+            _legacy_response.HttpxBinaryResponseContent,
+            AsyncStreamedBinaryAPIResponse,
+            StreamedBinaryAPIResponse,
+        ],
+    ) -> npt.NDArray[np.float32]:
+        chunks: list[bytes] = []
+        if isinstance(response, _legacy_response.HttpxBinaryResponseContent) or isinstance(
+            response, StreamedBinaryAPIResponse
+        ):
+            for chunk in response.iter_bytes(chunk_size=1024):
+                if chunk:
+                    chunks.append(chunk)
+        else:
+            async for chunk in response.iter_bytes(chunk_size=1024):
+                if chunk:
+                    chunks.append(chunk)
+
+        audio_bytes = b"".join(chunks)
+        audio_np = np.frombuffer(audio_bytes, dtype=np.int16).astype(np.float32) / 32767.0
+        audio_np = audio_np.reshape(-1, 1)
+        return audio_np
+
+    async def play(
+        self,
+        input: Union[
+            npt.NDArray[np.int16],
+            npt.NDArray[np.float32],
+            _legacy_response.HttpxBinaryResponseContent,
+            AsyncStreamedBinaryAPIResponse,
+            StreamedBinaryAPIResponse,
+        ],
+    ) -> None:
+        audio_content: npt.NDArray[np.float32]
+        if isinstance(input, np.ndarray):
+            if input.dtype == np.int16 and self.dtype == np.float32:
+                audio_content = (input.astype(np.float32) / 32767.0).reshape(-1, self.channels)
+            elif input.dtype == np.float32:
+                audio_content = cast("npt.NDArray[np.float32]", input)
+            else:
+                raise ValueError(f"Unsupported dtype: {input.dtype}")
+        else:
+            audio_content = await self._tts_response_to_buffer(input)
+
+        loop = asyncio.get_event_loop()
+        event = asyncio.Event()
+        idx = 0
+
+        def callback(
+            outdata: npt.NDArray[np.float32],
+            frame_count: int,
+            _time_info: Any,
+            _status: Any,
+        ):
+            nonlocal idx
+
+            remainder = len(audio_content) - idx
+            if remainder == 0 or (callable(self.should_stop) and self.should_stop()):
+                loop.call_soon_threadsafe(event.set)
+                raise sd.CallbackStop
+            valid_frames = frame_count if remainder >= frame_count else remainder
+            outdata[:valid_frames] = audio_content[idx : idx + valid_frames]
+            outdata[valid_frames:] = 0
+            idx += valid_frames
+
+        stream = sd.OutputStream(
+            samplerate=SAMPLE_RATE,
+            callback=callback,
+            dtype=audio_content.dtype,
+            channels=audio_content.shape[1],
+        )
+        with stream:
+            await event.wait()
+
+    async def play_stream(
+        self,
+        buffer_stream: AsyncGenerator[Union[npt.NDArray[np.float32], npt.NDArray[np.int16], None], None],
+    ) -> None:
+        loop = asyncio.get_event_loop()
+        event = asyncio.Event()
+        buffer_queue: queue.Queue[Union[npt.NDArray[np.float32], npt.NDArray[np.int16], None]] = queue.Queue(maxsize=50)
+
+        async def buffer_producer():
+            async for buffer in buffer_stream:
+                if buffer is None:
+                    break
+                await loop.run_in_executor(None, buffer_queue.put, buffer)
+            await loop.run_in_executor(None, buffer_queue.put, None)  # Signal completion
+
+        def callback(
+            outdata: npt.NDArray[np.float32],
+            frame_count: int,
+            _time_info: Any,
+            _status: Any,
+        ):
+            nonlocal current_buffer, buffer_pos
+
+            frames_written = 0
+            while frames_written < frame_count:
+                if current_buffer is None or buffer_pos >= len(current_buffer):
+                    try:
+                        current_buffer = buffer_queue.get(timeout=0.1)
+                        if current_buffer is None:
+                            loop.call_soon_threadsafe(event.set)
+                            raise sd.CallbackStop
+                        buffer_pos = 0
+
+                        if current_buffer.dtype == np.int16 and self.dtype == np.float32:
+                            current_buffer = (current_buffer.astype(np.float32) / 32767.0).reshape(-1, self.channels)
+
+                    except queue.Empty:
+                        outdata[frames_written:] = 0
+                        return
+
+                remaining_frames = len(current_buffer) - buffer_pos
+                frames_to_write = min(frame_count - frames_written, remaining_frames)
+                outdata[frames_written : frames_written + frames_to_write] = current_buffer[
+                    buffer_pos : buffer_pos + frames_to_write
+                ]
+                buffer_pos += frames_to_write
+                frames_written += frames_to_write
+
+        current_buffer = None
+        buffer_pos = 0
+
+        producer_task = asyncio.create_task(buffer_producer())
+
+        with sd.OutputStream(
+            samplerate=SAMPLE_RATE,
+            channels=self.channels,
+            dtype=self.dtype,
+            callback=callback,
+        ):
+            await event.wait()
+
+        await producer_task
diff --git a/src/openai/helpers/microphone.py b/src/openai/helpers/microphone.py
new file mode 100644
index 0000000000..62a6d8d8a9
--- /dev/null
+++ b/src/openai/helpers/microphone.py
@@ -0,0 +1,100 @@
+# mypy: ignore-errors
+from __future__ import annotations
+
+import io
+import time
+import wave
+import asyncio
+from typing import Any, Type, Union, Generic, TypeVar, Callable, overload
+from typing_extensions import TYPE_CHECKING, Literal
+
+from .._types import FileTypes, FileContent
+from .._extras import numpy as np, sounddevice as sd
+
+if TYPE_CHECKING:
+    import numpy.typing as npt
+
+SAMPLE_RATE = 24000
+
+DType = TypeVar("DType", bound=np.generic)
+
+
+class Microphone(Generic[DType]):
+    def __init__(
+        self,
+        channels: int = 1,
+        dtype: Type[DType] = np.int16,
+        should_record: Union[Callable[[], bool], None] = None,
+        timeout: Union[float, None] = None,
+    ):
+        self.channels = channels
+        self.dtype = dtype
+        self.should_record = should_record
+        self.buffer_chunks = []
+        self.timeout = timeout
+        self.has_record_function = callable(should_record)
+
+    def _ndarray_to_wav(self, audio_data: npt.NDArray[DType]) -> FileTypes:
+        buffer: FileContent = io.BytesIO()
+        with wave.open(buffer, "w") as wav_file:
+            wav_file.setnchannels(self.channels)
+            wav_file.setsampwidth(np.dtype(self.dtype).itemsize)
+            wav_file.setframerate(SAMPLE_RATE)
+            wav_file.writeframes(audio_data.tobytes())
+        buffer.seek(0)
+        return ("audio.wav", buffer, "audio/wav")
+
+    @overload
+    async def record(self, return_ndarray: Literal[True]) -> npt.NDArray[DType]: ...
+
+    @overload
+    async def record(self, return_ndarray: Literal[False]) -> FileTypes: ...
+
+    @overload
+    async def record(self, return_ndarray: None = ...) -> FileTypes: ...
+
+    async def record(self, return_ndarray: Union[bool, None] = False) -> Union[npt.NDArray[DType], FileTypes]:
+        loop = asyncio.get_event_loop()
+        event = asyncio.Event()
+        self.buffer_chunks: list[npt.NDArray[DType]] = []
+        start_time = time.perf_counter()
+
+        def callback(
+            indata: npt.NDArray[DType],
+            _frame_count: int,
+            _time_info: Any,
+            _status: Any,
+        ):
+            execution_time = time.perf_counter() - start_time
+            reached_recording_timeout = execution_time > self.timeout if self.timeout is not None else False
+            if reached_recording_timeout:
+                loop.call_soon_threadsafe(event.set)
+                raise sd.CallbackStop
+
+            should_be_recording = self.should_record() if callable(self.should_record) else True
+            if not should_be_recording:
+                loop.call_soon_threadsafe(event.set)
+                raise sd.CallbackStop
+
+            self.buffer_chunks.append(indata.copy())
+
+        stream = sd.InputStream(
+            callback=callback,
+            dtype=self.dtype,
+            samplerate=SAMPLE_RATE,
+            channels=self.channels,
+        )
+        with stream:
+            await event.wait()
+
+        # Concatenate all chunks into a single buffer, handle empty case
+        concatenated_chunks: npt.NDArray[DType] = (
+            np.concatenate(self.buffer_chunks, axis=0)
+            if len(self.buffer_chunks) > 0
+            else np.array([], dtype=self.dtype)
+        )
+
+        if return_ndarray:
+            return concatenated_chunks
+        else:
+            return self._ndarray_to_wav(concatenated_chunks)
diff --git a/src/openai/lib/_parsing/_completions.py b/src/openai/lib/_parsing/_completions.py
index c160070b66..7903732a4a 100644
--- a/src/openai/lib/_parsing/_completions.py
+++ b/src/openai/lib/_parsing/_completions.py
@@ -1,15 +1,16 @@
 from __future__ import annotations
 
 import json
+import logging
 from typing import TYPE_CHECKING, Any, Iterable, cast
 from typing_extensions import TypeVar, TypeGuard, assert_never
 
 import pydantic
 
 from .._tools import PydanticFunctionTool
-from ..._types import NOT_GIVEN, NotGiven
+from ..._types import Omit, omit
 from ..._utils import is_dict, is_given
-from ..._compat import PYDANTIC_V2, model_parse_json
+from ..._compat import PYDANTIC_V1, model_parse_json
 from ..._models import construct_type_unchecked
 from .._pydantic import is_basemodel_type, to_strict_json_schema, is_dataclass_like_type
 from ...types.chat import (
@@ -19,14 +20,15 @@
     ParsedChatCompletion,
     ChatCompletionMessage,
     ParsedFunctionToolCall,
-    ChatCompletionToolParam,
     ParsedChatCompletionMessage,
+    ChatCompletionToolUnionParam,
+    ChatCompletionFunctionToolParam,
     completion_create_params,
 )
 from ..._exceptions import LengthFinishReasonError, ContentFilterFinishReasonError
 from ...types.shared_params import FunctionDefinition
 from ...types.chat.completion_create_params import ResponseFormat as ResponseFormatParam
-from ...types.chat.chat_completion_message_tool_call import Function
+from ...types.chat.chat_completion_message_function_tool_call import Function
 
 ResponseFormatT = TypeVar(
     "ResponseFormatT",
@@ -35,12 +37,36 @@
 )
 _default_response_format: None = None
 
+log: logging.Logger = logging.getLogger("openai.lib.parsing")
+
+
+def is_strict_chat_completion_tool_param(
+    tool: ChatCompletionToolUnionParam,
+) -> TypeGuard[ChatCompletionFunctionToolParam]:
+    """Check if the given tool is a strict ChatCompletionFunctionToolParam."""
+    if not tool["type"] == "function":
+        return False
+    if tool["function"].get("strict") is not True:
+        return False
+
+    return True
+
+
+def select_strict_chat_completion_tools(
+    tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+) -> Iterable[ChatCompletionFunctionToolParam] | Omit:
+    """Select only the strict ChatCompletionFunctionToolParams from the given tools."""
+    if not is_given(tools):
+        return omit
+
+    return [t for t in tools if is_strict_chat_completion_tool_param(t)]
+
 
 def validate_input_tools(
-    tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-) -> None:
+    tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+) -> Iterable[ChatCompletionFunctionToolParam] | Omit:
     if not is_given(tools):
-        return
+        return omit
 
     for tool in tools:
         if tool["type"] != "function":
@@ -54,11 +80,13 @@ def validate_input_tools(
                 f"`{tool['function']['name']}` is not strict. Only `strict` function tools can be auto-parsed"
             )
 
+    return cast(Iterable[ChatCompletionFunctionToolParam], tools)
+
 
 def parse_chat_completion(
     *,
-    response_format: type[ResponseFormatT] | completion_create_params.ResponseFormat | NotGiven,
-    input_tools: Iterable[ChatCompletionToolParam] | NotGiven,
+    response_format: type[ResponseFormatT] | completion_create_params.ResponseFormat | Omit,
+    input_tools: Iterable[ChatCompletionToolUnionParam] | Omit,
     chat_completion: ChatCompletion | ParsedChatCompletion[object],
 ) -> ParsedChatCompletion[ResponseFormatT]:
     if is_given(input_tools):
@@ -95,6 +123,14 @@ def parse_chat_completion(
                             type_=ParsedFunctionToolCall,
                         )
                     )
+                elif tool_call.type == "custom":
+                    # warn user that custom tool calls are not callable here
+                    log.warning(
+                        "Custom tool calls are not callable. Ignoring tool call: %s - %s",
+                        tool_call.id,
+                        tool_call.custom.name,
+                        stacklevel=2,
+                    )
                 elif TYPE_CHECKING:  # type: ignore[unreachable]
                     assert_never(tool_call)
                 else:
@@ -129,13 +165,15 @@ def parse_chat_completion(
     )
 
 
-def get_input_tool_by_name(*, input_tools: list[ChatCompletionToolParam], name: str) -> ChatCompletionToolParam | None:
-    return next((t for t in input_tools if t.get("function", {}).get("name") == name), None)
+def get_input_tool_by_name(
+    *, input_tools: list[ChatCompletionToolUnionParam], name: str
+) -> ChatCompletionFunctionToolParam | None:
+    return next((t for t in input_tools if t["type"] == "function" and t.get("function", {}).get("name") == name), None)
 
 
 def parse_function_tool_arguments(
-    *, input_tools: list[ChatCompletionToolParam], function: Function | ParsedFunction
-) -> object:
+    *, input_tools: list[ChatCompletionToolUnionParam], function: Function | ParsedFunction
+) -> object | None:
     input_tool = get_input_tool_by_name(input_tools=input_tools, name=function.name)
     if not input_tool:
         return None
@@ -149,12 +187,12 @@ def parse_function_tool_arguments(
     if not input_fn.get("strict"):
         return None
 
-    return json.loads(function.arguments)
+    return json.loads(function.arguments)  # type: ignore[no-any-return]
 
 
 def maybe_parse_content(
     *,
-    response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
+    response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
     message: ChatCompletionMessage | ParsedChatCompletionMessage[object],
 ) -> ResponseFormatT | None:
     if has_rich_response_format(response_format) and message.content and not message.refusal:
@@ -164,7 +202,7 @@ def maybe_parse_content(
 
 
 def solve_response_format_t(
-    response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
+    response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
 ) -> type[ResponseFormatT]:
     """Return the runtime type for the given response format.
 
@@ -179,8 +217,8 @@ def solve_response_format_t(
 
 def has_parseable_input(
     *,
-    response_format: type | ResponseFormatParam | NotGiven,
-    input_tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
+    response_format: type | ResponseFormatParam | Omit,
+    input_tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
 ) -> bool:
     if has_rich_response_format(response_format):
         return True
@@ -193,7 +231,7 @@ def has_parseable_input(
 
 
 def has_rich_response_format(
-    response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
+    response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
 ) -> TypeGuard[type[ResponseFormatT]]:
     if not is_given(response_format):
         return False
@@ -208,7 +246,10 @@ def is_response_format_param(response_format: object) -> TypeGuard[ResponseForma
     return is_dict(response_format)
 
 
-def is_parseable_tool(input_tool: ChatCompletionToolParam) -> bool:
+def is_parseable_tool(input_tool: ChatCompletionToolUnionParam) -> bool:
+    if input_tool["type"] != "function":
+        return False
+
     input_fn = cast(object, input_tool.get("function"))
     if isinstance(input_fn, PydanticFunctionTool):
         return True
@@ -221,7 +262,7 @@ def _parse_content(response_format: type[ResponseFormatT], content: str) -> Resp
         return cast(ResponseFormatT, model_parse_json(response_format, content))
 
     if is_dataclass_like_type(response_format):
-        if not PYDANTIC_V2:
+        if PYDANTIC_V1:
             raise TypeError(f"Non BaseModel types are only supported with Pydantic v2 - {response_format}")
 
         return pydantic.TypeAdapter(response_format).validate_json(content)
@@ -230,10 +271,10 @@ def _parse_content(response_format: type[ResponseFormatT], content: str) -> Resp
 
 
 def type_to_response_format_param(
-    response_format: type | completion_create_params.ResponseFormat | NotGiven,
-) -> ResponseFormatParam | NotGiven:
+    response_format: type | completion_create_params.ResponseFormat | Omit,
+) -> ResponseFormatParam | Omit:
     if not is_given(response_format):
-        return NOT_GIVEN
+        return omit
 
     if is_response_format_param(response_format):
         return response_format
diff --git a/src/openai/lib/_parsing/_responses.py b/src/openai/lib/_parsing/_responses.py
index a189dcf937..4d7b0b6224 100644
--- a/src/openai/lib/_parsing/_responses.py
+++ b/src/openai/lib/_parsing/_responses.py
@@ -7,9 +7,9 @@
 import pydantic
 
 from .._tools import ResponsesPydanticFunctionTool
-from ..._types import NotGiven
+from ..._types import Omit
 from ..._utils import is_given
-from ..._compat import PYDANTIC_V2, model_parse_json
+from ..._compat import PYDANTIC_V1, model_parse_json
 from ..._models import construct_type_unchecked
 from .._pydantic import is_basemodel_type, is_dataclass_like_type
 from ._completions import solve_response_format_t, type_to_response_format_param
@@ -52,8 +52,8 @@ def type_to_text_format_param(type_: type) -> ResponseFormatTextConfigParam:
 
 def parse_response(
     *,
-    text_format: type[TextFormatT] | NotGiven,
-    input_tools: Iterable[ToolParam] | NotGiven | None,
+    text_format: type[TextFormatT] | Omit,
+    input_tools: Iterable[ToolParam] | Omit | None,
     response: Response | ParsedResponse[object],
 ) -> ParsedResponse[TextFormatT]:
     solved_t = solve_response_format_t(text_format)
@@ -103,6 +103,18 @@ def parse_response(
             or output.type == "file_search_call"
             or output.type == "web_search_call"
             or output.type == "reasoning"
+            or output.type == "mcp_call"
+            or output.type == "mcp_approval_request"
+            or output.type == "image_generation_call"
+            or output.type == "code_interpreter_call"
+            or output.type == "local_shell_call"
+            or output.type == "shell_call"
+            or output.type == "shell_call_output"
+            or output.type == "apply_patch_call"
+            or output.type == "apply_patch_call_output"
+            or output.type == "mcp_list_tools"
+            or output.type == "exec"
+            or output.type == "custom_tool_call"
         ):
             output_list.append(output)
         elif TYPE_CHECKING:  # type: ignore
@@ -122,7 +134,7 @@ def parse_response(
     )
 
 
-def parse_text(text: str, text_format: type[TextFormatT] | NotGiven) -> TextFormatT | None:
+def parse_text(text: str, text_format: type[TextFormatT] | Omit) -> TextFormatT | None:
     if not is_given(text_format):
         return None
 
@@ -130,7 +142,7 @@ def parse_text(text: str, text_format: type[TextFormatT] | NotGiven) -> TextForm
         return cast(TextFormatT, model_parse_json(text_format, text))
 
     if is_dataclass_like_type(text_format):
-        if not PYDANTIC_V2:
+        if PYDANTIC_V1:
             raise TypeError(f"Non BaseModel types are only supported with Pydantic v2 - {text_format}")
 
         return pydantic.TypeAdapter(text_format).validate_json(text)
@@ -148,7 +160,7 @@ def get_input_tool_by_name(*, input_tools: Iterable[ToolParam], name: str) -> Fu
 
 def parse_function_tool_arguments(
     *,
-    input_tools: Iterable[ToolParam] | NotGiven | None,
+    input_tools: Iterable[ToolParam] | Omit | None,
     function_call: ParsedResponseFunctionToolCall | ResponseFunctionToolCall,
 ) -> object:
     if input_tools is None or not is_given(input_tools):
diff --git a/src/openai/lib/_pydantic.py b/src/openai/lib/_pydantic.py
index c2d73e5fc6..3cfe224cb1 100644
--- a/src/openai/lib/_pydantic.py
+++ b/src/openai/lib/_pydantic.py
@@ -8,7 +8,7 @@
 
 from .._types import NOT_GIVEN
 from .._utils import is_dict as _is_dict, is_list
-from .._compat import PYDANTIC_V2, model_json_schema
+from .._compat import PYDANTIC_V1, model_json_schema
 
 _T = TypeVar("_T")
 
@@ -16,7 +16,7 @@
 def to_strict_json_schema(model: type[pydantic.BaseModel] | pydantic.TypeAdapter[Any]) -> dict[str, Any]:
     if inspect.isclass(model) and is_basemodel_type(model):
         schema = model_json_schema(model)
-    elif PYDANTIC_V2 and isinstance(model, pydantic.TypeAdapter):
+    elif (not PYDANTIC_V1) and isinstance(model, pydantic.TypeAdapter):
         schema = model.json_schema()
     else:
         raise TypeError(f"Non BaseModel types are only supported with Pydantic v2 - {model}")
diff --git a/src/openai/lib/_realtime.py b/src/openai/lib/_realtime.py
new file mode 100644
index 0000000000..999d1e4463
--- /dev/null
+++ b/src/openai/lib/_realtime.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import json
+from typing_extensions import override
+
+import httpx
+
+from openai import _legacy_response
+from openai._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from openai._utils import maybe_transform, async_maybe_transform
+from openai._base_client import make_request_options
+from openai.resources.realtime.calls import Calls, AsyncCalls
+from openai.types.realtime.realtime_session_create_request_param import RealtimeSessionCreateRequestParam
+
+__all__ = ["_Calls", "_AsyncCalls"]
+
+
+# Custom code to override the `create` method to have correct behavior with
+# application/sdp and multipart/form-data.
+# Ideally we can cutover to the generated code this overrides eventually and remove this.
+class _Calls(Calls):
+    @override
+    def create(
+        self,
+        *,
+        sdp: str,
+        session: RealtimeSessionCreateRequestParam | Omit = omit,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        if session is omit:
+            extra_headers = {"Accept": "application/sdp", "Content-Type": "application/sdp", **(extra_headers or {})}
+            return self._post(
+                "/realtime/calls",
+                body=sdp.encode("utf-8"),
+                options=make_request_options(extra_headers=extra_headers, extra_query=extra_query, timeout=timeout),
+                cast_to=_legacy_response.HttpxBinaryResponseContent,
+            )
+
+        extra_headers = {"Accept": "application/sdp", "Content-Type": "multipart/form-data", **(extra_headers or {})}
+        session_payload = maybe_transform(session, RealtimeSessionCreateRequestParam)
+        files = [
+            ("sdp", (None, sdp.encode("utf-8"), "application/sdp")),
+            ("session", (None, json.dumps(session_payload).encode("utf-8"), "application/json")),
+        ]
+        return self._post(
+            "/realtime/calls",
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
+
+
+class _AsyncCalls(AsyncCalls):
+    @override
+    async def create(
+        self,
+        *,
+        sdp: str,
+        session: RealtimeSessionCreateRequestParam | Omit = omit,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        if session is omit:
+            extra_headers = {"Accept": "application/sdp", "Content-Type": "application/sdp", **(extra_headers or {})}
+            return await self._post(
+                "/realtime/calls",
+                body=sdp.encode("utf-8"),
+                options=make_request_options(extra_headers=extra_headers, extra_query=extra_query, timeout=timeout),
+                cast_to=_legacy_response.HttpxBinaryResponseContent,
+            )
+
+        extra_headers = {"Accept": "application/sdp", "Content-Type": "multipart/form-data", **(extra_headers or {})}
+        session_payload = await async_maybe_transform(session, RealtimeSessionCreateRequestParam)
+        files = [
+            ("sdp", (None, sdp.encode("utf-8"), "application/sdp")),
+            ("session", (None, json.dumps(session_payload).encode("utf-8"), "application/json")),
+        ]
+        return await self._post(
+            "/realtime/calls",
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
diff --git a/src/openai/lib/_tools.py b/src/openai/lib/_tools.py
index 415d750074..4070ad63bb 100644
--- a/src/openai/lib/_tools.py
+++ b/src/openai/lib/_tools.py
@@ -5,7 +5,7 @@
 import pydantic
 
 from ._pydantic import to_strict_json_schema
-from ..types.chat import ChatCompletionToolParam
+from ..types.chat import ChatCompletionFunctionToolParam
 from ..types.shared_params import FunctionDefinition
 from ..types.responses.function_tool_param import FunctionToolParam as ResponsesFunctionToolParam
 
@@ -42,7 +42,7 @@ def pydantic_function_tool(
     *,
     name: str | None = None,  # inferred from class name by default
     description: str | None = None,  # inferred from class docstring by default
-) -> ChatCompletionToolParam:
+) -> ChatCompletionFunctionToolParam:
     if description is None:
         # note: we intentionally don't use `.getdoc()` to avoid
         # including pydantic's docstrings
diff --git a/src/openai/lib/azure.py b/src/openai/lib/azure.py
index ea7bd20d99..ad64707261 100644
--- a/src/openai/lib/azure.py
+++ b/src/openai/lib/azure.py
@@ -25,6 +25,7 @@
         "/audio/translations",
         "/audio/speech",
         "/images/generations",
+        "/images/edits",
     ]
 )
 
@@ -93,10 +94,11 @@ def __init__(
         azure_endpoint: str,
         azure_deployment: str | None = None,
         api_version: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], str] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AzureADTokenProvider | None = None,
         organization: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -112,10 +114,11 @@ def __init__(
         *,
         azure_deployment: str | None = None,
         api_version: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], str] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AzureADTokenProvider | None = None,
         organization: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -131,10 +134,11 @@ def __init__(
         *,
         base_url: str,
         api_version: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], str] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AzureADTokenProvider | None = None,
         organization: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -150,11 +154,12 @@ def __init__(
         api_version: str | None = None,
         azure_endpoint: str | None = None,
         azure_deployment: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], str] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AzureADTokenProvider | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         base_url: str | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
@@ -233,6 +238,7 @@ def __init__(
             api_key=api_key,
             organization=organization,
             project=project,
+            webhook_secret=webhook_secret,
             base_url=base_url,
             timeout=timeout,
             max_retries=max_retries,
@@ -252,9 +258,10 @@ def __init__(
     def copy(
         self,
         *,
-        api_key: str | None = None,
+        api_key: str | Callable[[], str] | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         api_version: str | None = None,
         azure_ad_token: str | None = None,
@@ -276,6 +283,7 @@ def copy(
             api_key=api_key,
             organization=organization,
             project=project,
+            webhook_secret=webhook_secret,
             websocket_base_url=websocket_base_url,
             base_url=base_url,
             timeout=timeout,
@@ -337,7 +345,7 @@ def _configure_realtime(self, model: str, extra_query: Query) -> tuple[httpx.URL
             "api-version": self._api_version,
             "deployment": self._azure_deployment or model,
         }
-        if self.api_key != "<missing API key>":
+        if self.api_key and self.api_key != "<missing API key>":
             auth_headers = {"api-key": self.api_key}
         else:
             token = self._get_azure_ad_token()
@@ -364,11 +372,12 @@ def __init__(
         azure_endpoint: str,
         azure_deployment: str | None = None,
         api_version: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], Awaitable[str]] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -384,11 +393,12 @@ def __init__(
         *,
         azure_deployment: str | None = None,
         api_version: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], Awaitable[str]] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -404,11 +414,12 @@ def __init__(
         *,
         base_url: str,
         api_version: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], Awaitable[str]] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -424,11 +435,12 @@ def __init__(
         azure_endpoint: str | None = None,
         azure_deployment: str | None = None,
         api_version: str | None = None,
-        api_key: str | None = None,
+        api_key: str | Callable[[], Awaitable[str]] | None = None,
         azure_ad_token: str | None = None,
         azure_ad_token_provider: AsyncAzureADTokenProvider | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         base_url: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
@@ -507,6 +519,7 @@ def __init__(
             api_key=api_key,
             organization=organization,
             project=project,
+            webhook_secret=webhook_secret,
             base_url=base_url,
             timeout=timeout,
             max_retries=max_retries,
@@ -526,9 +539,10 @@ def __init__(
     def copy(
         self,
         *,
-        api_key: str | None = None,
+        api_key: str | Callable[[], Awaitable[str]] | None = None,
         organization: str | None = None,
         project: str | None = None,
+        webhook_secret: str | None = None,
         websocket_base_url: str | httpx.URL | None = None,
         api_version: str | None = None,
         azure_ad_token: str | None = None,
@@ -550,6 +564,7 @@ def copy(
             api_key=api_key,
             organization=organization,
             project=project,
+            webhook_secret=webhook_secret,
             websocket_base_url=websocket_base_url,
             base_url=base_url,
             timeout=timeout,
@@ -613,7 +628,7 @@ async def _configure_realtime(self, model: str, extra_query: Query) -> tuple[htt
             "api-version": self._api_version,
             "deployment": self._azure_deployment or model,
         }
-        if self.api_key != "<missing API key>":
+        if self.api_key and self.api_key != "<missing API key>":
             auth_headers = {"api-key": self.api_key}
         else:
             token = await self._get_azure_ad_token()
diff --git a/src/openai/lib/streaming/chat/_completions.py b/src/openai/lib/streaming/chat/_completions.py
index 2146091354..c4610e2120 100644
--- a/src/openai/lib/streaming/chat/_completions.py
+++ b/src/openai/lib/streaming/chat/_completions.py
@@ -23,7 +23,7 @@
     FunctionToolCallArgumentsDeltaEvent,
 )
 from .._deltas import accumulate_delta
-from ...._types import NOT_GIVEN, IncEx, NotGiven
+from ...._types import Omit, IncEx, omit
 from ...._utils import is_given, consume_sync_iterator, consume_async_iterator
 from ...._compat import model_dump
 from ...._models import build, construct_type
@@ -37,7 +37,7 @@
     parse_function_tool_arguments,
 )
 from ...._streaming import Stream, AsyncStream
-from ....types.chat import ChatCompletionChunk, ParsedChatCompletion, ChatCompletionToolParam
+from ....types.chat import ChatCompletionChunk, ParsedChatCompletion, ChatCompletionToolUnionParam
 from ...._exceptions import LengthFinishReasonError, ContentFilterFinishReasonError
 from ....types.chat.chat_completion import ChoiceLogprobs
 from ....types.chat.chat_completion_chunk import Choice as ChoiceChunk
@@ -57,8 +57,8 @@ def __init__(
         self,
         *,
         raw_stream: Stream[ChatCompletionChunk],
-        response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
-        input_tools: Iterable[ChatCompletionToolParam] | NotGiven,
+        response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
+        input_tools: Iterable[ChatCompletionToolUnionParam] | Omit,
     ) -> None:
         self._raw_stream = raw_stream
         self._response = raw_stream.response
@@ -113,6 +113,8 @@ def current_completion_snapshot(self) -> ParsedChatCompletionSnapshot:
 
     def __stream__(self) -> Iterator[ChatCompletionStreamEvent[ResponseFormatT]]:
         for sse_event in self._raw_stream:
+            if not _is_valid_chat_completion_chunk_weak(sse_event):
+                continue
             events_to_fire = self._state.handle_chunk(sse_event)
             for event in events_to_fire:
                 yield event
@@ -126,7 +128,7 @@ class ChatCompletionStreamManager(Generic[ResponseFormatT]):
 
     Usage:
     ```py
-    with client.beta.chat.completions.stream(...) as stream:
+    with client.chat.completions.stream(...) as stream:
         for event in stream:
             ...
     ```
@@ -136,8 +138,8 @@ def __init__(
         self,
         api_request: Callable[[], Stream[ChatCompletionChunk]],
         *,
-        response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
-        input_tools: Iterable[ChatCompletionToolParam] | NotGiven,
+        response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
+        input_tools: Iterable[ChatCompletionToolUnionParam] | Omit,
     ) -> None:
         self.__stream: ChatCompletionStream[ResponseFormatT] | None = None
         self.__api_request = api_request
@@ -178,8 +180,8 @@ def __init__(
         self,
         *,
         raw_stream: AsyncStream[ChatCompletionChunk],
-        response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
-        input_tools: Iterable[ChatCompletionToolParam] | NotGiven,
+        response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
+        input_tools: Iterable[ChatCompletionToolUnionParam] | Omit,
     ) -> None:
         self._raw_stream = raw_stream
         self._response = raw_stream.response
@@ -234,6 +236,8 @@ def current_completion_snapshot(self) -> ParsedChatCompletionSnapshot:
 
     async def __stream__(self) -> AsyncIterator[ChatCompletionStreamEvent[ResponseFormatT]]:
         async for sse_event in self._raw_stream:
+            if not _is_valid_chat_completion_chunk_weak(sse_event):
+                continue
             events_to_fire = self._state.handle_chunk(sse_event)
             for event in events_to_fire:
                 yield event
@@ -247,7 +251,7 @@ class AsyncChatCompletionStreamManager(Generic[ResponseFormatT]):
 
     Usage:
     ```py
-    async with client.beta.chat.completions.stream(...) as stream:
+    async with client.chat.completions.stream(...) as stream:
         for event in stream:
             ...
     ```
@@ -257,8 +261,8 @@ def __init__(
         self,
         api_request: Awaitable[AsyncStream[ChatCompletionChunk]],
         *,
-        response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
-        input_tools: Iterable[ChatCompletionToolParam] | NotGiven,
+        response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
+        input_tools: Iterable[ChatCompletionToolUnionParam] | Omit,
     ) -> None:
         self.__stream: AsyncChatCompletionStream[ResponseFormatT] | None = None
         self.__api_request = api_request
@@ -310,15 +314,15 @@ class ChatCompletionStreamState(Generic[ResponseFormatT]):
     def __init__(
         self,
         *,
-        input_tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven = NOT_GIVEN,
+        input_tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        response_format: type[ResponseFormatT] | ResponseFormatParam | Omit = omit,
     ) -> None:
         self.__current_completion_snapshot: ParsedChatCompletionSnapshot | None = None
         self.__choice_event_states: list[ChoiceEventState] = []
 
         self._input_tools = [tool for tool in input_tools] if is_given(input_tools) else []
         self._response_format = response_format
-        self._rich_response_format: type | NotGiven = response_format if inspect.isclass(response_format) else NOT_GIVEN
+        self._rich_response_format: type | Omit = response_format if inspect.isclass(response_format) else omit
 
     def get_final_completion(self) -> ParsedChatCompletion[ResponseFormatT]:
         """Parse the final completion object.
@@ -434,6 +438,8 @@ def _accumulate_chunk(self, chunk: ChatCompletionChunk) -> ParsedChatCompletionS
                 choice_snapshot.message.content
                 and not choice_snapshot.message.refusal
                 and is_given(self._rich_response_format)
+                # partial parsing fails on white-space
+                and choice_snapshot.message.content.lstrip()
             ):
                 choice_snapshot.message.parsed = from_json(
                     bytes(choice_snapshot.message.content, "utf-8"),
@@ -578,7 +584,7 @@ def _build_events(
 
 
 class ChoiceEventState:
-    def __init__(self, *, input_tools: list[ChatCompletionToolParam]) -> None:
+    def __init__(self, *, input_tools: list[ChatCompletionToolUnionParam]) -> None:
         self._input_tools = input_tools
 
         self._content_done = False
@@ -593,7 +599,7 @@ def get_done_events(
         *,
         choice_chunk: ChoiceChunk,
         choice_snapshot: ParsedChoiceSnapshot,
-        response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
+        response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
     ) -> list[ChatCompletionStreamEvent[ResponseFormatT]]:
         events_to_fire: list[ChatCompletionStreamEvent[ResponseFormatT]] = []
 
@@ -633,7 +639,7 @@ def _content_done_events(
         self,
         *,
         choice_snapshot: ParsedChoiceSnapshot,
-        response_format: type[ResponseFormatT] | ResponseFormatParam | NotGiven,
+        response_format: type[ResponseFormatT] | ResponseFormatParam | Omit,
     ) -> list[ChatCompletionStreamEvent[ResponseFormatT]]:
         events_to_fire: list[ChatCompletionStreamEvent[ResponseFormatT]] = []
 
@@ -753,3 +759,12 @@ def _convert_initial_chunk_into_snapshot(chunk: ChatCompletionChunk) -> ParsedCh
             },
         ),
     )
+
+
+def _is_valid_chat_completion_chunk_weak(sse_event: ChatCompletionChunk) -> bool:
+    # Although the _raw_stream is always supposed to contain only objects adhering to ChatCompletionChunk schema,
+    # this is broken by the Azure OpenAI in case of Asynchronous Filter enabled.
+    # An easy filter is to check for the "object" property:
+    # - should be "chat.completion.chunk" for a ChatCompletionChunk;
+    # - is an empty string for Asynchronous Filter events.
+    return sse_event.object == "chat.completion.chunk"  # type: ignore # pylance reports this as a useless check
diff --git a/src/openai/lib/streaming/responses/_events.py b/src/openai/lib/streaming/responses/_events.py
index fe17edf649..bdc47b834a 100644
--- a/src/openai/lib/streaming/responses/_events.py
+++ b/src/openai/lib/streaming/responses/_events.py
@@ -9,6 +9,7 @@
     ParsedResponse,
     ResponseErrorEvent,
     ResponseFailedEvent,
+    ResponseQueuedEvent,
     ResponseCreatedEvent,
     ResponseTextDoneEvent as RawResponseTextDoneEvent,
     ResponseAudioDoneEvent,
@@ -19,20 +20,38 @@
     ResponseInProgressEvent,
     ResponseRefusalDoneEvent,
     ResponseRefusalDeltaEvent,
+    ResponseMcpCallFailedEvent,
     ResponseOutputItemDoneEvent,
     ResponseContentPartDoneEvent,
     ResponseOutputItemAddedEvent,
     ResponseContentPartAddedEvent,
+    ResponseMcpCallCompletedEvent,
+    ResponseMcpCallInProgressEvent,
+    ResponseMcpListToolsFailedEvent,
     ResponseAudioTranscriptDoneEvent,
-    ResponseTextAnnotationDeltaEvent,
     ResponseAudioTranscriptDeltaEvent,
+    ResponseMcpCallArgumentsDoneEvent,
+    ResponseImageGenCallCompletedEvent,
+    ResponseMcpCallArgumentsDeltaEvent,
+    ResponseMcpListToolsCompletedEvent,
+    ResponseImageGenCallGeneratingEvent,
+    ResponseImageGenCallInProgressEvent,
+    ResponseMcpListToolsInProgressEvent,
     ResponseWebSearchCallCompletedEvent,
     ResponseWebSearchCallSearchingEvent,
+    ResponseCustomToolCallInputDoneEvent,
     ResponseFileSearchCallCompletedEvent,
     ResponseFileSearchCallSearchingEvent,
     ResponseWebSearchCallInProgressEvent,
+    ResponseCustomToolCallInputDeltaEvent,
     ResponseFileSearchCallInProgressEvent,
+    ResponseImageGenCallPartialImageEvent,
+    ResponseReasoningSummaryPartDoneEvent,
+    ResponseReasoningSummaryTextDoneEvent,
     ResponseFunctionCallArgumentsDoneEvent,
+    ResponseOutputTextAnnotationAddedEvent,
+    ResponseReasoningSummaryPartAddedEvent,
+    ResponseReasoningSummaryTextDeltaEvent,
     ResponseFunctionCallArgumentsDeltaEvent as RawResponseFunctionCallArgumentsDeltaEvent,
     ResponseCodeInterpreterCallCodeDoneEvent,
     ResponseCodeInterpreterCallCodeDeltaEvent,
@@ -40,6 +59,8 @@
     ResponseCodeInterpreterCallInProgressEvent,
     ResponseCodeInterpreterCallInterpretingEvent,
 )
+from ....types.responses.response_reasoning_text_done_event import ResponseReasoningTextDoneEvent
+from ....types.responses.response_reasoning_text_delta_event import ResponseReasoningTextDeltaEvent
 
 TextFormatT = TypeVar(
     "TextFormatT",
@@ -96,11 +117,32 @@ class ResponseCompletedEvent(RawResponseCompletedEvent, GenericModel, Generic[Te
         ResponseOutputItemDoneEvent,
         ResponseRefusalDeltaEvent,
         ResponseRefusalDoneEvent,
-        ResponseTextAnnotationDeltaEvent,
         ResponseTextDoneEvent,
         ResponseWebSearchCallCompletedEvent,
         ResponseWebSearchCallInProgressEvent,
         ResponseWebSearchCallSearchingEvent,
+        ResponseReasoningSummaryPartAddedEvent,
+        ResponseReasoningSummaryPartDoneEvent,
+        ResponseReasoningSummaryTextDeltaEvent,
+        ResponseReasoningSummaryTextDoneEvent,
+        ResponseImageGenCallCompletedEvent,
+        ResponseImageGenCallInProgressEvent,
+        ResponseImageGenCallGeneratingEvent,
+        ResponseImageGenCallPartialImageEvent,
+        ResponseMcpCallCompletedEvent,
+        ResponseMcpCallArgumentsDeltaEvent,
+        ResponseMcpCallArgumentsDoneEvent,
+        ResponseMcpCallFailedEvent,
+        ResponseMcpCallInProgressEvent,
+        ResponseMcpListToolsCompletedEvent,
+        ResponseMcpListToolsFailedEvent,
+        ResponseMcpListToolsInProgressEvent,
+        ResponseOutputTextAnnotationAddedEvent,
+        ResponseQueuedEvent,
+        ResponseReasoningTextDeltaEvent,
+        ResponseReasoningTextDoneEvent,
+        ResponseCustomToolCallInputDeltaEvent,
+        ResponseCustomToolCallInputDoneEvent,
     ],
     PropertyInfo(discriminator="type"),
 ]
diff --git a/src/openai/lib/streaming/responses/_responses.py b/src/openai/lib/streaming/responses/_responses.py
index f8f4b64174..6975a9260d 100644
--- a/src/openai/lib/streaming/responses/_responses.py
+++ b/src/openai/lib/streaming/responses/_responses.py
@@ -13,7 +13,7 @@
     ResponseTextDeltaEvent,
     ResponseFunctionCallArgumentsDeltaEvent,
 )
-from ...._types import NOT_GIVEN, NotGiven
+from ...._types import Omit, omit
 from ...._utils import is_given, consume_sync_iterator, consume_async_iterator
 from ...._models import build, construct_type_unchecked
 from ...._streaming import Stream, AsyncStream
@@ -32,13 +32,15 @@ def __init__(
         self,
         *,
         raw_stream: Stream[RawResponseStreamEvent],
-        text_format: type[TextFormatT] | NotGiven,
-        input_tools: Iterable[ToolParam] | NotGiven,
+        text_format: type[TextFormatT] | Omit,
+        input_tools: Iterable[ToolParam] | Omit,
+        starting_after: int | None,
     ) -> None:
         self._raw_stream = raw_stream
         self._response = raw_stream.response
         self._iterator = self.__stream__()
         self._state = ResponseStreamState(text_format=text_format, input_tools=input_tools)
+        self._starting_after = starting_after
 
     def __next__(self) -> ResponseStreamEvent[TextFormatT]:
         return self._iterator.__next__()
@@ -54,7 +56,8 @@ def __stream__(self) -> Iterator[ResponseStreamEvent[TextFormatT]]:
         for sse_event in self._raw_stream:
             events_to_fire = self._state.handle_event(sse_event)
             for event in events_to_fire:
-                yield event
+                if self._starting_after is None or event.sequence_number > self._starting_after:
+                    yield event
 
     def __exit__(
         self,
@@ -94,13 +97,15 @@ def __init__(
         self,
         api_request: Callable[[], Stream[RawResponseStreamEvent]],
         *,
-        text_format: type[TextFormatT] | NotGiven,
-        input_tools: Iterable[ToolParam] | NotGiven,
+        text_format: type[TextFormatT] | Omit,
+        input_tools: Iterable[ToolParam] | Omit,
+        starting_after: int | None,
     ) -> None:
         self.__stream: ResponseStream[TextFormatT] | None = None
         self.__api_request = api_request
         self.__text_format = text_format
         self.__input_tools = input_tools
+        self.__starting_after = starting_after
 
     def __enter__(self) -> ResponseStream[TextFormatT]:
         raw_stream = self.__api_request()
@@ -109,6 +114,7 @@ def __enter__(self) -> ResponseStream[TextFormatT]:
             raw_stream=raw_stream,
             text_format=self.__text_format,
             input_tools=self.__input_tools,
+            starting_after=self.__starting_after,
         )
 
         return self.__stream
@@ -128,13 +134,15 @@ def __init__(
         self,
         *,
         raw_stream: AsyncStream[RawResponseStreamEvent],
-        text_format: type[TextFormatT] | NotGiven,
-        input_tools: Iterable[ToolParam] | NotGiven,
+        text_format: type[TextFormatT] | Omit,
+        input_tools: Iterable[ToolParam] | Omit,
+        starting_after: int | None,
     ) -> None:
         self._raw_stream = raw_stream
         self._response = raw_stream.response
         self._iterator = self.__stream__()
         self._state = ResponseStreamState(text_format=text_format, input_tools=input_tools)
+        self._starting_after = starting_after
 
     async def __anext__(self) -> ResponseStreamEvent[TextFormatT]:
         return await self._iterator.__anext__()
@@ -147,7 +155,8 @@ async def __stream__(self) -> AsyncIterator[ResponseStreamEvent[TextFormatT]]:
         async for sse_event in self._raw_stream:
             events_to_fire = self._state.handle_event(sse_event)
             for event in events_to_fire:
-                yield event
+                if self._starting_after is None or event.sequence_number > self._starting_after:
+                    yield event
 
     async def __aenter__(self) -> Self:
         return self
@@ -190,13 +199,15 @@ def __init__(
         self,
         api_request: Awaitable[AsyncStream[RawResponseStreamEvent]],
         *,
-        text_format: type[TextFormatT] | NotGiven,
-        input_tools: Iterable[ToolParam] | NotGiven,
+        text_format: type[TextFormatT] | Omit,
+        input_tools: Iterable[ToolParam] | Omit,
+        starting_after: int | None,
     ) -> None:
         self.__stream: AsyncResponseStream[TextFormatT] | None = None
         self.__api_request = api_request
         self.__text_format = text_format
         self.__input_tools = input_tools
+        self.__starting_after = starting_after
 
     async def __aenter__(self) -> AsyncResponseStream[TextFormatT]:
         raw_stream = await self.__api_request
@@ -205,6 +216,7 @@ async def __aenter__(self) -> AsyncResponseStream[TextFormatT]:
             raw_stream=raw_stream,
             text_format=self.__text_format,
             input_tools=self.__input_tools,
+            starting_after=self.__starting_after,
         )
 
         return self.__stream
@@ -223,14 +235,14 @@ class ResponseStreamState(Generic[TextFormatT]):
     def __init__(
         self,
         *,
-        input_tools: Iterable[ToolParam] | NotGiven,
-        text_format: type[TextFormatT] | NotGiven,
+        input_tools: Iterable[ToolParam] | Omit,
+        text_format: type[TextFormatT] | Omit,
     ) -> None:
         self.__current_snapshot: ParsedResponseSnapshot | None = None
         self._completed_response: ParsedResponse[TextFormatT] | None = None
         self._input_tools = [tool for tool in input_tools] if is_given(input_tools) else []
         self._text_format = text_format
-        self._rich_text_format: type | NotGiven = text_format if inspect.isclass(text_format) else NOT_GIVEN
+        self._rich_text_format: type | Omit = text_format if inspect.isclass(text_format) else omit
 
     def handle_event(self, event: RawResponseStreamEvent) -> List[ResponseStreamEvent[TextFormatT]]:
         self.__current_snapshot = snapshot = self.accumulate_event(event)
@@ -251,6 +263,8 @@ def handle_event(self, event: RawResponseStreamEvent) -> List[ResponseStreamEven
                     delta=event.delta,
                     item_id=event.item_id,
                     output_index=event.output_index,
+                    sequence_number=event.sequence_number,
+                    logprobs=event.logprobs,
                     type="response.output_text.delta",
                     snapshot=content.text,
                 )
@@ -268,6 +282,8 @@ def handle_event(self, event: RawResponseStreamEvent) -> List[ResponseStreamEven
                     content_index=event.content_index,
                     item_id=event.item_id,
                     output_index=event.output_index,
+                    sequence_number=event.sequence_number,
+                    logprobs=event.logprobs,
                     type="response.output_text.done",
                     text=event.text,
                     parsed=parse_text(event.text, text_format=self._text_format),
@@ -283,6 +299,7 @@ def handle_event(self, event: RawResponseStreamEvent) -> List[ResponseStreamEven
                     delta=event.delta,
                     item_id=event.item_id,
                     output_index=event.output_index,
+                    sequence_number=event.sequence_number,
                     type="response.function_call_arguments.delta",
                     snapshot=output.arguments,
                 )
@@ -295,6 +312,7 @@ def handle_event(self, event: RawResponseStreamEvent) -> List[ResponseStreamEven
             events.append(
                 build(
                     ResponseCompletedEvent,
+                    sequence_number=event.sequence_number,
                     type="response.completed",
                     response=response,
                 )
diff --git a/src/openai/pagination.py b/src/openai/pagination.py
index a59cced854..4dd3788aa3 100644
--- a/src/openai/pagination.py
+++ b/src/openai/pagination.py
@@ -5,7 +5,14 @@
 
 from ._base_client import BasePage, PageInfo, BaseSyncPage, BaseAsyncPage
 
-__all__ = ["SyncPage", "AsyncPage", "SyncCursorPage", "AsyncCursorPage"]
+__all__ = [
+    "SyncPage",
+    "AsyncPage",
+    "SyncCursorPage",
+    "AsyncCursorPage",
+    "SyncConversationCursorPage",
+    "AsyncConversationCursorPage",
+]
 
 _T = TypeVar("_T")
 
@@ -123,3 +130,61 @@ def next_page_info(self) -> Optional[PageInfo]:
             return None
 
         return PageInfo(params={"after": item.id})
+
+
+class SyncConversationCursorPage(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    data: List[_T]
+    has_more: Optional[bool] = None
+    last_id: Optional[str] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        data = self.data
+        if not data:
+            return []
+        return data
+
+    @override
+    def has_next_page(self) -> bool:
+        has_more = self.has_more
+        if has_more is not None and has_more is False:
+            return False
+
+        return super().has_next_page()
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        last_id = self.last_id
+        if not last_id:
+            return None
+
+        return PageInfo(params={"after": last_id})
+
+
+class AsyncConversationCursorPage(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    data: List[_T]
+    has_more: Optional[bool] = None
+    last_id: Optional[str] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        data = self.data
+        if not data:
+            return []
+        return data
+
+    @override
+    def has_next_page(self) -> bool:
+        has_more = self.has_more
+        if has_more is not None and has_more is False:
+            return False
+
+        return super().has_next_page()
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        last_id = self.last_id
+        if not last_id:
+            return None
+
+        return PageInfo(params={"after": last_id})
diff --git a/src/openai/resources/__init__.py b/src/openai/resources/__init__.py
index d3457cf319..b793fbc7b0 100644
--- a/src/openai/resources/__init__.py
+++ b/src/openai/resources/__init__.py
@@ -24,6 +24,14 @@
     AudioWithStreamingResponse,
     AsyncAudioWithStreamingResponse,
 )
+from .evals import (
+    Evals,
+    AsyncEvals,
+    EvalsWithRawResponse,
+    AsyncEvalsWithRawResponse,
+    EvalsWithStreamingResponse,
+    AsyncEvalsWithStreamingResponse,
+)
 from .files import (
     Files,
     AsyncFiles,
@@ -48,6 +56,14 @@
     ModelsWithStreamingResponse,
     AsyncModelsWithStreamingResponse,
 )
+from .videos import (
+    Videos,
+    AsyncVideos,
+    VideosWithRawResponse,
+    AsyncVideosWithRawResponse,
+    VideosWithStreamingResponse,
+    AsyncVideosWithStreamingResponse,
+)
 from .batches import (
     Batches,
     AsyncBatches,
@@ -64,13 +80,13 @@
     UploadsWithStreamingResponse,
     AsyncUploadsWithStreamingResponse,
 )
-from .responses import (
-    Responses,
-    AsyncResponses,
-    ResponsesWithRawResponse,
-    AsyncResponsesWithRawResponse,
-    ResponsesWithStreamingResponse,
-    AsyncResponsesWithStreamingResponse,
+from .containers import (
+    Containers,
+    AsyncContainers,
+    ContainersWithRawResponse,
+    AsyncContainersWithRawResponse,
+    ContainersWithStreamingResponse,
+    AsyncContainersWithStreamingResponse,
 )
 from .embeddings import (
     Embeddings,
@@ -192,10 +208,22 @@
     "AsyncUploadsWithRawResponse",
     "UploadsWithStreamingResponse",
     "AsyncUploadsWithStreamingResponse",
-    "Responses",
-    "AsyncResponses",
-    "ResponsesWithRawResponse",
-    "AsyncResponsesWithRawResponse",
-    "ResponsesWithStreamingResponse",
-    "AsyncResponsesWithStreamingResponse",
+    "Evals",
+    "AsyncEvals",
+    "EvalsWithRawResponse",
+    "AsyncEvalsWithRawResponse",
+    "EvalsWithStreamingResponse",
+    "AsyncEvalsWithStreamingResponse",
+    "Containers",
+    "AsyncContainers",
+    "ContainersWithRawResponse",
+    "AsyncContainersWithRawResponse",
+    "ContainersWithStreamingResponse",
+    "AsyncContainersWithStreamingResponse",
+    "Videos",
+    "AsyncVideos",
+    "VideosWithRawResponse",
+    "AsyncVideosWithRawResponse",
+    "VideosWithStreamingResponse",
+    "AsyncVideosWithStreamingResponse",
 ]
diff --git a/src/openai/resources/audio/speech.py b/src/openai/resources/audio/speech.py
index ad01118161..992fb5971a 100644
--- a/src/openai/resources/audio/speech.py
+++ b/src/openai/resources/audio/speech.py
@@ -8,11 +8,8 @@
 import httpx
 
 from ... import _legacy_response
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ..._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -53,15 +50,19 @@ def create(
         *,
         input: str,
         model: Union[str, SpeechModel],
-        voice: Literal["alloy", "ash", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer"],
-        response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"] | NotGiven = NOT_GIVEN,
-        speed: float | NotGiven = NOT_GIVEN,
+        voice: Union[
+            str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"]
+        ],
+        instructions: str | Omit = omit,
+        response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"] | Omit = omit,
+        speed: float | Omit = omit,
+        stream_format: Literal["sse", "audio"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> _legacy_response.HttpxBinaryResponseContent:
         """
         Generates audio from the input text.
@@ -71,19 +72,25 @@ def create(
 
           model:
               One of the available [TTS models](https://platform.openai.com/docs/models#tts):
-              `tts-1` or `tts-1-hd`
+              `tts-1`, `tts-1-hd` or `gpt-4o-mini-tts`.
 
           voice: The voice to use when generating the audio. Supported voices are `alloy`, `ash`,
-              `coral`, `echo`, `fable`, `onyx`, `nova`, `sage` and `shimmer`. Previews of the
-              voices are available in the
+              `ballad`, `coral`, `echo`, `fable`, `onyx`, `nova`, `sage`, `shimmer`, and
+              `verse`. Previews of the voices are available in the
               [Text to speech guide](https://platform.openai.com/docs/guides/text-to-speech#voice-options).
 
+          instructions: Control the voice of your generated audio with additional instructions. Does not
+              work with `tts-1` or `tts-1-hd`.
+
           response_format: The format to audio in. Supported formats are `mp3`, `opus`, `aac`, `flac`,
               `wav`, and `pcm`.
 
           speed: The speed of the generated audio. Select a value from `0.25` to `4.0`. `1.0` is
               the default.
 
+          stream_format: The format to stream the audio in. Supported formats are `sse` and `audio`.
+              `sse` is not supported for `tts-1` or `tts-1-hd`.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -100,8 +107,10 @@ def create(
                     "input": input,
                     "model": model,
                     "voice": voice,
+                    "instructions": instructions,
                     "response_format": response_format,
                     "speed": speed,
+                    "stream_format": stream_format,
                 },
                 speech_create_params.SpeechCreateParams,
             ),
@@ -137,15 +146,19 @@ async def create(
         *,
         input: str,
         model: Union[str, SpeechModel],
-        voice: Literal["alloy", "ash", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer"],
-        response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"] | NotGiven = NOT_GIVEN,
-        speed: float | NotGiven = NOT_GIVEN,
+        voice: Union[
+            str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"]
+        ],
+        instructions: str | Omit = omit,
+        response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"] | Omit = omit,
+        speed: float | Omit = omit,
+        stream_format: Literal["sse", "audio"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> _legacy_response.HttpxBinaryResponseContent:
         """
         Generates audio from the input text.
@@ -155,19 +168,25 @@ async def create(
 
           model:
               One of the available [TTS models](https://platform.openai.com/docs/models#tts):
-              `tts-1` or `tts-1-hd`
+              `tts-1`, `tts-1-hd` or `gpt-4o-mini-tts`.
 
           voice: The voice to use when generating the audio. Supported voices are `alloy`, `ash`,
-              `coral`, `echo`, `fable`, `onyx`, `nova`, `sage` and `shimmer`. Previews of the
-              voices are available in the
+              `ballad`, `coral`, `echo`, `fable`, `onyx`, `nova`, `sage`, `shimmer`, and
+              `verse`. Previews of the voices are available in the
               [Text to speech guide](https://platform.openai.com/docs/guides/text-to-speech#voice-options).
 
+          instructions: Control the voice of your generated audio with additional instructions. Does not
+              work with `tts-1` or `tts-1-hd`.
+
           response_format: The format to audio in. Supported formats are `mp3`, `opus`, `aac`, `flac`,
               `wav`, and `pcm`.
 
           speed: The speed of the generated audio. Select a value from `0.25` to `4.0`. `1.0` is
               the default.
 
+          stream_format: The format to stream the audio in. Supported formats are `sse` and `audio`.
+              `sse` is not supported for `tts-1` or `tts-1-hd`.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -184,8 +203,10 @@ async def create(
                     "input": input,
                     "model": model,
                     "voice": voice,
+                    "instructions": instructions,
                     "response_format": response_format,
                     "speed": speed,
+                    "stream_format": stream_format,
                 },
                 speech_create_params.SpeechCreateParams,
             ),
diff --git a/src/openai/resources/audio/transcriptions.py b/src/openai/resources/audio/transcriptions.py
index f338ad067d..a5c86146d4 100644
--- a/src/openai/resources/audio/transcriptions.py
+++ b/src/openai/resources/audio/transcriptions.py
@@ -3,29 +3,38 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, List, Union, Mapping, cast
+from typing import TYPE_CHECKING, List, Union, Mapping, Optional, cast
 from typing_extensions import Literal, overload, assert_never
 
 import httpx
 
 from ... import _legacy_response
-from ...types import AudioResponseFormat
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from ..._utils import (
-    extract_files,
-    maybe_transform,
-    deepcopy_minimal,
-    async_maybe_transform,
+from ..._types import (
+    Body,
+    Omit,
+    Query,
+    Headers,
+    NotGiven,
+    FileTypes,
+    SequenceNotStr,
+    omit,
+    not_given,
 )
+from ..._utils import extract_files, required_args, maybe_transform, deepcopy_minimal, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ..._streaming import Stream, AsyncStream
 from ...types.audio import transcription_create_params
 from ..._base_client import make_request_options
 from ...types.audio_model import AudioModel
 from ...types.audio.transcription import Transcription
 from ...types.audio_response_format import AudioResponseFormat
+from ...types.audio.transcription_include import TranscriptionInclude
 from ...types.audio.transcription_verbose import TranscriptionVerbose
+from ...types.audio.transcription_diarized import TranscriptionDiarized
+from ...types.audio.transcription_stream_event import TranscriptionStreamEvent
+from ...types.audio.transcription_create_response import TranscriptionCreateResponse
 
 __all__ = ["Transcriptions", "AsyncTranscriptions"]
 
@@ -58,18 +67,82 @@ def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        response_format: Union[Literal["json"], NotGiven] = NOT_GIVEN,
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[Literal["json"], Omit] = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Transcription: ...
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Transcription:
+        """
+        Transcribes audio into the input language.
+
+        Args:
+          file:
+              The audio file object (not file name) to transcribe, in one of these formats:
+              flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+
+          model: ID of the model to use. The options are `gpt-4o-transcribe`,
+              `gpt-4o-mini-transcribe`, and `whisper-1` (which is powered by our open source
+              Whisper V2 model).
+
+          chunking_strategy: Controls how the audio is cut into chunks. When set to `"auto"`, the server
+              first normalizes loudness and then uses voice activity detection (VAD) to choose
+              boundaries. `server_vad` object can be provided to tweak VAD detection
+              parameters manually. If unset, the audio is transcribed as a single block.
+
+          include: Additional information to include in the transcription response. `logprobs` will
+              return the log probabilities of the tokens in the response to understand the
+              model's confidence in the transcription. `logprobs` only works with
+              response_format set to `json` and only with the models `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`.
+
+          language: The language of the input audio. Supplying the input language in
+              [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+              format will improve accuracy and latency.
+
+          prompt: An optional text to guide the model's style or continue a previous audio
+              segment. The
+              [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
+              should match the audio language.
+
+          response_format: The format of the output, in one of these options: `json`, `text`, `srt`,
+              `verbose_json`, or `vtt`. For `gpt-4o-transcribe` and `gpt-4o-mini-transcribe`,
+              the only supported format is `json`.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+              for more information.
+
+              Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+
+          temperature: The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
+              output more random, while lower values like 0.2 will make it more focused and
+              deterministic. If set to 0, the model will use
+              [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+              automatically increase the temperature until certain thresholds are hit.
+
+          timestamp_granularities: The timestamp granularities to populate for this transcription.
+              `response_format` must be set `verbose_json` to use timestamp granularities.
+              Either or both of these options are supported: `word`, or `segment`. Note: There
+              is no additional latency for segment timestamps, but generating word timestamps
+              incurs additional latency.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+        """
 
     @overload
     def create(
@@ -77,17 +150,19 @@ def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
         response_format: Literal["verbose_json"],
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> TranscriptionVerbose: ...
 
     @overload
@@ -96,36 +171,65 @@ def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
         response_format: Literal["text", "srt", "vtt"],
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        include: List[TranscriptionInclude] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> str: ...
 
+    @overload
     def create(
         self,
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        response_format: Union[AudioResponseFormat, NotGiven] = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        response_format: Literal["diarized_json"],
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Transcription | TranscriptionVerbose | str:
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> TranscriptionDiarized: ...
+
+    @overload
+    def create(
+        self,
+        *,
+        file: FileTypes,
+        model: Union[str, AudioModel],
+        stream: Literal[True],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[AudioResponseFormat, Omit] = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Stream[TranscriptionStreamEvent]:
         """
         Transcribes audio into the input language.
 
@@ -134,8 +238,42 @@ def create(
               The audio file object (not file name) to transcribe, in one of these formats:
               flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
 
-          model: ID of the model to use. Only `whisper-1` (which is powered by our open source
-              Whisper V2 model) is currently available.
+          model: ID of the model to use. The options are `gpt-4o-transcribe`,
+              `gpt-4o-mini-transcribe`, `whisper-1` (which is powered by our open source
+              Whisper V2 model), and `gpt-4o-transcribe-diarize`.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+              for more information.
+
+              Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+
+          chunking_strategy: Controls how the audio is cut into chunks. When set to `"auto"`, the server
+              first normalizes loudness and then uses voice activity detection (VAD) to choose
+              boundaries. `server_vad` object can be provided to tweak VAD detection
+              parameters manually. If unset, the audio is transcribed as a single block.
+              Required when using `gpt-4o-transcribe-diarize` for inputs longer than 30
+              seconds.
+
+          include: Additional information to include in the transcription response. `logprobs` will
+              return the log probabilities of the tokens in the response to understand the
+              model's confidence in the transcription. `logprobs` only works with
+              response_format set to `json` and only with the models `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          known_speaker_names: Optional list of speaker names that correspond to the audio samples provided in
+              `known_speaker_references[]`. Each entry should be a short identifier (for
+              example `customer` or `agent`). Up to 4 speakers are supported.
+
+          known_speaker_references: Optional list of audio samples (as
+              [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs))
+              that contain known speaker references matching `known_speaker_names[]`. Each
+              sample must be between 2 and 10 seconds, and can use any of the same input audio
+              formats supported by `file`.
 
           language: The language of the input audio. Supplying the input language in
               [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
@@ -144,10 +282,14 @@ def create(
           prompt: An optional text to guide the model's style or continue a previous audio
               segment. The
               [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-              should match the audio language.
+              should match the audio language. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
 
           response_format: The format of the output, in one of these options: `json`, `text`, `srt`,
-              `verbose_json`, or `vtt`.
+              `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+              `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+              `diarized_json`, with `diarized_json` required to receive speaker annotations.
 
           temperature: The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
               output more random, while lower values like 0.2 will make it more focused and
@@ -159,7 +301,8 @@ def create(
               `response_format` must be set `verbose_json` to use timestamp granularities.
               Either or both of these options are supported: `word`, or `segment`. Note: There
               is no additional latency for segment timestamps, but generating word timestamps
-              incurs additional latency.
+              incurs additional latency. This option is not available for
+              `gpt-4o-transcribe-diarize`.
 
           extra_headers: Send extra headers
 
@@ -169,13 +312,150 @@ def create(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @overload
+    def create(
+        self,
+        *,
+        file: FileTypes,
+        model: Union[str, AudioModel],
+        stream: bool,
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[AudioResponseFormat, Omit] = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> TranscriptionCreateResponse | Stream[TranscriptionStreamEvent]:
+        """
+        Transcribes audio into the input language.
+
+        Args:
+          file:
+              The audio file object (not file name) to transcribe, in one of these formats:
+              flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+
+          model: ID of the model to use. The options are `gpt-4o-transcribe`,
+              `gpt-4o-mini-transcribe`, `whisper-1` (which is powered by our open source
+              Whisper V2 model), and `gpt-4o-transcribe-diarize`.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+              for more information.
+
+              Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+
+          chunking_strategy: Controls how the audio is cut into chunks. When set to `"auto"`, the server
+              first normalizes loudness and then uses voice activity detection (VAD) to choose
+              boundaries. `server_vad` object can be provided to tweak VAD detection
+              parameters manually. If unset, the audio is transcribed as a single block.
+              Required when using `gpt-4o-transcribe-diarize` for inputs longer than 30
+              seconds.
+
+          include: Additional information to include in the transcription response. `logprobs` will
+              return the log probabilities of the tokens in the response to understand the
+              model's confidence in the transcription. `logprobs` only works with
+              response_format set to `json` and only with the models `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          known_speaker_names: Optional list of speaker names that correspond to the audio samples provided in
+              `known_speaker_references[]`. Each entry should be a short identifier (for
+              example `customer` or `agent`). Up to 4 speakers are supported.
+
+          known_speaker_references: Optional list of audio samples (as
+              [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs))
+              that contain known speaker references matching `known_speaker_names[]`. Each
+              sample must be between 2 and 10 seconds, and can use any of the same input audio
+              formats supported by `file`.
+
+          language: The language of the input audio. Supplying the input language in
+              [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+              format will improve accuracy and latency.
+
+          prompt: An optional text to guide the model's style or continue a previous audio
+              segment. The
+              [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
+              should match the audio language. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          response_format: The format of the output, in one of these options: `json`, `text`, `srt`,
+              `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+              `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+              `diarized_json`, with `diarized_json` required to receive speaker annotations.
+
+          temperature: The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
+              output more random, while lower values like 0.2 will make it more focused and
+              deterministic. If set to 0, the model will use
+              [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+              automatically increase the temperature until certain thresholds are hit.
+
+          timestamp_granularities: The timestamp granularities to populate for this transcription.
+              `response_format` must be set `verbose_json` to use timestamp granularities.
+              Either or both of these options are supported: `word`, or `segment`. Note: There
+              is no additional latency for segment timestamps, but generating word timestamps
+              incurs additional latency. This option is not available for
+              `gpt-4o-transcribe-diarize`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["file", "model"], ["file", "model", "stream"])
+    def create(
+        self,
+        *,
+        file: FileTypes,
+        model: Union[str, AudioModel],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[AudioResponseFormat, Omit] = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> str | Transcription | TranscriptionDiarized | TranscriptionVerbose | Stream[TranscriptionStreamEvent]:
         body = deepcopy_minimal(
             {
                 "file": file,
                 "model": model,
+                "chunking_strategy": chunking_strategy,
+                "include": include,
+                "known_speaker_names": known_speaker_names,
+                "known_speaker_references": known_speaker_references,
                 "language": language,
                 "prompt": prompt,
                 "response_format": response_format,
+                "stream": stream,
                 "temperature": temperature,
                 "timestamp_granularities": timestamp_granularities,
             }
@@ -187,12 +467,19 @@ def create(
         extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
         return self._post(  # type: ignore[return-value]
             "/audio/transcriptions",
-            body=maybe_transform(body, transcription_create_params.TranscriptionCreateParams),
+            body=maybe_transform(
+                body,
+                transcription_create_params.TranscriptionCreateParamsStreaming
+                if stream
+                else transcription_create_params.TranscriptionCreateParamsNonStreaming,
+            ),
             files=files,
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=_get_response_format_type(response_format),
+            stream=stream or False,
+            stream_cls=Stream[TranscriptionStreamEvent],
         )
 
 
@@ -222,18 +509,101 @@ async def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        response_format: Union[Literal["json"], NotGiven] = NOT_GIVEN,
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[Literal["json"], Omit] = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Transcription: ...
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> TranscriptionCreateResponse:
+        """
+        Transcribes audio into the input language.
+
+        Args:
+          file:
+              The audio file object (not file name) to transcribe, in one of these formats:
+              flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+
+          model: ID of the model to use. The options are `gpt-4o-transcribe`,
+              `gpt-4o-mini-transcribe`, `whisper-1` (which is powered by our open source
+              Whisper V2 model), and `gpt-4o-transcribe-diarize`.
+
+          chunking_strategy: Controls how the audio is cut into chunks. When set to `"auto"`, the server
+              first normalizes loudness and then uses voice activity detection (VAD) to choose
+              boundaries. `server_vad` object can be provided to tweak VAD detection
+              parameters manually. If unset, the audio is transcribed as a single block.
+              Required when using `gpt-4o-transcribe-diarize` for inputs longer than 30
+              seconds.
+
+          include: Additional information to include in the transcription response. `logprobs` will
+              return the log probabilities of the tokens in the response to understand the
+              model's confidence in the transcription. `logprobs` only works with
+              response_format set to `json` and only with the models `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          known_speaker_names: Optional list of speaker names that correspond to the audio samples provided in
+              `known_speaker_references[]`. Each entry should be a short identifier (for
+              example `customer` or `agent`). Up to 4 speakers are supported.
+
+          known_speaker_references: Optional list of audio samples (as
+              [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs))
+              that contain known speaker references matching `known_speaker_names[]`. Each
+              sample must be between 2 and 10 seconds, and can use any of the same input audio
+              formats supported by `file`.
+
+          language: The language of the input audio. Supplying the input language in
+              [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+              format will improve accuracy and latency.
+
+          prompt: An optional text to guide the model's style or continue a previous audio
+              segment. The
+              [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
+              should match the audio language. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          response_format: The format of the output, in one of these options: `json`, `text`, `srt`,
+              `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+              `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+              `diarized_json`, with `diarized_json` required to receive speaker annotations.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+              for more information.
+
+              Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+
+          temperature: The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
+              output more random, while lower values like 0.2 will make it more focused and
+              deterministic. If set to 0, the model will use
+              [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+              automatically increase the temperature until certain thresholds are hit.
+
+          timestamp_granularities: The timestamp granularities to populate for this transcription.
+              `response_format` must be set `verbose_json` to use timestamp granularities.
+              Either or both of these options are supported: `word`, or `segment`. Note: There
+              is no additional latency for segment timestamps, but generating word timestamps
+              incurs additional latency. This option is not available for
+              `gpt-4o-transcribe-diarize`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+        """
 
     @overload
     async def create(
@@ -241,17 +611,19 @@ async def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
         response_format: Literal["verbose_json"],
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> TranscriptionVerbose: ...
 
     @overload
@@ -260,36 +632,44 @@ async def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
         response_format: Literal["text", "srt", "vtt"],
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> str: ...
 
+    @overload
     async def create(
         self,
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        language: str | NotGiven = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        response_format: Union[AudioResponseFormat, NotGiven] = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
-        timestamp_granularities: List[Literal["word", "segment"]] | NotGiven = NOT_GIVEN,
+        stream: Literal[True],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[AudioResponseFormat, Omit] = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Transcription | TranscriptionVerbose | str:
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncStream[TranscriptionStreamEvent]:
         """
         Transcribes audio into the input language.
 
@@ -298,8 +678,42 @@ async def create(
               The audio file object (not file name) to transcribe, in one of these formats:
               flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
 
-          model: ID of the model to use. Only `whisper-1` (which is powered by our open source
-              Whisper V2 model) is currently available.
+          model: ID of the model to use. The options are `gpt-4o-transcribe`,
+              `gpt-4o-mini-transcribe`, `whisper-1` (which is powered by our open source
+              Whisper V2 model), and `gpt-4o-transcribe-diarize`.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+              for more information.
+
+              Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+
+          chunking_strategy: Controls how the audio is cut into chunks. When set to `"auto"`, the server
+              first normalizes loudness and then uses voice activity detection (VAD) to choose
+              boundaries. `server_vad` object can be provided to tweak VAD detection
+              parameters manually. If unset, the audio is transcribed as a single block.
+              Required when using `gpt-4o-transcribe-diarize` for inputs longer than 30
+              seconds.
+
+          include: Additional information to include in the transcription response. `logprobs` will
+              return the log probabilities of the tokens in the response to understand the
+              model's confidence in the transcription. `logprobs` only works with
+              response_format set to `json` and only with the models `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          known_speaker_names: Optional list of speaker names that correspond to the audio samples provided in
+              `known_speaker_references[]`. Each entry should be a short identifier (for
+              example `customer` or `agent`). Up to 4 speakers are supported.
+
+          known_speaker_references: Optional list of audio samples (as
+              [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs))
+              that contain known speaker references matching `known_speaker_names[]`. Each
+              sample must be between 2 and 10 seconds, and can use any of the same input audio
+              formats supported by `file`.
 
           language: The language of the input audio. Supplying the input language in
               [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
@@ -308,10 +722,14 @@ async def create(
           prompt: An optional text to guide the model's style or continue a previous audio
               segment. The
               [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-              should match the audio language.
+              should match the audio language. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
 
           response_format: The format of the output, in one of these options: `json`, `text`, `srt`,
-              `verbose_json`, or `vtt`.
+              `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+              `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+              `diarized_json`, with `diarized_json` required to receive speaker annotations.
 
           temperature: The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
               output more random, while lower values like 0.2 will make it more focused and
@@ -323,7 +741,8 @@ async def create(
               `response_format` must be set `verbose_json` to use timestamp granularities.
               Either or both of these options are supported: `word`, or `segment`. Note: There
               is no additional latency for segment timestamps, but generating word timestamps
-              incurs additional latency.
+              incurs additional latency. This option is not available for
+              `gpt-4o-transcribe-diarize`.
 
           extra_headers: Send extra headers
 
@@ -333,13 +752,150 @@ async def create(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @overload
+    async def create(
+        self,
+        *,
+        file: FileTypes,
+        model: Union[str, AudioModel],
+        stream: bool,
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[AudioResponseFormat, Omit] = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> TranscriptionCreateResponse | AsyncStream[TranscriptionStreamEvent]:
+        """
+        Transcribes audio into the input language.
+
+        Args:
+          file:
+              The audio file object (not file name) to transcribe, in one of these formats:
+              flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+
+          model: ID of the model to use. The options are `gpt-4o-transcribe`,
+              `gpt-4o-mini-transcribe`, `whisper-1` (which is powered by our open source
+              Whisper V2 model), and `gpt-4o-transcribe-diarize`.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+              for more information.
+
+              Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+
+          chunking_strategy: Controls how the audio is cut into chunks. When set to `"auto"`, the server
+              first normalizes loudness and then uses voice activity detection (VAD) to choose
+              boundaries. `server_vad` object can be provided to tweak VAD detection
+              parameters manually. If unset, the audio is transcribed as a single block.
+              Required when using `gpt-4o-transcribe-diarize` for inputs longer than 30
+              seconds.
+
+          include: Additional information to include in the transcription response. `logprobs` will
+              return the log probabilities of the tokens in the response to understand the
+              model's confidence in the transcription. `logprobs` only works with
+              response_format set to `json` and only with the models `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          known_speaker_names: Optional list of speaker names that correspond to the audio samples provided in
+              `known_speaker_references[]`. Each entry should be a short identifier (for
+              example `customer` or `agent`). Up to 4 speakers are supported.
+
+          known_speaker_references: Optional list of audio samples (as
+              [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs))
+              that contain known speaker references matching `known_speaker_names[]`. Each
+              sample must be between 2 and 10 seconds, and can use any of the same input audio
+              formats supported by `file`.
+
+          language: The language of the input audio. Supplying the input language in
+              [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+              format will improve accuracy and latency.
+
+          prompt: An optional text to guide the model's style or continue a previous audio
+              segment. The
+              [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
+              should match the audio language. This field is not supported when using
+              `gpt-4o-transcribe-diarize`.
+
+          response_format: The format of the output, in one of these options: `json`, `text`, `srt`,
+              `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+              `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+              `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+              `diarized_json`, with `diarized_json` required to receive speaker annotations.
+
+          temperature: The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
+              output more random, while lower values like 0.2 will make it more focused and
+              deterministic. If set to 0, the model will use
+              [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+              automatically increase the temperature until certain thresholds are hit.
+
+          timestamp_granularities: The timestamp granularities to populate for this transcription.
+              `response_format` must be set `verbose_json` to use timestamp granularities.
+              Either or both of these options are supported: `word`, or `segment`. Note: There
+              is no additional latency for segment timestamps, but generating word timestamps
+              incurs additional latency. This option is not available for
+              `gpt-4o-transcribe-diarize`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["file", "model"], ["file", "model", "stream"])
+    async def create(
+        self,
+        *,
+        file: FileTypes,
+        model: Union[str, AudioModel],
+        chunking_strategy: Optional[transcription_create_params.ChunkingStrategy] | Omit = omit,
+        include: List[TranscriptionInclude] | Omit = omit,
+        known_speaker_names: SequenceNotStr[str] | Omit = omit,
+        known_speaker_references: SequenceNotStr[str] | Omit = omit,
+        language: str | Omit = omit,
+        prompt: str | Omit = omit,
+        response_format: Union[AudioResponseFormat, Omit] = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        temperature: float | Omit = omit,
+        timestamp_granularities: List[Literal["word", "segment"]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Transcription | TranscriptionVerbose | TranscriptionDiarized | str | AsyncStream[TranscriptionStreamEvent]:
         body = deepcopy_minimal(
             {
                 "file": file,
                 "model": model,
+                "chunking_strategy": chunking_strategy,
+                "include": include,
+                "known_speaker_names": known_speaker_names,
+                "known_speaker_references": known_speaker_references,
                 "language": language,
                 "prompt": prompt,
                 "response_format": response_format,
+                "stream": stream,
                 "temperature": temperature,
                 "timestamp_granularities": timestamp_granularities,
             }
@@ -351,12 +907,19 @@ async def create(
         extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
         return await self._post(
             "/audio/transcriptions",
-            body=await async_maybe_transform(body, transcription_create_params.TranscriptionCreateParams),
+            body=await async_maybe_transform(
+                body,
+                transcription_create_params.TranscriptionCreateParamsStreaming
+                if stream
+                else transcription_create_params.TranscriptionCreateParamsNonStreaming,
+            ),
             files=files,
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=_get_response_format_type(response_format),
+            stream=stream or False,
+            stream_cls=AsyncStream[TranscriptionStreamEvent],
         )
 
 
@@ -397,15 +960,17 @@ def __init__(self, transcriptions: AsyncTranscriptions) -> None:
 
 
 def _get_response_format_type(
-    response_format: Literal["json", "text", "srt", "verbose_json", "vtt"] | NotGiven,
-) -> type[Transcription | TranscriptionVerbose | str]:
-    if isinstance(response_format, NotGiven) or response_format is None:  # pyright: ignore[reportUnnecessaryComparison]
+    response_format: AudioResponseFormat | Omit,
+) -> type[Transcription | TranscriptionVerbose | TranscriptionDiarized | str]:
+    if isinstance(response_format, Omit) or response_format is None:  # pyright: ignore[reportUnnecessaryComparison]
         return Transcription
 
     if response_format == "json":
         return Transcription
     elif response_format == "verbose_json":
         return TranscriptionVerbose
+    elif response_format == "diarized_json":
+        return TranscriptionDiarized
     elif response_format == "srt" or response_format == "text" or response_format == "vtt":
         return str
     elif TYPE_CHECKING:  # type: ignore[unreachable]
diff --git a/src/openai/resources/audio/translations.py b/src/openai/resources/audio/translations.py
index cd3132dc57..310f901fb3 100644
--- a/src/openai/resources/audio/translations.py
+++ b/src/openai/resources/audio/translations.py
@@ -9,14 +9,8 @@
 import httpx
 
 from ... import _legacy_response
-from ...types import AudioResponseFormat
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from ..._utils import (
-    extract_files,
-    maybe_transform,
-    deepcopy_minimal,
-    async_maybe_transform,
-)
+from ..._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
+from ..._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -58,15 +52,15 @@ def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        response_format: Union[Literal["json"], NotGiven] = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        response_format: Union[Literal["json"], Omit] = omit,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Translation: ...
 
     @overload
@@ -76,14 +70,14 @@ def create(
         file: FileTypes,
         model: Union[str, AudioModel],
         response_format: Literal["verbose_json"],
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> TranslationVerbose: ...
 
     @overload
@@ -93,14 +87,14 @@ def create(
         file: FileTypes,
         model: Union[str, AudioModel],
         response_format: Literal["text", "srt", "vtt"],
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> str: ...
 
     def create(
@@ -108,15 +102,15 @@ def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        prompt: str | NotGiven = NOT_GIVEN,
-        response_format: Union[AudioResponseFormat, NotGiven] = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        prompt: str | Omit = omit,
+        response_format: Union[Literal["json", "text", "srt", "verbose_json", "vtt"], Omit] = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Translation | TranslationVerbose | str:
         """
         Translates audio into English.
@@ -201,15 +195,15 @@ async def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        response_format: Union[Literal["json"], NotGiven] = NOT_GIVEN,
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        response_format: Union[Literal["json"], Omit] = omit,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Translation: ...
 
     @overload
@@ -219,14 +213,14 @@ async def create(
         file: FileTypes,
         model: Union[str, AudioModel],
         response_format: Literal["verbose_json"],
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> TranslationVerbose: ...
 
     @overload
@@ -236,14 +230,14 @@ async def create(
         file: FileTypes,
         model: Union[str, AudioModel],
         response_format: Literal["text", "srt", "vtt"],
-        prompt: str | NotGiven = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        prompt: str | Omit = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> str: ...
 
     async def create(
@@ -251,15 +245,15 @@ async def create(
         *,
         file: FileTypes,
         model: Union[str, AudioModel],
-        prompt: str | NotGiven = NOT_GIVEN,
-        response_format: Union[AudioResponseFormat, NotGiven] = NOT_GIVEN,
-        temperature: float | NotGiven = NOT_GIVEN,
+        prompt: str | Omit = omit,
+        response_format: Union[AudioResponseFormat, Omit] = omit,
+        temperature: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Translation | TranslationVerbose | str:
         """
         Translates audio into English.
@@ -355,9 +349,9 @@ def __init__(self, translations: AsyncTranslations) -> None:
 
 
 def _get_response_format_type(
-    response_format: Literal["json", "text", "srt", "verbose_json", "vtt"] | NotGiven,
+    response_format: AudioResponseFormat | Omit,
 ) -> type[Translation | TranslationVerbose | str]:
-    if isinstance(response_format, NotGiven) or response_format is None:  # pyright: ignore[reportUnnecessaryComparison]
+    if isinstance(response_format, Omit) or response_format is None:  # pyright: ignore[reportUnnecessaryComparison]
         return Translation
 
     if response_format == "json":
@@ -366,8 +360,8 @@ def _get_response_format_type(
         return TranslationVerbose
     elif response_format == "srt" or response_format == "text" or response_format == "vtt":
         return str
-    elif TYPE_CHECKING:  # type: ignore[unreachable]
+    elif TYPE_CHECKING and response_format != "diarized_json":  # type: ignore[unreachable]
         assert_never(response_format)
     else:
-        log.warn("Unexpected audio response format: %s", response_format)
-        return Transcription
+        log.warning("Unexpected audio response format: %s", response_format)
+        return Translation
diff --git a/src/openai/resources/batches.py b/src/openai/resources/batches.py
index 7e7ec19ec2..80400839e4 100644
--- a/src/openai/resources/batches.py
+++ b/src/openai/resources/batches.py
@@ -9,11 +9,8 @@
 
 from .. import _legacy_response
 from ..types import batch_list_params, batch_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -49,15 +46,18 @@ def create(
         self,
         *,
         completion_window: Literal["24h"],
-        endpoint: Literal["/v1/chat/completions", "/v1/embeddings", "/v1/completions"],
+        endpoint: Literal[
+            "/v1/responses", "/v1/chat/completions", "/v1/embeddings", "/v1/completions", "/v1/moderations"
+        ],
         input_file_id: str,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
+        output_expires_after: batch_create_params.OutputExpiresAfter | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Batch:
         """
         Creates and executes a batch from an uploaded file of requests
@@ -67,9 +67,10 @@ def create(
               is supported.
 
           endpoint: The endpoint to be used for all requests in the batch. Currently
-              `/v1/chat/completions`, `/v1/embeddings`, and `/v1/completions` are supported.
-              Note that `/v1/embeddings` batches are also restricted to a maximum of 50,000
-              embedding inputs across all requests in the batch.
+              `/v1/responses`, `/v1/chat/completions`, `/v1/embeddings`, `/v1/completions`,
+              and `/v1/moderations` are supported. Note that `/v1/embeddings` batches are also
+              restricted to a maximum of 50,000 embedding inputs across all requests in the
+              batch.
 
           input_file_id: The ID of an uploaded file that contains requests for the new batch.
 
@@ -88,6 +89,9 @@ def create(
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          output_expires_after: The expiration policy for the output and/or error file that are generated for a
+              batch.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -104,6 +108,7 @@ def create(
                     "endpoint": endpoint,
                     "input_file_id": input_file_id,
                     "metadata": metadata,
+                    "output_expires_after": output_expires_after,
                 },
                 batch_create_params.BatchCreateParams,
             ),
@@ -122,7 +127,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Batch:
         """
         Retrieves a batch.
@@ -149,14 +154,14 @@ def retrieve(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[Batch]:
         """List your organization's batches.
 
@@ -207,7 +212,7 @@ def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Batch:
         """Cancels an in-progress batch.
 
@@ -259,15 +264,18 @@ async def create(
         self,
         *,
         completion_window: Literal["24h"],
-        endpoint: Literal["/v1/chat/completions", "/v1/embeddings", "/v1/completions"],
+        endpoint: Literal[
+            "/v1/responses", "/v1/chat/completions", "/v1/embeddings", "/v1/completions", "/v1/moderations"
+        ],
         input_file_id: str,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
+        output_expires_after: batch_create_params.OutputExpiresAfter | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Batch:
         """
         Creates and executes a batch from an uploaded file of requests
@@ -277,9 +285,10 @@ async def create(
               is supported.
 
           endpoint: The endpoint to be used for all requests in the batch. Currently
-              `/v1/chat/completions`, `/v1/embeddings`, and `/v1/completions` are supported.
-              Note that `/v1/embeddings` batches are also restricted to a maximum of 50,000
-              embedding inputs across all requests in the batch.
+              `/v1/responses`, `/v1/chat/completions`, `/v1/embeddings`, `/v1/completions`,
+              and `/v1/moderations` are supported. Note that `/v1/embeddings` batches are also
+              restricted to a maximum of 50,000 embedding inputs across all requests in the
+              batch.
 
           input_file_id: The ID of an uploaded file that contains requests for the new batch.
 
@@ -298,6 +307,9 @@ async def create(
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          output_expires_after: The expiration policy for the output and/or error file that are generated for a
+              batch.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -314,6 +326,7 @@ async def create(
                     "endpoint": endpoint,
                     "input_file_id": input_file_id,
                     "metadata": metadata,
+                    "output_expires_after": output_expires_after,
                 },
                 batch_create_params.BatchCreateParams,
             ),
@@ -332,7 +345,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Batch:
         """
         Retrieves a batch.
@@ -359,14 +372,14 @@ async def retrieve(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[Batch, AsyncCursorPage[Batch]]:
         """List your organization's batches.
 
@@ -417,7 +430,7 @@ async def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Batch:
         """Cancels an in-progress batch.
 
diff --git a/src/openai/resources/beta/__init__.py b/src/openai/resources/beta/__init__.py
index 87fea25267..6d6f538670 100644
--- a/src/openai/resources/beta/__init__.py
+++ b/src/openai/resources/beta/__init__.py
@@ -8,6 +8,14 @@
     BetaWithStreamingResponse,
     AsyncBetaWithStreamingResponse,
 )
+from .chatkit import (
+    ChatKit,
+    AsyncChatKit,
+    ChatKitWithRawResponse,
+    AsyncChatKitWithRawResponse,
+    ChatKitWithStreamingResponse,
+    AsyncChatKitWithStreamingResponse,
+)
 from .threads import (
     Threads,
     AsyncThreads,
@@ -26,6 +34,12 @@
 )
 
 __all__ = [
+    "ChatKit",
+    "AsyncChatKit",
+    "ChatKitWithRawResponse",
+    "AsyncChatKitWithRawResponse",
+    "ChatKitWithStreamingResponse",
+    "AsyncChatKitWithStreamingResponse",
     "Assistants",
     "AsyncAssistants",
     "AssistantsWithRawResponse",
diff --git a/src/openai/resources/beta/assistants.py b/src/openai/resources/beta/assistants.py
index 1c7cbf3737..e4ec1dca11 100644
--- a/src/openai/resources/beta/assistants.py
+++ b/src/openai/resources/beta/assistants.py
@@ -8,11 +8,8 @@
 import httpx
 
 from ... import _legacy_response
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ..._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -58,22 +55,22 @@ def create(
         self,
         *,
         model: Union[str, ChatModel],
-        description: Optional[str] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        name: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[assistant_create_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Iterable[AssistantToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
+        description: Optional[str] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: Optional[str] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_resources: Optional[assistant_create_params.ToolResources] | Omit = omit,
+        tools: Iterable[AssistantToolParam] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Assistant:
         """
         Create an assistant with a model and instructions.
@@ -99,12 +96,18 @@ def create(
 
           name: The name of the assistant. The maximum length is 256 characters.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -188,7 +191,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Assistant:
         """
         Retrieves an assistant.
@@ -217,12 +220,24 @@ def update(
         self,
         assistant_id: str,
         *,
-        description: Optional[str] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        description: Optional[str] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
         model: Union[
             str,
             Literal[
+                "gpt-5",
+                "gpt-5-mini",
+                "gpt-5-nano",
+                "gpt-5-2025-08-07",
+                "gpt-5-mini-2025-08-07",
+                "gpt-5-nano-2025-08-07",
+                "gpt-4.1",
+                "gpt-4.1-mini",
+                "gpt-4.1-nano",
+                "gpt-4.1-2025-04-14",
+                "gpt-4.1-mini-2025-04-14",
+                "gpt-4.1-nano-2025-04-14",
                 "o3-mini",
                 "o3-mini-2025-01-31",
                 "o1",
@@ -255,20 +270,20 @@ def update(
                 "gpt-3.5-turbo-16k-0613",
             ],
         ]
-        | NotGiven = NOT_GIVEN,
-        name: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[assistant_update_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Iterable[AssistantToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
+        | Omit = omit,
+        name: Optional[str] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_resources: Optional[assistant_update_params.ToolResources] | Omit = omit,
+        tools: Iterable[AssistantToolParam] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Assistant:
         """Modifies an assistant.
 
@@ -295,12 +310,18 @@ def update(
 
           name: The name of the assistant. The maximum length is 256 characters.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -380,16 +401,16 @@ def update(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[Assistant]:
         """Returns a list of assistants.
 
@@ -451,7 +472,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AssistantDeleted:
         """
         Delete an assistant.
@@ -501,22 +522,22 @@ async def create(
         self,
         *,
         model: Union[str, ChatModel],
-        description: Optional[str] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        name: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[assistant_create_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Iterable[AssistantToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
+        description: Optional[str] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: Optional[str] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_resources: Optional[assistant_create_params.ToolResources] | Omit = omit,
+        tools: Iterable[AssistantToolParam] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Assistant:
         """
         Create an assistant with a model and instructions.
@@ -542,12 +563,18 @@ async def create(
 
           name: The name of the assistant. The maximum length is 256 characters.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -631,7 +658,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Assistant:
         """
         Retrieves an assistant.
@@ -660,12 +687,24 @@ async def update(
         self,
         assistant_id: str,
         *,
-        description: Optional[str] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        description: Optional[str] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
         model: Union[
             str,
             Literal[
+                "gpt-5",
+                "gpt-5-mini",
+                "gpt-5-nano",
+                "gpt-5-2025-08-07",
+                "gpt-5-mini-2025-08-07",
+                "gpt-5-nano-2025-08-07",
+                "gpt-4.1",
+                "gpt-4.1-mini",
+                "gpt-4.1-nano",
+                "gpt-4.1-2025-04-14",
+                "gpt-4.1-mini-2025-04-14",
+                "gpt-4.1-nano-2025-04-14",
                 "o3-mini",
                 "o3-mini-2025-01-31",
                 "o1",
@@ -698,20 +737,20 @@ async def update(
                 "gpt-3.5-turbo-16k-0613",
             ],
         ]
-        | NotGiven = NOT_GIVEN,
-        name: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[assistant_update_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Iterable[AssistantToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
+        | Omit = omit,
+        name: Optional[str] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_resources: Optional[assistant_update_params.ToolResources] | Omit = omit,
+        tools: Iterable[AssistantToolParam] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Assistant:
         """Modifies an assistant.
 
@@ -738,12 +777,18 @@ async def update(
 
           name: The name of the assistant. The maximum length is 256 characters.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -823,16 +868,16 @@ async def update(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[Assistant, AsyncCursorPage[Assistant]]:
         """Returns a list of assistants.
 
@@ -894,7 +939,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AssistantDeleted:
         """
         Delete an assistant.
diff --git a/src/openai/resources/beta/beta.py b/src/openai/resources/beta/beta.py
index 62fc8258b9..5ee3639db1 100644
--- a/src/openai/resources/beta/beta.py
+++ b/src/openai/resources/beta/beta.py
@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from ..._compat import cached_property
-from .chat.chat import Chat, AsyncChat
 from .assistants import (
     Assistants,
     AsyncAssistants,
@@ -13,6 +12,14 @@
     AsyncAssistantsWithStreamingResponse,
 )
 from ..._resource import SyncAPIResource, AsyncAPIResource
+from .chatkit.chatkit import (
+    ChatKit,
+    AsyncChatKit,
+    ChatKitWithRawResponse,
+    AsyncChatKitWithRawResponse,
+    ChatKitWithStreamingResponse,
+    AsyncChatKitWithStreamingResponse,
+)
 from .threads.threads import (
     Threads,
     AsyncThreads,
@@ -21,13 +28,10 @@
     ThreadsWithStreamingResponse,
     AsyncThreadsWithStreamingResponse,
 )
+from ...resources.chat import Chat, AsyncChat
 from .realtime.realtime import (
     Realtime,
     AsyncRealtime,
-    RealtimeWithRawResponse,
-    AsyncRealtimeWithRawResponse,
-    RealtimeWithStreamingResponse,
-    AsyncRealtimeWithStreamingResponse,
 )
 
 __all__ = ["Beta", "AsyncBeta"]
@@ -42,6 +46,10 @@ def chat(self) -> Chat:
     def realtime(self) -> Realtime:
         return Realtime(self._client)
 
+    @cached_property
+    def chatkit(self) -> ChatKit:
+        return ChatKit(self._client)
+
     @cached_property
     def assistants(self) -> Assistants:
         return Assistants(self._client)
@@ -79,6 +87,10 @@ def chat(self) -> AsyncChat:
     def realtime(self) -> AsyncRealtime:
         return AsyncRealtime(self._client)
 
+    @cached_property
+    def chatkit(self) -> AsyncChatKit:
+        return AsyncChatKit(self._client)
+
     @cached_property
     def assistants(self) -> AsyncAssistants:
         return AsyncAssistants(self._client)
@@ -112,8 +124,8 @@ def __init__(self, beta: Beta) -> None:
         self._beta = beta
 
     @cached_property
-    def realtime(self) -> RealtimeWithRawResponse:
-        return RealtimeWithRawResponse(self._beta.realtime)
+    def chatkit(self) -> ChatKitWithRawResponse:
+        return ChatKitWithRawResponse(self._beta.chatkit)
 
     @cached_property
     def assistants(self) -> AssistantsWithRawResponse:
@@ -129,8 +141,8 @@ def __init__(self, beta: AsyncBeta) -> None:
         self._beta = beta
 
     @cached_property
-    def realtime(self) -> AsyncRealtimeWithRawResponse:
-        return AsyncRealtimeWithRawResponse(self._beta.realtime)
+    def chatkit(self) -> AsyncChatKitWithRawResponse:
+        return AsyncChatKitWithRawResponse(self._beta.chatkit)
 
     @cached_property
     def assistants(self) -> AsyncAssistantsWithRawResponse:
@@ -146,8 +158,8 @@ def __init__(self, beta: Beta) -> None:
         self._beta = beta
 
     @cached_property
-    def realtime(self) -> RealtimeWithStreamingResponse:
-        return RealtimeWithStreamingResponse(self._beta.realtime)
+    def chatkit(self) -> ChatKitWithStreamingResponse:
+        return ChatKitWithStreamingResponse(self._beta.chatkit)
 
     @cached_property
     def assistants(self) -> AssistantsWithStreamingResponse:
@@ -163,8 +175,8 @@ def __init__(self, beta: AsyncBeta) -> None:
         self._beta = beta
 
     @cached_property
-    def realtime(self) -> AsyncRealtimeWithStreamingResponse:
-        return AsyncRealtimeWithStreamingResponse(self._beta.realtime)
+    def chatkit(self) -> AsyncChatKitWithStreamingResponse:
+        return AsyncChatKitWithStreamingResponse(self._beta.chatkit)
 
     @cached_property
     def assistants(self) -> AsyncAssistantsWithStreamingResponse:
diff --git a/src/openai/resources/beta/chat/__init__.py b/src/openai/resources/beta/chat/__init__.py
deleted file mode 100644
index 072d7867a5..0000000000
--- a/src/openai/resources/beta/chat/__init__.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from .chat import Chat, AsyncChat
-from .completions import Completions, AsyncCompletions
-
-__all__ = [
-    "Completions",
-    "AsyncCompletions",
-    "Chat",
-    "AsyncChat",
-]
diff --git a/src/openai/resources/beta/chat/chat.py b/src/openai/resources/beta/chat/chat.py
deleted file mode 100644
index 6afdcea381..0000000000
--- a/src/openai/resources/beta/chat/chat.py
+++ /dev/null
@@ -1,21 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from ...._compat import cached_property
-from .completions import Completions, AsyncCompletions
-from ...._resource import SyncAPIResource, AsyncAPIResource
-
-__all__ = ["Chat", "AsyncChat"]
-
-
-class Chat(SyncAPIResource):
-    @cached_property
-    def completions(self) -> Completions:
-        return Completions(self._client)
-
-
-class AsyncChat(AsyncAPIResource):
-    @cached_property
-    def completions(self) -> AsyncCompletions:
-        return AsyncCompletions(self._client)
diff --git a/src/openai/resources/beta/chat/completions.py b/src/openai/resources/beta/chat/completions.py
deleted file mode 100644
index 545a3f4087..0000000000
--- a/src/openai/resources/beta/chat/completions.py
+++ /dev/null
@@ -1,634 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing import Dict, List, Type, Union, Iterable, Optional, cast
-from functools import partial
-from typing_extensions import Literal
-
-import httpx
-
-from .... import _legacy_response
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ...._utils import maybe_transform, async_maybe_transform
-from ...._compat import cached_property
-from ...._resource import SyncAPIResource, AsyncAPIResource
-from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
-from ...._streaming import Stream
-from ....types.chat import completion_create_params
-from ...._base_client import make_request_options
-from ....lib._parsing import (
-    ResponseFormatT,
-    validate_input_tools as _validate_input_tools,
-    parse_chat_completion as _parse_chat_completion,
-    type_to_response_format_param as _type_to_response_format,
-)
-from ....types.chat_model import ChatModel
-from ....lib.streaming.chat import ChatCompletionStreamManager, AsyncChatCompletionStreamManager
-from ....types.shared_params import Metadata, ReasoningEffort
-from ....types.chat.chat_completion import ChatCompletion
-from ....types.chat.chat_completion_chunk import ChatCompletionChunk
-from ....types.chat.parsed_chat_completion import ParsedChatCompletion
-from ....types.chat.chat_completion_tool_param import ChatCompletionToolParam
-from ....types.chat.chat_completion_audio_param import ChatCompletionAudioParam
-from ....types.chat.chat_completion_message_param import ChatCompletionMessageParam
-from ....types.chat.chat_completion_stream_options_param import ChatCompletionStreamOptionsParam
-from ....types.chat.chat_completion_prediction_content_param import ChatCompletionPredictionContentParam
-from ....types.chat.chat_completion_tool_choice_option_param import ChatCompletionToolChoiceOptionParam
-
-__all__ = ["Completions", "AsyncCompletions"]
-
-
-class Completions(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> CompletionsWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
-        """
-        return CompletionsWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> CompletionsWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
-        """
-        return CompletionsWithStreamingResponse(self)
-
-    def parse(
-        self,
-        *,
-        messages: Iterable[ChatCompletionMessageParam],
-        model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        response_format: type[ResponseFormatT] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ParsedChatCompletion[ResponseFormatT]:
-        """Wrapper over the `client.chat.completions.create()` method that provides richer integrations with Python specific types
-        & returns a `ParsedChatCompletion` object, which is a subclass of the standard `ChatCompletion` class.
-
-        You can pass a pydantic model to this method and it will automatically convert the model
-        into a JSON schema, send it to the API and parse the response content back into the given model.
-
-        This method will also automatically parse `function` tool calls if:
-        - You use the `openai.pydantic_function_tool()` helper method
-        - You mark your tool schema with `"strict": True`
-
-        Example usage:
-        ```py
-        from pydantic import BaseModel
-        from openai import OpenAI
-
-
-        class Step(BaseModel):
-            explanation: str
-            output: str
-
-
-        class MathResponse(BaseModel):
-            steps: List[Step]
-            final_answer: str
-
-
-        client = OpenAI()
-        completion = client.beta.chat.completions.parse(
-            model="gpt-4o-2024-08-06",
-            messages=[
-                {"role": "system", "content": "You are a helpful math tutor."},
-                {"role": "user", "content": "solve 8x + 31 = 2"},
-            ],
-            response_format=MathResponse,
-        )
-
-        message = completion.choices[0].message
-        if message.parsed:
-            print(message.parsed.steps)
-            print("answer: ", message.parsed.final_answer)
-        ```
-        """
-        _validate_input_tools(tools)
-
-        extra_headers = {
-            "X-Stainless-Helper-Method": "beta.chat.completions.parse",
-            **(extra_headers or {}),
-        }
-
-        def parser(raw_completion: ChatCompletion) -> ParsedChatCompletion[ResponseFormatT]:
-            return _parse_chat_completion(
-                response_format=response_format,
-                chat_completion=raw_completion,
-                input_tools=tools,
-            )
-
-        return self._post(
-            "/chat/completions",
-            body=maybe_transform(
-                {
-                    "messages": messages,
-                    "model": model,
-                    "audio": audio,
-                    "frequency_penalty": frequency_penalty,
-                    "function_call": function_call,
-                    "functions": functions,
-                    "logit_bias": logit_bias,
-                    "logprobs": logprobs,
-                    "max_completion_tokens": max_completion_tokens,
-                    "max_tokens": max_tokens,
-                    "metadata": metadata,
-                    "modalities": modalities,
-                    "n": n,
-                    "parallel_tool_calls": parallel_tool_calls,
-                    "prediction": prediction,
-                    "presence_penalty": presence_penalty,
-                    "reasoning_effort": reasoning_effort,
-                    "response_format": _type_to_response_format(response_format),
-                    "seed": seed,
-                    "service_tier": service_tier,
-                    "stop": stop,
-                    "store": store,
-                    "stream": False,
-                    "stream_options": stream_options,
-                    "temperature": temperature,
-                    "tool_choice": tool_choice,
-                    "tools": tools,
-                    "top_logprobs": top_logprobs,
-                    "top_p": top_p,
-                    "user": user,
-                    "web_search_options": web_search_options,
-                },
-                completion_create_params.CompletionCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                post_parser=parser,
-            ),
-            # we turn the `ChatCompletion` instance into a `ParsedChatCompletion`
-            # in the `parser` function above
-            cast_to=cast(Type[ParsedChatCompletion[ResponseFormatT]], ChatCompletion),
-            stream=False,
-        )
-
-    def stream(
-        self,
-        *,
-        messages: Iterable[ChatCompletionMessageParam],
-        model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | type[ResponseFormatT] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ChatCompletionStreamManager[ResponseFormatT]:
-        """Wrapper over the `client.chat.completions.create(stream=True)` method that provides a more granular event API
-        and automatic accumulation of each delta.
-
-        This also supports all of the parsing utilities that `.parse()` does.
-
-        Unlike `.create(stream=True)`, the `.stream()` method requires usage within a context manager to prevent accidental leakage of the response:
-
-        ```py
-        with client.beta.chat.completions.stream(
-            model="gpt-4o-2024-08-06",
-            messages=[...],
-        ) as stream:
-            for event in stream:
-                if event.type == "content.delta":
-                    print(event.delta, flush=True, end="")
-        ```
-
-        When the context manager is entered, a `ChatCompletionStream` instance is returned which, like `.create(stream=True)` is an iterator. The full list of events that are yielded by the iterator are outlined in [these docs](https://github.com/openai/openai-python/blob/main/helpers.md#chat-completions-events).
-
-        When the context manager exits, the response will be closed, however the `stream` instance is still available outside
-        the context manager.
-        """
-        extra_headers = {
-            "X-Stainless-Helper-Method": "beta.chat.completions.stream",
-            **(extra_headers or {}),
-        }
-
-        api_request: partial[Stream[ChatCompletionChunk]] = partial(
-            self._client.chat.completions.create,
-            messages=messages,
-            model=model,
-            audio=audio,
-            stream=True,
-            response_format=_type_to_response_format(response_format),
-            frequency_penalty=frequency_penalty,
-            function_call=function_call,
-            functions=functions,
-            logit_bias=logit_bias,
-            logprobs=logprobs,
-            max_completion_tokens=max_completion_tokens,
-            max_tokens=max_tokens,
-            metadata=metadata,
-            modalities=modalities,
-            n=n,
-            parallel_tool_calls=parallel_tool_calls,
-            prediction=prediction,
-            presence_penalty=presence_penalty,
-            reasoning_effort=reasoning_effort,
-            seed=seed,
-            service_tier=service_tier,
-            store=store,
-            stop=stop,
-            stream_options=stream_options,
-            temperature=temperature,
-            tool_choice=tool_choice,
-            tools=tools,
-            top_logprobs=top_logprobs,
-            top_p=top_p,
-            user=user,
-            web_search_options=web_search_options,
-            extra_headers=extra_headers,
-            extra_query=extra_query,
-            extra_body=extra_body,
-            timeout=timeout,
-        )
-        return ChatCompletionStreamManager(
-            api_request,
-            response_format=response_format,
-            input_tools=tools,
-        )
-
-
-class AsyncCompletions(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncCompletionsWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return the
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncCompletionsWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncCompletionsWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
-        """
-        return AsyncCompletionsWithStreamingResponse(self)
-
-    async def parse(
-        self,
-        *,
-        messages: Iterable[ChatCompletionMessageParam],
-        model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        response_format: type[ResponseFormatT] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ParsedChatCompletion[ResponseFormatT]:
-        """Wrapper over the `client.chat.completions.create()` method that provides richer integrations with Python specific types
-        & returns a `ParsedChatCompletion` object, which is a subclass of the standard `ChatCompletion` class.
-
-        You can pass a pydantic model to this method and it will automatically convert the model
-        into a JSON schema, send it to the API and parse the response content back into the given model.
-
-        This method will also automatically parse `function` tool calls if:
-        - You use the `openai.pydantic_function_tool()` helper method
-        - You mark your tool schema with `"strict": True`
-
-        Example usage:
-        ```py
-        from pydantic import BaseModel
-        from openai import AsyncOpenAI
-
-
-        class Step(BaseModel):
-            explanation: str
-            output: str
-
-
-        class MathResponse(BaseModel):
-            steps: List[Step]
-            final_answer: str
-
-
-        client = AsyncOpenAI()
-        completion = await client.beta.chat.completions.parse(
-            model="gpt-4o-2024-08-06",
-            messages=[
-                {"role": "system", "content": "You are a helpful math tutor."},
-                {"role": "user", "content": "solve 8x + 31 = 2"},
-            ],
-            response_format=MathResponse,
-        )
-
-        message = completion.choices[0].message
-        if message.parsed:
-            print(message.parsed.steps)
-            print("answer: ", message.parsed.final_answer)
-        ```
-        """
-        _validate_input_tools(tools)
-
-        extra_headers = {
-            "X-Stainless-Helper-Method": "beta.chat.completions.parse",
-            **(extra_headers or {}),
-        }
-
-        def parser(raw_completion: ChatCompletion) -> ParsedChatCompletion[ResponseFormatT]:
-            return _parse_chat_completion(
-                response_format=response_format,
-                chat_completion=raw_completion,
-                input_tools=tools,
-            )
-
-        return await self._post(
-            "/chat/completions",
-            body=await async_maybe_transform(
-                {
-                    "messages": messages,
-                    "model": model,
-                    "audio": audio,
-                    "frequency_penalty": frequency_penalty,
-                    "function_call": function_call,
-                    "functions": functions,
-                    "logit_bias": logit_bias,
-                    "logprobs": logprobs,
-                    "max_completion_tokens": max_completion_tokens,
-                    "max_tokens": max_tokens,
-                    "metadata": metadata,
-                    "modalities": modalities,
-                    "n": n,
-                    "parallel_tool_calls": parallel_tool_calls,
-                    "prediction": prediction,
-                    "presence_penalty": presence_penalty,
-                    "reasoning_effort": reasoning_effort,
-                    "response_format": _type_to_response_format(response_format),
-                    "seed": seed,
-                    "service_tier": service_tier,
-                    "store": store,
-                    "stop": stop,
-                    "stream": False,
-                    "stream_options": stream_options,
-                    "temperature": temperature,
-                    "tool_choice": tool_choice,
-                    "tools": tools,
-                    "top_logprobs": top_logprobs,
-                    "top_p": top_p,
-                    "user": user,
-                    "web_search_options": web_search_options,
-                },
-                completion_create_params.CompletionCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                post_parser=parser,
-            ),
-            # we turn the `ChatCompletion` instance into a `ParsedChatCompletion`
-            # in the `parser` function above
-            cast_to=cast(Type[ParsedChatCompletion[ResponseFormatT]], ChatCompletion),
-            stream=False,
-        )
-
-    def stream(
-        self,
-        *,
-        messages: Iterable[ChatCompletionMessageParam],
-        model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | type[ResponseFormatT] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> AsyncChatCompletionStreamManager[ResponseFormatT]:
-        """Wrapper over the `client.chat.completions.create(stream=True)` method that provides a more granular event API
-        and automatic accumulation of each delta.
-
-        This also supports all of the parsing utilities that `.parse()` does.
-
-        Unlike `.create(stream=True)`, the `.stream()` method requires usage within a context manager to prevent accidental leakage of the response:
-
-        ```py
-        async with client.beta.chat.completions.stream(
-            model="gpt-4o-2024-08-06",
-            messages=[...],
-        ) as stream:
-            async for event in stream:
-                if event.type == "content.delta":
-                    print(event.delta, flush=True, end="")
-        ```
-
-        When the context manager is entered, an `AsyncChatCompletionStream` instance is returned which, like `.create(stream=True)` is an async iterator. The full list of events that are yielded by the iterator are outlined in [these docs](https://github.com/openai/openai-python/blob/main/helpers.md#chat-completions-events).
-
-        When the context manager exits, the response will be closed, however the `stream` instance is still available outside
-        the context manager.
-        """
-        _validate_input_tools(tools)
-
-        extra_headers = {
-            "X-Stainless-Helper-Method": "beta.chat.completions.stream",
-            **(extra_headers or {}),
-        }
-
-        api_request = self._client.chat.completions.create(
-            messages=messages,
-            model=model,
-            audio=audio,
-            stream=True,
-            response_format=_type_to_response_format(response_format),
-            frequency_penalty=frequency_penalty,
-            function_call=function_call,
-            functions=functions,
-            logit_bias=logit_bias,
-            logprobs=logprobs,
-            max_completion_tokens=max_completion_tokens,
-            max_tokens=max_tokens,
-            metadata=metadata,
-            modalities=modalities,
-            n=n,
-            parallel_tool_calls=parallel_tool_calls,
-            prediction=prediction,
-            presence_penalty=presence_penalty,
-            reasoning_effort=reasoning_effort,
-            seed=seed,
-            service_tier=service_tier,
-            stop=stop,
-            store=store,
-            stream_options=stream_options,
-            temperature=temperature,
-            tool_choice=tool_choice,
-            tools=tools,
-            top_logprobs=top_logprobs,
-            top_p=top_p,
-            user=user,
-            extra_headers=extra_headers,
-            extra_query=extra_query,
-            extra_body=extra_body,
-            timeout=timeout,
-            web_search_options=web_search_options,
-        )
-        return AsyncChatCompletionStreamManager(
-            api_request,
-            response_format=response_format,
-            input_tools=tools,
-        )
-
-
-class CompletionsWithRawResponse:
-    def __init__(self, completions: Completions) -> None:
-        self._completions = completions
-
-        self.parse = _legacy_response.to_raw_response_wrapper(
-            completions.parse,
-        )
-
-
-class AsyncCompletionsWithRawResponse:
-    def __init__(self, completions: AsyncCompletions) -> None:
-        self._completions = completions
-
-        self.parse = _legacy_response.async_to_raw_response_wrapper(
-            completions.parse,
-        )
-
-
-class CompletionsWithStreamingResponse:
-    def __init__(self, completions: Completions) -> None:
-        self._completions = completions
-
-        self.parse = to_streamed_response_wrapper(
-            completions.parse,
-        )
-
-
-class AsyncCompletionsWithStreamingResponse:
-    def __init__(self, completions: AsyncCompletions) -> None:
-        self._completions = completions
-
-        self.parse = async_to_streamed_response_wrapper(
-            completions.parse,
-        )
diff --git a/src/openai/resources/beta/chatkit/__init__.py b/src/openai/resources/beta/chatkit/__init__.py
new file mode 100644
index 0000000000..05f24d6238
--- /dev/null
+++ b/src/openai/resources/beta/chatkit/__init__.py
@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .chatkit import (
+    ChatKit,
+    AsyncChatKit,
+    ChatKitWithRawResponse,
+    AsyncChatKitWithRawResponse,
+    ChatKitWithStreamingResponse,
+    AsyncChatKitWithStreamingResponse,
+)
+from .threads import (
+    Threads,
+    AsyncThreads,
+    ThreadsWithRawResponse,
+    AsyncThreadsWithRawResponse,
+    ThreadsWithStreamingResponse,
+    AsyncThreadsWithStreamingResponse,
+)
+from .sessions import (
+    Sessions,
+    AsyncSessions,
+    SessionsWithRawResponse,
+    AsyncSessionsWithRawResponse,
+    SessionsWithStreamingResponse,
+    AsyncSessionsWithStreamingResponse,
+)
+
+__all__ = [
+    "Sessions",
+    "AsyncSessions",
+    "SessionsWithRawResponse",
+    "AsyncSessionsWithRawResponse",
+    "SessionsWithStreamingResponse",
+    "AsyncSessionsWithStreamingResponse",
+    "Threads",
+    "AsyncThreads",
+    "ThreadsWithRawResponse",
+    "AsyncThreadsWithRawResponse",
+    "ThreadsWithStreamingResponse",
+    "AsyncThreadsWithStreamingResponse",
+    "ChatKit",
+    "AsyncChatKit",
+    "ChatKitWithRawResponse",
+    "AsyncChatKitWithRawResponse",
+    "ChatKitWithStreamingResponse",
+    "AsyncChatKitWithStreamingResponse",
+]
diff --git a/src/openai/resources/beta/chatkit/chatkit.py b/src/openai/resources/beta/chatkit/chatkit.py
new file mode 100644
index 0000000000..5a10a39c7b
--- /dev/null
+++ b/src/openai/resources/beta/chatkit/chatkit.py
@@ -0,0 +1,134 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .threads import (
+    Threads,
+    AsyncThreads,
+    ThreadsWithRawResponse,
+    AsyncThreadsWithRawResponse,
+    ThreadsWithStreamingResponse,
+    AsyncThreadsWithStreamingResponse,
+)
+from .sessions import (
+    Sessions,
+    AsyncSessions,
+    SessionsWithRawResponse,
+    AsyncSessionsWithRawResponse,
+    SessionsWithStreamingResponse,
+    AsyncSessionsWithStreamingResponse,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["ChatKit", "AsyncChatKit"]
+
+
+class ChatKit(SyncAPIResource):
+    @cached_property
+    def sessions(self) -> Sessions:
+        return Sessions(self._client)
+
+    @cached_property
+    def threads(self) -> Threads:
+        return Threads(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ChatKitWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return ChatKitWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ChatKitWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return ChatKitWithStreamingResponse(self)
+
+
+class AsyncChatKit(AsyncAPIResource):
+    @cached_property
+    def sessions(self) -> AsyncSessions:
+        return AsyncSessions(self._client)
+
+    @cached_property
+    def threads(self) -> AsyncThreads:
+        return AsyncThreads(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncChatKitWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncChatKitWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncChatKitWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncChatKitWithStreamingResponse(self)
+
+
+class ChatKitWithRawResponse:
+    def __init__(self, chatkit: ChatKit) -> None:
+        self._chatkit = chatkit
+
+    @cached_property
+    def sessions(self) -> SessionsWithRawResponse:
+        return SessionsWithRawResponse(self._chatkit.sessions)
+
+    @cached_property
+    def threads(self) -> ThreadsWithRawResponse:
+        return ThreadsWithRawResponse(self._chatkit.threads)
+
+
+class AsyncChatKitWithRawResponse:
+    def __init__(self, chatkit: AsyncChatKit) -> None:
+        self._chatkit = chatkit
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsWithRawResponse:
+        return AsyncSessionsWithRawResponse(self._chatkit.sessions)
+
+    @cached_property
+    def threads(self) -> AsyncThreadsWithRawResponse:
+        return AsyncThreadsWithRawResponse(self._chatkit.threads)
+
+
+class ChatKitWithStreamingResponse:
+    def __init__(self, chatkit: ChatKit) -> None:
+        self._chatkit = chatkit
+
+    @cached_property
+    def sessions(self) -> SessionsWithStreamingResponse:
+        return SessionsWithStreamingResponse(self._chatkit.sessions)
+
+    @cached_property
+    def threads(self) -> ThreadsWithStreamingResponse:
+        return ThreadsWithStreamingResponse(self._chatkit.threads)
+
+
+class AsyncChatKitWithStreamingResponse:
+    def __init__(self, chatkit: AsyncChatKit) -> None:
+        self._chatkit = chatkit
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsWithStreamingResponse:
+        return AsyncSessionsWithStreamingResponse(self._chatkit.sessions)
+
+    @cached_property
+    def threads(self) -> AsyncThreadsWithStreamingResponse:
+        return AsyncThreadsWithStreamingResponse(self._chatkit.threads)
diff --git a/src/openai/resources/beta/chatkit/sessions.py b/src/openai/resources/beta/chatkit/sessions.py
new file mode 100644
index 0000000000..a814f1058e
--- /dev/null
+++ b/src/openai/resources/beta/chatkit/sessions.py
@@ -0,0 +1,301 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...._base_client import make_request_options
+from ....types.beta.chatkit import (
+    ChatSessionWorkflowParam,
+    ChatSessionRateLimitsParam,
+    ChatSessionExpiresAfterParam,
+    ChatSessionChatKitConfigurationParam,
+    session_create_params,
+)
+from ....types.beta.chatkit.chat_session import ChatSession
+from ....types.beta.chatkit.chat_session_workflow_param import ChatSessionWorkflowParam
+from ....types.beta.chatkit.chat_session_rate_limits_param import ChatSessionRateLimitsParam
+from ....types.beta.chatkit.chat_session_expires_after_param import ChatSessionExpiresAfterParam
+from ....types.beta.chatkit.chat_session_chatkit_configuration_param import ChatSessionChatKitConfigurationParam
+
+__all__ = ["Sessions", "AsyncSessions"]
+
+
+class Sessions(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> SessionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return SessionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SessionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return SessionsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        user: str,
+        workflow: ChatSessionWorkflowParam,
+        chatkit_configuration: ChatSessionChatKitConfigurationParam | Omit = omit,
+        expires_after: ChatSessionExpiresAfterParam | Omit = omit,
+        rate_limits: ChatSessionRateLimitsParam | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ChatSession:
+        """
+        Create a ChatKit session
+
+        Args:
+          user: A free-form string that identifies your end user; ensures this Session can
+              access other objects that have the same `user` scope.
+
+          workflow: Workflow that powers the session.
+
+          chatkit_configuration: Optional overrides for ChatKit runtime configuration features
+
+          expires_after: Optional override for session expiration timing in seconds from creation.
+              Defaults to 10 minutes.
+
+          rate_limits: Optional override for per-minute request limits. When omitted, defaults to 10.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._post(
+            "/chatkit/sessions",
+            body=maybe_transform(
+                {
+                    "user": user,
+                    "workflow": workflow,
+                    "chatkit_configuration": chatkit_configuration,
+                    "expires_after": expires_after,
+                    "rate_limits": rate_limits,
+                },
+                session_create_params.SessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatSession,
+        )
+
+    def cancel(
+        self,
+        session_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ChatSession:
+        """
+        Cancel a ChatKit session
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._post(
+            f"/chatkit/sessions/{session_id}/cancel",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatSession,
+        )
+
+
+class AsyncSessions(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncSessionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSessionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSessionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncSessionsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        user: str,
+        workflow: ChatSessionWorkflowParam,
+        chatkit_configuration: ChatSessionChatKitConfigurationParam | Omit = omit,
+        expires_after: ChatSessionExpiresAfterParam | Omit = omit,
+        rate_limits: ChatSessionRateLimitsParam | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ChatSession:
+        """
+        Create a ChatKit session
+
+        Args:
+          user: A free-form string that identifies your end user; ensures this Session can
+              access other objects that have the same `user` scope.
+
+          workflow: Workflow that powers the session.
+
+          chatkit_configuration: Optional overrides for ChatKit runtime configuration features
+
+          expires_after: Optional override for session expiration timing in seconds from creation.
+              Defaults to 10 minutes.
+
+          rate_limits: Optional override for per-minute request limits. When omitted, defaults to 10.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return await self._post(
+            "/chatkit/sessions",
+            body=await async_maybe_transform(
+                {
+                    "user": user,
+                    "workflow": workflow,
+                    "chatkit_configuration": chatkit_configuration,
+                    "expires_after": expires_after,
+                    "rate_limits": rate_limits,
+                },
+                session_create_params.SessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatSession,
+        )
+
+    async def cancel(
+        self,
+        session_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ChatSession:
+        """
+        Cancel a ChatKit session
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return await self._post(
+            f"/chatkit/sessions/{session_id}/cancel",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatSession,
+        )
+
+
+class SessionsWithRawResponse:
+    def __init__(self, sessions: Sessions) -> None:
+        self._sessions = sessions
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            sessions.create,
+        )
+        self.cancel = _legacy_response.to_raw_response_wrapper(
+            sessions.cancel,
+        )
+
+
+class AsyncSessionsWithRawResponse:
+    def __init__(self, sessions: AsyncSessions) -> None:
+        self._sessions = sessions
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            sessions.create,
+        )
+        self.cancel = _legacy_response.async_to_raw_response_wrapper(
+            sessions.cancel,
+        )
+
+
+class SessionsWithStreamingResponse:
+    def __init__(self, sessions: Sessions) -> None:
+        self._sessions = sessions
+
+        self.create = to_streamed_response_wrapper(
+            sessions.create,
+        )
+        self.cancel = to_streamed_response_wrapper(
+            sessions.cancel,
+        )
+
+
+class AsyncSessionsWithStreamingResponse:
+    def __init__(self, sessions: AsyncSessions) -> None:
+        self._sessions = sessions
+
+        self.create = async_to_streamed_response_wrapper(
+            sessions.create,
+        )
+        self.cancel = async_to_streamed_response_wrapper(
+            sessions.cancel,
+        )
diff --git a/src/openai/resources/beta/chatkit/threads.py b/src/openai/resources/beta/chatkit/threads.py
new file mode 100644
index 0000000000..37cd57295a
--- /dev/null
+++ b/src/openai/resources/beta/chatkit/threads.py
@@ -0,0 +1,521 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Any, cast
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncConversationCursorPage, AsyncConversationCursorPage
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.beta.chatkit import thread_list_params, thread_list_items_params
+from ....types.beta.chatkit.chatkit_thread import ChatKitThread
+from ....types.beta.chatkit.thread_delete_response import ThreadDeleteResponse
+from ....types.beta.chatkit.chatkit_thread_item_list import Data
+
+__all__ = ["Threads", "AsyncThreads"]
+
+
+class Threads(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ThreadsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return ThreadsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ThreadsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return ThreadsWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        thread_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ChatKitThread:
+        """
+        Retrieve a ChatKit thread
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not thread_id:
+            raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._get(
+            f"/chatkit/threads/{thread_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatKitThread,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncConversationCursorPage[ChatKitThread]:
+        """
+        List ChatKit threads
+
+        Args:
+          after: List items created after this thread item ID. Defaults to null for the first
+              page.
+
+          before: List items created before this thread item ID. Defaults to null for the newest
+              results.
+
+          limit: Maximum number of thread items to return. Defaults to 20.
+
+          order: Sort order for results by creation time. Defaults to `desc`.
+
+          user: Filter threads that belong to this user identifier. Defaults to null to return
+              all users.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._get_api_list(
+            "/chatkit/threads",
+            page=SyncConversationCursorPage[ChatKitThread],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "before": before,
+                        "limit": limit,
+                        "order": order,
+                        "user": user,
+                    },
+                    thread_list_params.ThreadListParams,
+                ),
+            ),
+            model=ChatKitThread,
+        )
+
+    def delete(
+        self,
+        thread_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ThreadDeleteResponse:
+        """
+        Delete a ChatKit thread
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not thread_id:
+            raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._delete(
+            f"/chatkit/threads/{thread_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ThreadDeleteResponse,
+        )
+
+    def list_items(
+        self,
+        thread_id: str,
+        *,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncConversationCursorPage[Data]:
+        """
+        List ChatKit thread items
+
+        Args:
+          after: List items created after this thread item ID. Defaults to null for the first
+              page.
+
+          before: List items created before this thread item ID. Defaults to null for the newest
+              results.
+
+          limit: Maximum number of thread items to return. Defaults to 20.
+
+          order: Sort order for results by creation time. Defaults to `desc`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not thread_id:
+            raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._get_api_list(
+            f"/chatkit/threads/{thread_id}/items",
+            page=SyncConversationCursorPage[Data],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "before": before,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    thread_list_items_params.ThreadListItemsParams,
+                ),
+            ),
+            model=cast(Any, Data),  # Union types cannot be passed in as arguments in the type system
+        )
+
+
+class AsyncThreads(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncThreadsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncThreadsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncThreadsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncThreadsWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        thread_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ChatKitThread:
+        """
+        Retrieve a ChatKit thread
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not thread_id:
+            raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return await self._get(
+            f"/chatkit/threads/{thread_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ChatKitThread,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[ChatKitThread, AsyncConversationCursorPage[ChatKitThread]]:
+        """
+        List ChatKit threads
+
+        Args:
+          after: List items created after this thread item ID. Defaults to null for the first
+              page.
+
+          before: List items created before this thread item ID. Defaults to null for the newest
+              results.
+
+          limit: Maximum number of thread items to return. Defaults to 20.
+
+          order: Sort order for results by creation time. Defaults to `desc`.
+
+          user: Filter threads that belong to this user identifier. Defaults to null to return
+              all users.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._get_api_list(
+            "/chatkit/threads",
+            page=AsyncConversationCursorPage[ChatKitThread],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "before": before,
+                        "limit": limit,
+                        "order": order,
+                        "user": user,
+                    },
+                    thread_list_params.ThreadListParams,
+                ),
+            ),
+            model=ChatKitThread,
+        )
+
+    async def delete(
+        self,
+        thread_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ThreadDeleteResponse:
+        """
+        Delete a ChatKit thread
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not thread_id:
+            raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return await self._delete(
+            f"/chatkit/threads/{thread_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ThreadDeleteResponse,
+        )
+
+    def list_items(
+        self,
+        thread_id: str,
+        *,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[Data, AsyncConversationCursorPage[Data]]:
+        """
+        List ChatKit thread items
+
+        Args:
+          after: List items created after this thread item ID. Defaults to null for the first
+              page.
+
+          before: List items created before this thread item ID. Defaults to null for the newest
+              results.
+
+          limit: Maximum number of thread items to return. Defaults to 20.
+
+          order: Sort order for results by creation time. Defaults to `desc`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not thread_id:
+            raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
+        extra_headers = {"OpenAI-Beta": "chatkit_beta=v1", **(extra_headers or {})}
+        return self._get_api_list(
+            f"/chatkit/threads/{thread_id}/items",
+            page=AsyncConversationCursorPage[Data],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "before": before,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    thread_list_items_params.ThreadListItemsParams,
+                ),
+            ),
+            model=cast(Any, Data),  # Union types cannot be passed in as arguments in the type system
+        )
+
+
+class ThreadsWithRawResponse:
+    def __init__(self, threads: Threads) -> None:
+        self._threads = threads
+
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            threads.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            threads.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            threads.delete,
+        )
+        self.list_items = _legacy_response.to_raw_response_wrapper(
+            threads.list_items,
+        )
+
+
+class AsyncThreadsWithRawResponse:
+    def __init__(self, threads: AsyncThreads) -> None:
+        self._threads = threads
+
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            threads.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            threads.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            threads.delete,
+        )
+        self.list_items = _legacy_response.async_to_raw_response_wrapper(
+            threads.list_items,
+        )
+
+
+class ThreadsWithStreamingResponse:
+    def __init__(self, threads: Threads) -> None:
+        self._threads = threads
+
+        self.retrieve = to_streamed_response_wrapper(
+            threads.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            threads.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            threads.delete,
+        )
+        self.list_items = to_streamed_response_wrapper(
+            threads.list_items,
+        )
+
+
+class AsyncThreadsWithStreamingResponse:
+    def __init__(self, threads: AsyncThreads) -> None:
+        self._threads = threads
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            threads.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            threads.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            threads.delete,
+        )
+        self.list_items = async_to_streamed_response_wrapper(
+            threads.list_items,
+        )
diff --git a/src/openai/resources/beta/realtime/__init__.py b/src/openai/resources/beta/realtime/__init__.py
index 474434e6e1..7ab3d9931c 100644
--- a/src/openai/resources/beta/realtime/__init__.py
+++ b/src/openai/resources/beta/realtime/__init__.py
@@ -16,6 +16,14 @@
     SessionsWithStreamingResponse,
     AsyncSessionsWithStreamingResponse,
 )
+from .transcription_sessions import (
+    TranscriptionSessions,
+    AsyncTranscriptionSessions,
+    TranscriptionSessionsWithRawResponse,
+    AsyncTranscriptionSessionsWithRawResponse,
+    TranscriptionSessionsWithStreamingResponse,
+    AsyncTranscriptionSessionsWithStreamingResponse,
+)
 
 __all__ = [
     "Sessions",
@@ -24,6 +32,12 @@
     "AsyncSessionsWithRawResponse",
     "SessionsWithStreamingResponse",
     "AsyncSessionsWithStreamingResponse",
+    "TranscriptionSessions",
+    "AsyncTranscriptionSessions",
+    "TranscriptionSessionsWithRawResponse",
+    "AsyncTranscriptionSessionsWithRawResponse",
+    "TranscriptionSessionsWithStreamingResponse",
+    "AsyncTranscriptionSessionsWithStreamingResponse",
     "Realtime",
     "AsyncRealtime",
     "RealtimeWithRawResponse",
diff --git a/src/openai/resources/beta/realtime/realtime.py b/src/openai/resources/beta/realtime/realtime.py
index cd610d9089..4fa35963b6 100644
--- a/src/openai/resources/beta/realtime/realtime.py
+++ b/src/openai/resources/beta/realtime/realtime.py
@@ -32,7 +32,19 @@
 from ...._resource import SyncAPIResource, AsyncAPIResource
 from ...._exceptions import OpenAIError
 from ...._base_client import _merge_mappings
-from ....types.beta.realtime import session_update_event_param, response_create_event_param
+from ....types.beta.realtime import (
+    session_update_event_param,
+    response_create_event_param,
+    transcription_session_update_param,
+)
+from .transcription_sessions import (
+    TranscriptionSessions,
+    AsyncTranscriptionSessions,
+    TranscriptionSessionsWithRawResponse,
+    AsyncTranscriptionSessionsWithRawResponse,
+    TranscriptionSessionsWithStreamingResponse,
+    AsyncTranscriptionSessionsWithStreamingResponse,
+)
 from ....types.websocket_connection_options import WebsocketConnectionOptions
 from ....types.beta.realtime.realtime_client_event import RealtimeClientEvent
 from ....types.beta.realtime.realtime_server_event import RealtimeServerEvent
@@ -55,6 +67,10 @@ class Realtime(SyncAPIResource):
     def sessions(self) -> Sessions:
         return Sessions(self._client)
 
+    @cached_property
+    def transcription_sessions(self) -> TranscriptionSessions:
+        return TranscriptionSessions(self._client)
+
     @cached_property
     def with_raw_response(self) -> RealtimeWithRawResponse:
         """
@@ -107,6 +123,10 @@ class AsyncRealtime(AsyncAPIResource):
     def sessions(self) -> AsyncSessions:
         return AsyncSessions(self._client)
 
+    @cached_property
+    def transcription_sessions(self) -> AsyncTranscriptionSessions:
+        return AsyncTranscriptionSessions(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncRealtimeWithRawResponse:
         """
@@ -162,6 +182,10 @@ def __init__(self, realtime: Realtime) -> None:
     def sessions(self) -> SessionsWithRawResponse:
         return SessionsWithRawResponse(self._realtime.sessions)
 
+    @cached_property
+    def transcription_sessions(self) -> TranscriptionSessionsWithRawResponse:
+        return TranscriptionSessionsWithRawResponse(self._realtime.transcription_sessions)
+
 
 class AsyncRealtimeWithRawResponse:
     def __init__(self, realtime: AsyncRealtime) -> None:
@@ -171,6 +195,10 @@ def __init__(self, realtime: AsyncRealtime) -> None:
     def sessions(self) -> AsyncSessionsWithRawResponse:
         return AsyncSessionsWithRawResponse(self._realtime.sessions)
 
+    @cached_property
+    def transcription_sessions(self) -> AsyncTranscriptionSessionsWithRawResponse:
+        return AsyncTranscriptionSessionsWithRawResponse(self._realtime.transcription_sessions)
+
 
 class RealtimeWithStreamingResponse:
     def __init__(self, realtime: Realtime) -> None:
@@ -180,6 +208,10 @@ def __init__(self, realtime: Realtime) -> None:
     def sessions(self) -> SessionsWithStreamingResponse:
         return SessionsWithStreamingResponse(self._realtime.sessions)
 
+    @cached_property
+    def transcription_sessions(self) -> TranscriptionSessionsWithStreamingResponse:
+        return TranscriptionSessionsWithStreamingResponse(self._realtime.transcription_sessions)
+
 
 class AsyncRealtimeWithStreamingResponse:
     def __init__(self, realtime: AsyncRealtime) -> None:
@@ -189,14 +221,20 @@ def __init__(self, realtime: AsyncRealtime) -> None:
     def sessions(self) -> AsyncSessionsWithStreamingResponse:
         return AsyncSessionsWithStreamingResponse(self._realtime.sessions)
 
+    @cached_property
+    def transcription_sessions(self) -> AsyncTranscriptionSessionsWithStreamingResponse:
+        return AsyncTranscriptionSessionsWithStreamingResponse(self._realtime.transcription_sessions)
+
 
 class AsyncRealtimeConnection:
     """Represents a live websocket connection to the Realtime API"""
 
     session: AsyncRealtimeSessionResource
     response: AsyncRealtimeResponseResource
-    conversation: AsyncRealtimeConversationResource
     input_audio_buffer: AsyncRealtimeInputAudioBufferResource
+    conversation: AsyncRealtimeConversationResource
+    output_audio_buffer: AsyncRealtimeOutputAudioBufferResource
+    transcription_session: AsyncRealtimeTranscriptionSessionResource
 
     _connection: AsyncWebsocketConnection
 
@@ -205,8 +243,10 @@ def __init__(self, connection: AsyncWebsocketConnection) -> None:
 
         self.session = AsyncRealtimeSessionResource(self)
         self.response = AsyncRealtimeResponseResource(self)
-        self.conversation = AsyncRealtimeConversationResource(self)
         self.input_audio_buffer = AsyncRealtimeInputAudioBufferResource(self)
+        self.conversation = AsyncRealtimeConversationResource(self)
+        self.output_audio_buffer = AsyncRealtimeOutputAudioBufferResource(self)
+        self.transcription_session = AsyncRealtimeTranscriptionSessionResource(self)
 
     async def __aiter__(self) -> AsyncIterator[RealtimeServerEvent]:
         """
@@ -239,10 +279,6 @@ async def recv_bytes(self) -> bytes:
         """
         message = await self._connection.recv(decode=False)
         log.debug(f"Received websocket message: %s", message)
-        if not isinstance(message, bytes):
-            # passing `decode=False` should always result in us getting `bytes` back
-            raise TypeError(f"Expected `.recv(decode=False)` to return `bytes` but got {type(message)}")
-
         return message
 
     async def send(self, event: RealtimeClientEvent | RealtimeClientEventParam) -> None:
@@ -322,6 +358,7 @@ async def __aenter__(self) -> AsyncRealtimeConnection:
             raise OpenAIError("You need to install `openai[realtime]` to use this method") from exc
 
         extra_query = self.__extra_query
+        await self.__client._refresh_api_key()
         auth_headers = self.__client.auth_headers
         if is_async_azure_client(self.__client):
             url, auth_headers = await self.__client._configure_realtime(self.__model, extra_query)
@@ -377,8 +414,10 @@ class RealtimeConnection:
 
     session: RealtimeSessionResource
     response: RealtimeResponseResource
-    conversation: RealtimeConversationResource
     input_audio_buffer: RealtimeInputAudioBufferResource
+    conversation: RealtimeConversationResource
+    output_audio_buffer: RealtimeOutputAudioBufferResource
+    transcription_session: RealtimeTranscriptionSessionResource
 
     _connection: WebsocketConnection
 
@@ -387,8 +426,10 @@ def __init__(self, connection: WebsocketConnection) -> None:
 
         self.session = RealtimeSessionResource(self)
         self.response = RealtimeResponseResource(self)
-        self.conversation = RealtimeConversationResource(self)
         self.input_audio_buffer = RealtimeInputAudioBufferResource(self)
+        self.conversation = RealtimeConversationResource(self)
+        self.output_audio_buffer = RealtimeOutputAudioBufferResource(self)
+        self.transcription_session = RealtimeTranscriptionSessionResource(self)
 
     def __iter__(self) -> Iterator[RealtimeServerEvent]:
         """
@@ -421,10 +462,6 @@ def recv_bytes(self) -> bytes:
         """
         message = self._connection.recv(decode=False)
         log.debug(f"Received websocket message: %s", message)
-        if not isinstance(message, bytes):
-            # passing `decode=False` should always result in us getting `bytes` back
-            raise TypeError(f"Expected `.recv(decode=False)` to return `bytes` but got {type(message)}")
-
         return message
 
     def send(self, event: RealtimeClientEvent | RealtimeClientEventParam) -> None:
@@ -504,6 +541,7 @@ def __enter__(self) -> RealtimeConnection:
             raise OpenAIError("You need to install `openai[realtime]` to use this method") from exc
 
         extra_query = self.__extra_query
+        self.__client._refresh_api_key()
         auth_headers = self.__client.auth_headers
         if is_azure_client(self.__client):
             url, auth_headers = self.__client._configure_realtime(self.__model, extra_query)
@@ -582,20 +620,6 @@ def update(self, *, session: session_update_event_param.Session, event_id: str |
 
 
 class RealtimeResponseResource(BaseRealtimeConnectionResource):
-    def cancel(self, *, event_id: str | NotGiven = NOT_GIVEN, response_id: str | NotGiven = NOT_GIVEN) -> None:
-        """Send this event to cancel an in-progress response.
-
-        The server will respond
-        with a `response.cancelled` event or an error if there is no response to
-        cancel.
-        """
-        self._connection.send(
-            cast(
-                RealtimeClientEventParam,
-                strip_not_given({"type": "response.cancel", "event_id": event_id, "response_id": response_id}),
-            )
-        )
-
     def create(
         self,
         *,
@@ -626,6 +650,70 @@ def create(
             )
         )
 
+    def cancel(self, *, event_id: str | NotGiven = NOT_GIVEN, response_id: str | NotGiven = NOT_GIVEN) -> None:
+        """Send this event to cancel an in-progress response.
+
+        The server will respond
+        with a `response.done` event with a status of `response.status=cancelled`. If
+        there is no response to cancel, the server will respond with an error.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "response.cancel", "event_id": event_id, "response_id": response_id}),
+            )
+        )
+
+
+class RealtimeInputAudioBufferResource(BaseRealtimeConnectionResource):
+    def clear(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """Send this event to clear the audio bytes in the buffer.
+
+        The server will
+        respond with an `input_audio_buffer.cleared` event.
+        """
+        self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.clear", "event_id": event_id}))
+        )
+
+    def commit(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """
+        Send this event to commit the user input audio buffer, which will create a
+        new user message item in the conversation. This event will produce an error
+        if the input audio buffer is empty. When in Server VAD mode, the client does
+        not need to send this event, the server will commit the audio buffer
+        automatically.
+
+        Committing the input audio buffer will trigger input audio transcription
+        (if enabled in session configuration), but it will not create a response
+        from the model. The server will respond with an `input_audio_buffer.committed`
+        event.
+        """
+        self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.commit", "event_id": event_id}))
+        )
+
+    def append(self, *, audio: str, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """Send this event to append audio bytes to the input audio buffer.
+
+        The audio
+        buffer is temporary storage you can write to and later commit. In Server VAD
+        mode, the audio buffer is used to detect speech and the server will decide
+        when to commit. When Server VAD is disabled, you must commit the audio buffer
+        manually.
+
+        The client may choose how much audio to place in each event up to a maximum
+        of 15 MiB, for example streaming smaller chunks from the client may allow the
+        VAD to be more responsive. Unlike made other client events, the server will
+        not send a confirmation response to this event.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "input_audio_buffer.append", "audio": audio, "event_id": event_id}),
+            )
+        )
+
 
 class RealtimeConversationResource(BaseRealtimeConnectionResource):
     @cached_property
@@ -711,53 +799,45 @@ def truncate(
             )
         )
 
-
-class RealtimeInputAudioBufferResource(BaseRealtimeConnectionResource):
-    def clear(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
-        """Send this event to clear the audio bytes in the buffer.
-
-        The server will
-        respond with an `input_audio_buffer.cleared` event.
+    def retrieve(self, *, item_id: str, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """
+        Send this event when you want to retrieve the server's representation of a specific item in the conversation history. This is useful, for example, to inspect user audio after noise cancellation and VAD.
+        The server will respond with a `conversation.item.retrieved` event,
+        unless the item does not exist in the conversation history, in which case the
+        server will respond with an error.
         """
         self._connection.send(
-            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.clear", "event_id": event_id}))
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "conversation.item.retrieve", "item_id": item_id, "event_id": event_id}),
+            )
         )
 
-    def commit(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
-        """
-        Send this event to commit the user input audio buffer, which will create a
-        new user message item in the conversation. This event will produce an error
-        if the input audio buffer is empty. When in Server VAD mode, the client does
-        not need to send this event, the server will commit the audio buffer
-        automatically.
 
-        Committing the input audio buffer will trigger input audio transcription
-        (if enabled in session configuration), but it will not create a response
-        from the model. The server will respond with an `input_audio_buffer.committed`
-        event.
+class RealtimeOutputAudioBufferResource(BaseRealtimeConnectionResource):
+    def clear(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """**WebRTC Only:** Emit to cut off the current audio response.
+
+        This will trigger the server to
+        stop generating audio and emit a `output_audio_buffer.cleared` event. This
+        event should be preceded by a `response.cancel` client event to stop the
+        generation of the current response.
+        [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc).
         """
         self._connection.send(
-            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.commit", "event_id": event_id}))
+            cast(RealtimeClientEventParam, strip_not_given({"type": "output_audio_buffer.clear", "event_id": event_id}))
         )
 
-    def append(self, *, audio: str, event_id: str | NotGiven = NOT_GIVEN) -> None:
-        """Send this event to append audio bytes to the input audio buffer.
 
-        The audio
-        buffer is temporary storage you can write to and later commit. In Server VAD
-        mode, the audio buffer is used to detect speech and the server will decide
-        when to commit. When Server VAD is disabled, you must commit the audio buffer
-        manually.
-
-        The client may choose how much audio to place in each event up to a maximum
-        of 15 MiB, for example streaming smaller chunks from the client may allow the
-        VAD to be more responsive. Unlike made other client events, the server will
-        not send a confirmation response to this event.
-        """
+class RealtimeTranscriptionSessionResource(BaseRealtimeConnectionResource):
+    def update(
+        self, *, session: transcription_session_update_param.Session, event_id: str | NotGiven = NOT_GIVEN
+    ) -> None:
+        """Send this event to update a transcription session."""
         self._connection.send(
             cast(
                 RealtimeClientEventParam,
-                strip_not_given({"type": "input_audio_buffer.append", "audio": audio, "event_id": event_id}),
+                strip_not_given({"type": "transcription_session.update", "session": session, "event_id": event_id}),
             )
         )
 
@@ -792,20 +872,6 @@ async def update(
 
 
 class AsyncRealtimeResponseResource(BaseAsyncRealtimeConnectionResource):
-    async def cancel(self, *, event_id: str | NotGiven = NOT_GIVEN, response_id: str | NotGiven = NOT_GIVEN) -> None:
-        """Send this event to cancel an in-progress response.
-
-        The server will respond
-        with a `response.cancelled` event or an error if there is no response to
-        cancel.
-        """
-        await self._connection.send(
-            cast(
-                RealtimeClientEventParam,
-                strip_not_given({"type": "response.cancel", "event_id": event_id, "response_id": response_id}),
-            )
-        )
-
     async def create(
         self,
         *,
@@ -836,6 +902,70 @@ async def create(
             )
         )
 
+    async def cancel(self, *, event_id: str | NotGiven = NOT_GIVEN, response_id: str | NotGiven = NOT_GIVEN) -> None:
+        """Send this event to cancel an in-progress response.
+
+        The server will respond
+        with a `response.done` event with a status of `response.status=cancelled`. If
+        there is no response to cancel, the server will respond with an error.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "response.cancel", "event_id": event_id, "response_id": response_id}),
+            )
+        )
+
+
+class AsyncRealtimeInputAudioBufferResource(BaseAsyncRealtimeConnectionResource):
+    async def clear(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """Send this event to clear the audio bytes in the buffer.
+
+        The server will
+        respond with an `input_audio_buffer.cleared` event.
+        """
+        await self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.clear", "event_id": event_id}))
+        )
+
+    async def commit(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """
+        Send this event to commit the user input audio buffer, which will create a
+        new user message item in the conversation. This event will produce an error
+        if the input audio buffer is empty. When in Server VAD mode, the client does
+        not need to send this event, the server will commit the audio buffer
+        automatically.
+
+        Committing the input audio buffer will trigger input audio transcription
+        (if enabled in session configuration), but it will not create a response
+        from the model. The server will respond with an `input_audio_buffer.committed`
+        event.
+        """
+        await self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.commit", "event_id": event_id}))
+        )
+
+    async def append(self, *, audio: str, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """Send this event to append audio bytes to the input audio buffer.
+
+        The audio
+        buffer is temporary storage you can write to and later commit. In Server VAD
+        mode, the audio buffer is used to detect speech and the server will decide
+        when to commit. When Server VAD is disabled, you must commit the audio buffer
+        manually.
+
+        The client may choose how much audio to place in each event up to a maximum
+        of 15 MiB, for example streaming smaller chunks from the client may allow the
+        VAD to be more responsive. Unlike made other client events, the server will
+        not send a confirmation response to this event.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "input_audio_buffer.append", "audio": audio, "event_id": event_id}),
+            )
+        )
+
 
 class AsyncRealtimeConversationResource(BaseAsyncRealtimeConnectionResource):
     @cached_property
@@ -921,52 +1051,44 @@ async def truncate(
             )
         )
 
-
-class AsyncRealtimeInputAudioBufferResource(BaseAsyncRealtimeConnectionResource):
-    async def clear(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
-        """Send this event to clear the audio bytes in the buffer.
-
-        The server will
-        respond with an `input_audio_buffer.cleared` event.
+    async def retrieve(self, *, item_id: str, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """
+        Send this event when you want to retrieve the server's representation of a specific item in the conversation history. This is useful, for example, to inspect user audio after noise cancellation and VAD.
+        The server will respond with a `conversation.item.retrieved` event,
+        unless the item does not exist in the conversation history, in which case the
+        server will respond with an error.
         """
         await self._connection.send(
-            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.clear", "event_id": event_id}))
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "conversation.item.retrieve", "item_id": item_id, "event_id": event_id}),
+            )
         )
 
-    async def commit(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
-        """
-        Send this event to commit the user input audio buffer, which will create a
-        new user message item in the conversation. This event will produce an error
-        if the input audio buffer is empty. When in Server VAD mode, the client does
-        not need to send this event, the server will commit the audio buffer
-        automatically.
 
-        Committing the input audio buffer will trigger input audio transcription
-        (if enabled in session configuration), but it will not create a response
-        from the model. The server will respond with an `input_audio_buffer.committed`
-        event.
+class AsyncRealtimeOutputAudioBufferResource(BaseAsyncRealtimeConnectionResource):
+    async def clear(self, *, event_id: str | NotGiven = NOT_GIVEN) -> None:
+        """**WebRTC Only:** Emit to cut off the current audio response.
+
+        This will trigger the server to
+        stop generating audio and emit a `output_audio_buffer.cleared` event. This
+        event should be preceded by a `response.cancel` client event to stop the
+        generation of the current response.
+        [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc).
         """
         await self._connection.send(
-            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.commit", "event_id": event_id}))
+            cast(RealtimeClientEventParam, strip_not_given({"type": "output_audio_buffer.clear", "event_id": event_id}))
         )
 
-    async def append(self, *, audio: str, event_id: str | NotGiven = NOT_GIVEN) -> None:
-        """Send this event to append audio bytes to the input audio buffer.
-
-        The audio
-        buffer is temporary storage you can write to and later commit. In Server VAD
-        mode, the audio buffer is used to detect speech and the server will decide
-        when to commit. When Server VAD is disabled, you must commit the audio buffer
-        manually.
 
-        The client may choose how much audio to place in each event up to a maximum
-        of 15 MiB, for example streaming smaller chunks from the client may allow the
-        VAD to be more responsive. Unlike made other client events, the server will
-        not send a confirmation response to this event.
-        """
+class AsyncRealtimeTranscriptionSessionResource(BaseAsyncRealtimeConnectionResource):
+    async def update(
+        self, *, session: transcription_session_update_param.Session, event_id: str | NotGiven = NOT_GIVEN
+    ) -> None:
+        """Send this event to update a transcription session."""
         await self._connection.send(
             cast(
                 RealtimeClientEventParam,
-                strip_not_given({"type": "input_audio_buffer.append", "audio": audio, "event_id": event_id}),
+                strip_not_given({"type": "transcription_session.update", "session": session, "event_id": event_id}),
             )
         )
diff --git a/src/openai/resources/beta/realtime/sessions.py b/src/openai/resources/beta/realtime/sessions.py
index 4b337b7c19..9b85e02d17 100644
--- a/src/openai/resources/beta/realtime/sessions.py
+++ b/src/openai/resources/beta/realtime/sessions.py
@@ -9,10 +9,7 @@
 
 from .... import _legacy_response
 from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ...._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ...._utils import maybe_transform, async_maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
 from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -46,25 +43,33 @@ def with_streaming_response(self) -> SessionsWithStreamingResponse:
     def create(
         self,
         *,
+        client_secret: session_create_params.ClientSecret | NotGiven = NOT_GIVEN,
         input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"] | NotGiven = NOT_GIVEN,
+        input_audio_noise_reduction: session_create_params.InputAudioNoiseReduction | NotGiven = NOT_GIVEN,
         input_audio_transcription: session_create_params.InputAudioTranscription | NotGiven = NOT_GIVEN,
         instructions: str | NotGiven = NOT_GIVEN,
         max_response_output_tokens: Union[int, Literal["inf"]] | NotGiven = NOT_GIVEN,
         modalities: List[Literal["text", "audio"]] | NotGiven = NOT_GIVEN,
         model: Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
             "gpt-4o-realtime-preview",
             "gpt-4o-realtime-preview-2024-10-01",
             "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
             "gpt-4o-mini-realtime-preview",
             "gpt-4o-mini-realtime-preview-2024-12-17",
         ]
         | NotGiven = NOT_GIVEN,
         output_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"] | NotGiven = NOT_GIVEN,
+        speed: float | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
         tool_choice: str | NotGiven = NOT_GIVEN,
         tools: Iterable[session_create_params.Tool] | NotGiven = NOT_GIVEN,
+        tracing: session_create_params.Tracing | NotGiven = NOT_GIVEN,
         turn_detection: session_create_params.TurnDetection | NotGiven = NOT_GIVEN,
-        voice: Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"] | NotGiven = NOT_GIVEN,
+        voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]]
+        | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -82,18 +87,26 @@ def create(
         the Realtime API.
 
         Args:
+          client_secret: Configuration options for the generated client secret.
+
           input_audio_format: The format of input audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. For
               `pcm16`, input audio must be 16-bit PCM at a 24kHz sample rate, single channel
               (mono), and little-endian byte order.
 
+          input_audio_noise_reduction: Configuration for input audio noise reduction. This can be set to `null` to turn
+              off. Noise reduction filters audio added to the input audio buffer before it is
+              sent to VAD and the model. Filtering the audio can improve VAD and turn
+              detection accuracy (reducing false positives) and model performance by improving
+              perception of the input audio.
+
           input_audio_transcription: Configuration for input audio transcription, defaults to off and can be set to
               `null` to turn off once on. Input audio transcription is not native to the
               model, since the model consumes audio directly. Transcription runs
               asynchronously through
-              [OpenAI Whisper transcription](https://platform.openai.com/docs/api-reference/audio/createTranscription)
-              and should be treated as rough guidance rather than the representation
-              understood by the model. The client can optionally set the language and prompt
-              for transcription, these fields will be passed to the Whisper API.
+              [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+              and should be treated as guidance of input audio content rather than precisely
+              what the model heard. The client can optionally set the language and prompt for
+              transcription, these offer additional guidance to the transcription service.
 
           instructions: The default system instructions (i.e. system message) prepended to model calls.
               This field allows the client to guide the model on desired responses. The model
@@ -119,20 +132,38 @@ def create(
           output_audio_format: The format of output audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`.
               For `pcm16`, output audio is sampled at a rate of 24kHz.
 
-          temperature: Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8.
+          speed: The speed of the model's spoken response. 1.0 is the default speed. 0.25 is the
+              minimum speed. 1.5 is the maximum speed. This value can only be changed in
+              between model turns, not while a response is in progress.
+
+          temperature: Sampling temperature for the model, limited to [0.6, 1.2]. For audio models a
+              temperature of 0.8 is highly recommended for best performance.
 
           tool_choice: How the model chooses tools. Options are `auto`, `none`, `required`, or specify
               a function.
 
           tools: Tools (functions) available to the model.
 
-          turn_detection: Configuration for turn detection. Can be set to `null` to turn off. Server VAD
-              means that the model will detect the start and end of speech based on audio
-              volume and respond at the end of user speech.
+          tracing: Configuration options for tracing. Set to null to disable tracing. Once tracing
+              is enabled for a session, the configuration cannot be modified.
+
+              `auto` will create a trace for the session with default values for the workflow
+              name, group id, and metadata.
+
+          turn_detection: Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
+              set to `null` to turn off, in which case the client must manually trigger model
+              response. Server VAD means that the model will detect the start and end of
+              speech based on audio volume and respond at the end of user speech. Semantic VAD
+              is more advanced and uses a turn detection model (in conjunction with VAD) to
+              semantically estimate whether the user has finished speaking, then dynamically
+              sets a timeout based on this probability. For example, if user audio trails off
+              with "uhhm", the model will score a low probability of turn end and wait longer
+              for the user to continue speaking. This can be useful for more natural
+              conversations, but may have a higher latency.
 
           voice: The voice the model uses to respond. Voice cannot be changed during the session
               once the model has responded with audio at least once. Current voice options are
-              `alloy`, `ash`, `ballad`, `coral`, `echo` `sage`, `shimmer` and `verse`.
+              `alloy`, `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, and `verse`.
 
           extra_headers: Send extra headers
 
@@ -147,16 +178,20 @@ def create(
             "/realtime/sessions",
             body=maybe_transform(
                 {
+                    "client_secret": client_secret,
                     "input_audio_format": input_audio_format,
+                    "input_audio_noise_reduction": input_audio_noise_reduction,
                     "input_audio_transcription": input_audio_transcription,
                     "instructions": instructions,
                     "max_response_output_tokens": max_response_output_tokens,
                     "modalities": modalities,
                     "model": model,
                     "output_audio_format": output_audio_format,
+                    "speed": speed,
                     "temperature": temperature,
                     "tool_choice": tool_choice,
                     "tools": tools,
+                    "tracing": tracing,
                     "turn_detection": turn_detection,
                     "voice": voice,
                 },
@@ -192,25 +227,33 @@ def with_streaming_response(self) -> AsyncSessionsWithStreamingResponse:
     async def create(
         self,
         *,
+        client_secret: session_create_params.ClientSecret | NotGiven = NOT_GIVEN,
         input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"] | NotGiven = NOT_GIVEN,
+        input_audio_noise_reduction: session_create_params.InputAudioNoiseReduction | NotGiven = NOT_GIVEN,
         input_audio_transcription: session_create_params.InputAudioTranscription | NotGiven = NOT_GIVEN,
         instructions: str | NotGiven = NOT_GIVEN,
         max_response_output_tokens: Union[int, Literal["inf"]] | NotGiven = NOT_GIVEN,
         modalities: List[Literal["text", "audio"]] | NotGiven = NOT_GIVEN,
         model: Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
             "gpt-4o-realtime-preview",
             "gpt-4o-realtime-preview-2024-10-01",
             "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
             "gpt-4o-mini-realtime-preview",
             "gpt-4o-mini-realtime-preview-2024-12-17",
         ]
         | NotGiven = NOT_GIVEN,
         output_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"] | NotGiven = NOT_GIVEN,
+        speed: float | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
         tool_choice: str | NotGiven = NOT_GIVEN,
         tools: Iterable[session_create_params.Tool] | NotGiven = NOT_GIVEN,
+        tracing: session_create_params.Tracing | NotGiven = NOT_GIVEN,
         turn_detection: session_create_params.TurnDetection | NotGiven = NOT_GIVEN,
-        voice: Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"] | NotGiven = NOT_GIVEN,
+        voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]]
+        | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -228,18 +271,26 @@ async def create(
         the Realtime API.
 
         Args:
+          client_secret: Configuration options for the generated client secret.
+
           input_audio_format: The format of input audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. For
               `pcm16`, input audio must be 16-bit PCM at a 24kHz sample rate, single channel
               (mono), and little-endian byte order.
 
+          input_audio_noise_reduction: Configuration for input audio noise reduction. This can be set to `null` to turn
+              off. Noise reduction filters audio added to the input audio buffer before it is
+              sent to VAD and the model. Filtering the audio can improve VAD and turn
+              detection accuracy (reducing false positives) and model performance by improving
+              perception of the input audio.
+
           input_audio_transcription: Configuration for input audio transcription, defaults to off and can be set to
               `null` to turn off once on. Input audio transcription is not native to the
               model, since the model consumes audio directly. Transcription runs
               asynchronously through
-              [OpenAI Whisper transcription](https://platform.openai.com/docs/api-reference/audio/createTranscription)
-              and should be treated as rough guidance rather than the representation
-              understood by the model. The client can optionally set the language and prompt
-              for transcription, these fields will be passed to the Whisper API.
+              [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+              and should be treated as guidance of input audio content rather than precisely
+              what the model heard. The client can optionally set the language and prompt for
+              transcription, these offer additional guidance to the transcription service.
 
           instructions: The default system instructions (i.e. system message) prepended to model calls.
               This field allows the client to guide the model on desired responses. The model
@@ -265,20 +316,38 @@ async def create(
           output_audio_format: The format of output audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`.
               For `pcm16`, output audio is sampled at a rate of 24kHz.
 
-          temperature: Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8.
+          speed: The speed of the model's spoken response. 1.0 is the default speed. 0.25 is the
+              minimum speed. 1.5 is the maximum speed. This value can only be changed in
+              between model turns, not while a response is in progress.
+
+          temperature: Sampling temperature for the model, limited to [0.6, 1.2]. For audio models a
+              temperature of 0.8 is highly recommended for best performance.
 
           tool_choice: How the model chooses tools. Options are `auto`, `none`, `required`, or specify
               a function.
 
           tools: Tools (functions) available to the model.
 
-          turn_detection: Configuration for turn detection. Can be set to `null` to turn off. Server VAD
-              means that the model will detect the start and end of speech based on audio
-              volume and respond at the end of user speech.
+          tracing: Configuration options for tracing. Set to null to disable tracing. Once tracing
+              is enabled for a session, the configuration cannot be modified.
+
+              `auto` will create a trace for the session with default values for the workflow
+              name, group id, and metadata.
+
+          turn_detection: Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
+              set to `null` to turn off, in which case the client must manually trigger model
+              response. Server VAD means that the model will detect the start and end of
+              speech based on audio volume and respond at the end of user speech. Semantic VAD
+              is more advanced and uses a turn detection model (in conjunction with VAD) to
+              semantically estimate whether the user has finished speaking, then dynamically
+              sets a timeout based on this probability. For example, if user audio trails off
+              with "uhhm", the model will score a low probability of turn end and wait longer
+              for the user to continue speaking. This can be useful for more natural
+              conversations, but may have a higher latency.
 
           voice: The voice the model uses to respond. Voice cannot be changed during the session
               once the model has responded with audio at least once. Current voice options are
-              `alloy`, `ash`, `ballad`, `coral`, `echo` `sage`, `shimmer` and `verse`.
+              `alloy`, `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, and `verse`.
 
           extra_headers: Send extra headers
 
@@ -293,16 +362,20 @@ async def create(
             "/realtime/sessions",
             body=await async_maybe_transform(
                 {
+                    "client_secret": client_secret,
                     "input_audio_format": input_audio_format,
+                    "input_audio_noise_reduction": input_audio_noise_reduction,
                     "input_audio_transcription": input_audio_transcription,
                     "instructions": instructions,
                     "max_response_output_tokens": max_response_output_tokens,
                     "modalities": modalities,
                     "model": model,
                     "output_audio_format": output_audio_format,
+                    "speed": speed,
                     "temperature": temperature,
                     "tool_choice": tool_choice,
                     "tools": tools,
+                    "tracing": tracing,
                     "turn_detection": turn_detection,
                     "voice": voice,
                 },
diff --git a/src/openai/resources/beta/realtime/transcription_sessions.py b/src/openai/resources/beta/realtime/transcription_sessions.py
new file mode 100644
index 0000000000..54fe7d5a6c
--- /dev/null
+++ b/src/openai/resources/beta/realtime/transcription_sessions.py
@@ -0,0 +1,282 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...._base_client import make_request_options
+from ....types.beta.realtime import transcription_session_create_params
+from ....types.beta.realtime.transcription_session import TranscriptionSession
+
+__all__ = ["TranscriptionSessions", "AsyncTranscriptionSessions"]
+
+
+class TranscriptionSessions(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TranscriptionSessionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return TranscriptionSessionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TranscriptionSessionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return TranscriptionSessionsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        client_secret: transcription_session_create_params.ClientSecret | NotGiven = NOT_GIVEN,
+        include: List[str] | NotGiven = NOT_GIVEN,
+        input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"] | NotGiven = NOT_GIVEN,
+        input_audio_noise_reduction: transcription_session_create_params.InputAudioNoiseReduction
+        | NotGiven = NOT_GIVEN,
+        input_audio_transcription: transcription_session_create_params.InputAudioTranscription | NotGiven = NOT_GIVEN,
+        modalities: List[Literal["text", "audio"]] | NotGiven = NOT_GIVEN,
+        turn_detection: transcription_session_create_params.TurnDetection | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> TranscriptionSession:
+        """
+        Create an ephemeral API token for use in client-side applications with the
+        Realtime API specifically for realtime transcriptions. Can be configured with
+        the same session parameters as the `transcription_session.update` client event.
+
+        It responds with a session object, plus a `client_secret` key which contains a
+        usable ephemeral API token that can be used to authenticate browser clients for
+        the Realtime API.
+
+        Args:
+          client_secret: Configuration options for the generated client secret.
+
+          include:
+              The set of items to include in the transcription. Current available items are:
+
+              - `item.input_audio_transcription.logprobs`
+
+          input_audio_format: The format of input audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. For
+              `pcm16`, input audio must be 16-bit PCM at a 24kHz sample rate, single channel
+              (mono), and little-endian byte order.
+
+          input_audio_noise_reduction: Configuration for input audio noise reduction. This can be set to `null` to turn
+              off. Noise reduction filters audio added to the input audio buffer before it is
+              sent to VAD and the model. Filtering the audio can improve VAD and turn
+              detection accuracy (reducing false positives) and model performance by improving
+              perception of the input audio.
+
+          input_audio_transcription: Configuration for input audio transcription. The client can optionally set the
+              language and prompt for transcription, these offer additional guidance to the
+              transcription service.
+
+          modalities: The set of modalities the model can respond with. To disable audio, set this to
+              ["text"].
+
+          turn_detection: Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
+              set to `null` to turn off, in which case the client must manually trigger model
+              response. Server VAD means that the model will detect the start and end of
+              speech based on audio volume and respond at the end of user speech. Semantic VAD
+              is more advanced and uses a turn detection model (in conjunction with VAD) to
+              semantically estimate whether the user has finished speaking, then dynamically
+              sets a timeout based on this probability. For example, if user audio trails off
+              with "uhhm", the model will score a low probability of turn end and wait longer
+              for the user to continue speaking. This can be useful for more natural
+              conversations, but may have a higher latency.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"OpenAI-Beta": "assistants=v2", **(extra_headers or {})}
+        return self._post(
+            "/realtime/transcription_sessions",
+            body=maybe_transform(
+                {
+                    "client_secret": client_secret,
+                    "include": include,
+                    "input_audio_format": input_audio_format,
+                    "input_audio_noise_reduction": input_audio_noise_reduction,
+                    "input_audio_transcription": input_audio_transcription,
+                    "modalities": modalities,
+                    "turn_detection": turn_detection,
+                },
+                transcription_session_create_params.TranscriptionSessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TranscriptionSession,
+        )
+
+
+class AsyncTranscriptionSessions(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTranscriptionSessionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncTranscriptionSessionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTranscriptionSessionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncTranscriptionSessionsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        client_secret: transcription_session_create_params.ClientSecret | NotGiven = NOT_GIVEN,
+        include: List[str] | NotGiven = NOT_GIVEN,
+        input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"] | NotGiven = NOT_GIVEN,
+        input_audio_noise_reduction: transcription_session_create_params.InputAudioNoiseReduction
+        | NotGiven = NOT_GIVEN,
+        input_audio_transcription: transcription_session_create_params.InputAudioTranscription | NotGiven = NOT_GIVEN,
+        modalities: List[Literal["text", "audio"]] | NotGiven = NOT_GIVEN,
+        turn_detection: transcription_session_create_params.TurnDetection | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> TranscriptionSession:
+        """
+        Create an ephemeral API token for use in client-side applications with the
+        Realtime API specifically for realtime transcriptions. Can be configured with
+        the same session parameters as the `transcription_session.update` client event.
+
+        It responds with a session object, plus a `client_secret` key which contains a
+        usable ephemeral API token that can be used to authenticate browser clients for
+        the Realtime API.
+
+        Args:
+          client_secret: Configuration options for the generated client secret.
+
+          include:
+              The set of items to include in the transcription. Current available items are:
+
+              - `item.input_audio_transcription.logprobs`
+
+          input_audio_format: The format of input audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. For
+              `pcm16`, input audio must be 16-bit PCM at a 24kHz sample rate, single channel
+              (mono), and little-endian byte order.
+
+          input_audio_noise_reduction: Configuration for input audio noise reduction. This can be set to `null` to turn
+              off. Noise reduction filters audio added to the input audio buffer before it is
+              sent to VAD and the model. Filtering the audio can improve VAD and turn
+              detection accuracy (reducing false positives) and model performance by improving
+              perception of the input audio.
+
+          input_audio_transcription: Configuration for input audio transcription. The client can optionally set the
+              language and prompt for transcription, these offer additional guidance to the
+              transcription service.
+
+          modalities: The set of modalities the model can respond with. To disable audio, set this to
+              ["text"].
+
+          turn_detection: Configuration for turn detection, ether Server VAD or Semantic VAD. This can be
+              set to `null` to turn off, in which case the client must manually trigger model
+              response. Server VAD means that the model will detect the start and end of
+              speech based on audio volume and respond at the end of user speech. Semantic VAD
+              is more advanced and uses a turn detection model (in conjunction with VAD) to
+              semantically estimate whether the user has finished speaking, then dynamically
+              sets a timeout based on this probability. For example, if user audio trails off
+              with "uhhm", the model will score a low probability of turn end and wait longer
+              for the user to continue speaking. This can be useful for more natural
+              conversations, but may have a higher latency.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"OpenAI-Beta": "assistants=v2", **(extra_headers or {})}
+        return await self._post(
+            "/realtime/transcription_sessions",
+            body=await async_maybe_transform(
+                {
+                    "client_secret": client_secret,
+                    "include": include,
+                    "input_audio_format": input_audio_format,
+                    "input_audio_noise_reduction": input_audio_noise_reduction,
+                    "input_audio_transcription": input_audio_transcription,
+                    "modalities": modalities,
+                    "turn_detection": turn_detection,
+                },
+                transcription_session_create_params.TranscriptionSessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TranscriptionSession,
+        )
+
+
+class TranscriptionSessionsWithRawResponse:
+    def __init__(self, transcription_sessions: TranscriptionSessions) -> None:
+        self._transcription_sessions = transcription_sessions
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            transcription_sessions.create,
+        )
+
+
+class AsyncTranscriptionSessionsWithRawResponse:
+    def __init__(self, transcription_sessions: AsyncTranscriptionSessions) -> None:
+        self._transcription_sessions = transcription_sessions
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            transcription_sessions.create,
+        )
+
+
+class TranscriptionSessionsWithStreamingResponse:
+    def __init__(self, transcription_sessions: TranscriptionSessions) -> None:
+        self._transcription_sessions = transcription_sessions
+
+        self.create = to_streamed_response_wrapper(
+            transcription_sessions.create,
+        )
+
+
+class AsyncTranscriptionSessionsWithStreamingResponse:
+    def __init__(self, transcription_sessions: AsyncTranscriptionSessions) -> None:
+        self._transcription_sessions = transcription_sessions
+
+        self.create = async_to_streamed_response_wrapper(
+            transcription_sessions.create,
+        )
diff --git a/src/openai/resources/beta/threads/messages.py b/src/openai/resources/beta/threads/messages.py
index e3374aba37..d94ecca9a2 100644
--- a/src/openai/resources/beta/threads/messages.py
+++ b/src/openai/resources/beta/threads/messages.py
@@ -2,17 +2,15 @@
 
 from __future__ import annotations
 
+import typing_extensions
 from typing import Union, Iterable, Optional
 from typing_extensions import Literal
 
 import httpx
 
 from .... import _legacy_response
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ...._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform, async_maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
 from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -50,20 +48,21 @@ def with_streaming_response(self) -> MessagesWithStreamingResponse:
         """
         return MessagesWithStreamingResponse(self)
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create(
         self,
         thread_id: str,
         *,
         content: Union[str, Iterable[MessageContentPartParam]],
         role: Literal["user", "assistant"],
-        attachments: Optional[Iterable[message_create_params.Attachment]] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        attachments: Optional[Iterable[message_create_params.Attachment]] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Message:
         """
         Create a message.
@@ -116,6 +115,7 @@ def create(
             cast_to=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def retrieve(
         self,
         message_id: str,
@@ -126,7 +126,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Message:
         """
         Retrieve a message.
@@ -153,18 +153,19 @@ def retrieve(
             cast_to=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def update(
         self,
         message_id: str,
         *,
         thread_id: str,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Message:
         """
         Modifies a message.
@@ -199,21 +200,22 @@ def update(
             cast_to=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def list(
         self,
         thread_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
-        run_id: str | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        run_id: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[Message]:
         """
         Returns a list of messages for a given thread.
@@ -270,6 +272,7 @@ def list(
             model=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def delete(
         self,
         message_id: str,
@@ -280,7 +283,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> MessageDeleted:
         """
         Deletes a message.
@@ -328,20 +331,21 @@ def with_streaming_response(self) -> AsyncMessagesWithStreamingResponse:
         """
         return AsyncMessagesWithStreamingResponse(self)
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create(
         self,
         thread_id: str,
         *,
         content: Union[str, Iterable[MessageContentPartParam]],
         role: Literal["user", "assistant"],
-        attachments: Optional[Iterable[message_create_params.Attachment]] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        attachments: Optional[Iterable[message_create_params.Attachment]] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Message:
         """
         Create a message.
@@ -394,6 +398,7 @@ async def create(
             cast_to=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def retrieve(
         self,
         message_id: str,
@@ -404,7 +409,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Message:
         """
         Retrieve a message.
@@ -431,18 +436,19 @@ async def retrieve(
             cast_to=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def update(
         self,
         message_id: str,
         *,
         thread_id: str,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Message:
         """
         Modifies a message.
@@ -477,21 +483,22 @@ async def update(
             cast_to=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def list(
         self,
         thread_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
-        run_id: str | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        run_id: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[Message, AsyncCursorPage[Message]]:
         """
         Returns a list of messages for a given thread.
@@ -548,6 +555,7 @@ def list(
             model=Message,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def delete(
         self,
         message_id: str,
@@ -558,7 +566,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> MessageDeleted:
         """
         Deletes a message.
@@ -590,20 +598,30 @@ class MessagesWithRawResponse:
     def __init__(self, messages: Messages) -> None:
         self._messages = messages
 
-        self.create = _legacy_response.to_raw_response_wrapper(
-            messages.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                messages.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = _legacy_response.to_raw_response_wrapper(
-            messages.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                messages.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = _legacy_response.to_raw_response_wrapper(
-            messages.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                messages.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = _legacy_response.to_raw_response_wrapper(
-            messages.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                messages.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = _legacy_response.to_raw_response_wrapper(
-            messages.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                messages.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
 
 
@@ -611,20 +629,30 @@ class AsyncMessagesWithRawResponse:
     def __init__(self, messages: AsyncMessages) -> None:
         self._messages = messages
 
-        self.create = _legacy_response.async_to_raw_response_wrapper(
-            messages.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                messages.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
-            messages.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                messages.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = _legacy_response.async_to_raw_response_wrapper(
-            messages.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                messages.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = _legacy_response.async_to_raw_response_wrapper(
-            messages.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                messages.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = _legacy_response.async_to_raw_response_wrapper(
-            messages.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                messages.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
 
 
@@ -632,20 +660,30 @@ class MessagesWithStreamingResponse:
     def __init__(self, messages: Messages) -> None:
         self._messages = messages
 
-        self.create = to_streamed_response_wrapper(
-            messages.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                messages.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = to_streamed_response_wrapper(
-            messages.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                messages.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = to_streamed_response_wrapper(
-            messages.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                messages.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = to_streamed_response_wrapper(
-            messages.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                messages.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = to_streamed_response_wrapper(
-            messages.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                messages.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
 
 
@@ -653,18 +691,28 @@ class AsyncMessagesWithStreamingResponse:
     def __init__(self, messages: AsyncMessages) -> None:
         self._messages = messages
 
-        self.create = async_to_streamed_response_wrapper(
-            messages.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                messages.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = async_to_streamed_response_wrapper(
-            messages.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                messages.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = async_to_streamed_response_wrapper(
-            messages.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                messages.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = async_to_streamed_response_wrapper(
-            messages.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                messages.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = async_to_streamed_response_wrapper(
-            messages.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                messages.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
diff --git a/src/openai/resources/beta/threads/runs/runs.py b/src/openai/resources/beta/threads/runs/runs.py
index acb1c9b261..d7445d52b5 100644
--- a/src/openai/resources/beta/threads/runs/runs.py
+++ b/src/openai/resources/beta/threads/runs/runs.py
@@ -18,7 +18,7 @@
     StepsWithStreamingResponse,
     AsyncStepsWithStreamingResponse,
 )
-from ....._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ....._types import NOT_GIVEN, Body, Omit, Query, Headers, NotGiven, omit, not_given
 from ....._utils import (
     is_given,
     required_args,
@@ -83,34 +83,35 @@ def with_streaming_response(self) -> RunsWithStreamingResponse:
         return RunsWithStreamingResponse(self)
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Create a run.
@@ -166,12 +167,18 @@ def create(
               [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
               during tool use.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -220,7 +227,7 @@ def create(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -233,34 +240,35 @@ def create(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
         stream: Literal[True],
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Stream[AssistantStreamEvent]:
         """
         Create a run.
@@ -320,12 +328,18 @@ def create(
               [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
               during tool use.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -370,7 +384,7 @@ def create(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -383,34 +397,35 @@ def create(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
         stream: bool,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | Stream[AssistantStreamEvent]:
         """
         Create a run.
@@ -470,12 +485,18 @@ def create(
               [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
               during tool use.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -520,7 +541,7 @@ def create(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -532,35 +553,36 @@ def create(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     @required_args(["assistant_id"], ["assistant_id", "stream"])
     def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | Stream[AssistantStreamEvent]:
         if not thread_id:
             raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
@@ -587,7 +609,7 @@ def create(
                     "top_p": top_p,
                     "truncation_strategy": truncation_strategy,
                 },
-                run_create_params.RunCreateParams,
+                run_create_params.RunCreateParamsStreaming if stream else run_create_params.RunCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -601,6 +623,7 @@ def create(
             stream_cls=Stream[AssistantStreamEvent],
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def retrieve(
         self,
         run_id: str,
@@ -611,7 +634,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Retrieves a run.
@@ -638,18 +661,19 @@ def retrieve(
             cast_to=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def update(
         self,
         run_id: str,
         *,
         thread_id: str,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Modifies a run.
@@ -684,20 +708,21 @@ def update(
             cast_to=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def list(
         self,
         thread_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[Run]:
         """
         Returns a list of runs belonging to a thread.
@@ -751,6 +776,7 @@ def list(
             model=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def cancel(
         self,
         run_id: str,
@@ -761,7 +787,7 @@ def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Cancels a run that is `in_progress`.
@@ -788,27 +814,28 @@ def cancel(
             cast_to=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create_and_poll(
         self,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
         thread_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -822,7 +849,7 @@ def create_and_poll(
         lifecycles can be found here:
         https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps
         """
-        run = self.create(
+        run = self.create(  # pyright: ignore[reportDeprecated]
             thread_id=thread_id,
             assistant_id=assistant_id,
             include=include,
@@ -848,7 +875,7 @@ def create_and_poll(
             extra_body=extra_body,
             timeout=timeout,
         )
-        return self.poll(
+        return self.poll(  # pyright: ignore[reportDeprecated]
             run.id,
             thread_id=thread_id,
             extra_headers=extra_headers,
@@ -864,21 +891,21 @@ def create_and_stream(
         self,
         *,
         assistant_id: str,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -896,21 +923,21 @@ def create_and_stream(
         self,
         *,
         assistant_id: str,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AssistantEventHandlerT,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -928,21 +955,21 @@ def create_and_stream(
         self,
         *,
         assistant_id: str,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AssistantEventHandlerT | None = None,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -996,6 +1023,7 @@ def create_and_stream(
         )
         return AssistantStreamManager(make_request, event_handler=event_handler or AssistantEventHandler())
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def poll(
         self,
         run_id: str,
@@ -1003,8 +1031,8 @@ def poll(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+        poll_interval_ms: int | Omit = omit,
     ) -> Run:
         """
         A helper to poll a run status until it reaches a terminal state. More
@@ -1018,7 +1046,7 @@ def poll(
 
         terminal_states = {"requires_action", "cancelled", "completed", "failed", "expired", "incomplete"}
         while True:
-            response = self.with_raw_response.retrieve(
+            response = self.with_raw_response.retrieve(  # pyright: ignore[reportDeprecated]
                 thread_id=thread_id,
                 run_id=run_id,
                 extra_headers=extra_headers,
@@ -1042,26 +1070,27 @@ def poll(
             self._sleep(poll_interval_ms / 1000)
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def stream(
         self,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -1074,26 +1103,27 @@ def stream(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def stream(
         self,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AssistantEventHandlerT,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -1106,26 +1136,27 @@ def stream(
         """Create a Run stream"""
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def stream(
         self,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AssistantEventHandlerT | None = None,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -1184,19 +1215,20 @@ def stream(
         return AssistantStreamManager(make_request, event_handler=event_handler or AssistantEventHandler())
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs(
         self,
         run_id: str,
         *,
         thread_id: str,
         tool_outputs: Iterable[run_submit_tool_outputs_params.ToolOutput],
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         When a run has the `status: "requires_action"` and `required_action.type` is
@@ -1222,6 +1254,7 @@ def submit_tool_outputs(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs(
         self,
         run_id: str,
@@ -1234,7 +1267,7 @@ def submit_tool_outputs(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Stream[AssistantStreamEvent]:
         """
         When a run has the `status: "requires_action"` and `required_action.type` is
@@ -1260,6 +1293,7 @@ def submit_tool_outputs(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs(
         self,
         run_id: str,
@@ -1272,7 +1306,7 @@ def submit_tool_outputs(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | Stream[AssistantStreamEvent]:
         """
         When a run has the `status: "requires_action"` and `required_action.type` is
@@ -1297,20 +1331,22 @@ def submit_tool_outputs(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     @required_args(["thread_id", "tool_outputs"], ["thread_id", "stream", "tool_outputs"])
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs(
         self,
         run_id: str,
         *,
         thread_id: str,
         tool_outputs: Iterable[run_submit_tool_outputs_params.ToolOutput],
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | Stream[AssistantStreamEvent]:
         if not thread_id:
             raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
@@ -1324,7 +1360,9 @@ def submit_tool_outputs(
                     "tool_outputs": tool_outputs,
                     "stream": stream,
                 },
-                run_submit_tool_outputs_params.RunSubmitToolOutputsParams,
+                run_submit_tool_outputs_params.RunSubmitToolOutputsParamsStreaming
+                if stream
+                else run_submit_tool_outputs_params.RunSubmitToolOutputsParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -1334,13 +1372,14 @@ def submit_tool_outputs(
             stream_cls=Stream[AssistantStreamEvent],
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs_and_poll(
         self,
         *,
         tool_outputs: Iterable[run_submit_tool_outputs_params.ToolOutput],
         run_id: str,
         thread_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        poll_interval_ms: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -1353,7 +1392,7 @@ def submit_tool_outputs_and_poll(
         More information on Run lifecycles can be found here:
         https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps
         """
-        run = self.submit_tool_outputs(
+        run = self.submit_tool_outputs(  # pyright: ignore[reportDeprecated]
             run_id=run_id,
             thread_id=thread_id,
             tool_outputs=tool_outputs,
@@ -1363,7 +1402,7 @@ def submit_tool_outputs_and_poll(
             extra_body=extra_body,
             timeout=timeout,
         )
-        return self.poll(
+        return self.poll(  # pyright: ignore[reportDeprecated]
             run_id=run.id,
             thread_id=thread_id,
             extra_headers=extra_headers,
@@ -1374,6 +1413,7 @@ def submit_tool_outputs_and_poll(
         )
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs_stream(
         self,
         *,
@@ -1395,6 +1435,7 @@ def submit_tool_outputs_stream(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs_stream(
         self,
         *,
@@ -1416,6 +1457,7 @@ def submit_tool_outputs_stream(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs_stream(
         self,
         *,
@@ -1492,34 +1534,35 @@ def with_streaming_response(self) -> AsyncRunsWithStreamingResponse:
         return AsyncRunsWithStreamingResponse(self)
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Create a run.
@@ -1575,12 +1618,18 @@ async def create(
               [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
               during tool use.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -1629,7 +1678,7 @@ async def create(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -1642,34 +1691,35 @@ async def create(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
         stream: Literal[True],
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncStream[AssistantStreamEvent]:
         """
         Create a run.
@@ -1729,12 +1779,18 @@ async def create(
               [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
               during tool use.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -1779,7 +1835,7 @@ async def create(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -1792,34 +1848,35 @@ async def create(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
         stream: bool,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | AsyncStream[AssistantStreamEvent]:
         """
         Create a run.
@@ -1879,12 +1936,18 @@ async def create(
               [parallel function calling](https://platform.openai.com/docs/guides/function-calling#configuring-parallel-function-calling)
               during tool use.
 
-          reasoning_effort: **o-series models only**
-
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: Specifies the format that the model must output. Compatible with
               [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -1929,7 +1992,7 @@ async def create(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -1941,35 +2004,37 @@ async def create(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     @required_args(["assistant_id"], ["assistant_id", "stream"])
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create(
         self,
         thread_id: str,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | AsyncStream[AssistantStreamEvent]:
         if not thread_id:
             raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
@@ -1996,7 +2061,7 @@ async def create(
                     "top_p": top_p,
                     "truncation_strategy": truncation_strategy,
                 },
-                run_create_params.RunCreateParams,
+                run_create_params.RunCreateParamsStreaming if stream else run_create_params.RunCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -2010,6 +2075,7 @@ async def create(
             stream_cls=AsyncStream[AssistantStreamEvent],
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def retrieve(
         self,
         run_id: str,
@@ -2020,7 +2086,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Retrieves a run.
@@ -2047,18 +2113,19 @@ async def retrieve(
             cast_to=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def update(
         self,
         run_id: str,
         *,
         thread_id: str,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Modifies a run.
@@ -2093,20 +2160,21 @@ async def update(
             cast_to=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def list(
         self,
         thread_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[Run, AsyncCursorPage[Run]]:
         """
         Returns a list of runs belonging to a thread.
@@ -2160,6 +2228,7 @@ def list(
             model=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def cancel(
         self,
         run_id: str,
@@ -2170,7 +2239,7 @@ async def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Cancels a run that is `in_progress`.
@@ -2197,27 +2266,28 @@ async def cancel(
             cast_to=Run,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create_and_poll(
         self,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
         thread_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -2231,7 +2301,7 @@ async def create_and_poll(
         lifecycles can be found here:
         https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps
         """
-        run = await self.create(
+        run = await self.create(  # pyright: ignore[reportDeprecated]
             thread_id=thread_id,
             assistant_id=assistant_id,
             include=include,
@@ -2257,7 +2327,7 @@ async def create_and_poll(
             extra_body=extra_body,
             timeout=timeout,
         )
-        return await self.poll(
+        return await self.poll(  # pyright: ignore[reportDeprecated]
             run.id,
             thread_id=thread_id,
             extra_headers=extra_headers,
@@ -2273,20 +2343,20 @@ def create_and_stream(
         self,
         *,
         assistant_id: str,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -2304,20 +2374,20 @@ def create_and_stream(
         self,
         *,
         assistant_id: str,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AsyncAssistantEventHandlerT,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -2335,20 +2405,20 @@ def create_and_stream(
         self,
         *,
         assistant_id: str,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AsyncAssistantEventHandlerT | None = None,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -2403,6 +2473,7 @@ def create_and_stream(
         )
         return AsyncAssistantStreamManager(request, event_handler=event_handler or AsyncAssistantEventHandler())
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def poll(
         self,
         run_id: str,
@@ -2410,8 +2481,8 @@ async def poll(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+        poll_interval_ms: int | Omit = omit,
     ) -> Run:
         """
         A helper to poll a run status until it reaches a terminal state. More
@@ -2425,7 +2496,7 @@ async def poll(
 
         terminal_states = {"requires_action", "cancelled", "completed", "failed", "expired", "incomplete"}
         while True:
-            response = await self.with_raw_response.retrieve(
+            response = await self.with_raw_response.retrieve(  # pyright: ignore[reportDeprecated]
                 thread_id=thread_id,
                 run_id=run_id,
                 extra_headers=extra_headers,
@@ -2449,25 +2520,26 @@ async def poll(
             await self._sleep(poll_interval_ms / 1000)
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def stream(
         self,
         *,
         assistant_id: str,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -2480,26 +2552,27 @@ def stream(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def stream(
         self,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AsyncAssistantEventHandlerT,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -2512,26 +2585,27 @@ def stream(
         """Create a Run stream"""
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def stream(
         self,
         *,
         assistant_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        additional_instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[AssistantToolParam]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[run_create_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
+        additional_instructions: Optional[str] | Omit = omit,
+        additional_messages: Optional[Iterable[run_create_params.AdditionalMessage]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[run_create_params.TruncationStrategy] | Omit = omit,
         thread_id: str,
         event_handler: AsyncAssistantEventHandlerT | None = None,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -2592,19 +2666,20 @@ def stream(
         return AsyncAssistantStreamManager(request, event_handler=event_handler or AsyncAssistantEventHandler())
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def submit_tool_outputs(
         self,
         run_id: str,
         *,
         thread_id: str,
         tool_outputs: Iterable[run_submit_tool_outputs_params.ToolOutput],
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         When a run has the `status: "requires_action"` and `required_action.type` is
@@ -2630,6 +2705,7 @@ async def submit_tool_outputs(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def submit_tool_outputs(
         self,
         run_id: str,
@@ -2642,7 +2718,7 @@ async def submit_tool_outputs(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncStream[AssistantStreamEvent]:
         """
         When a run has the `status: "requires_action"` and `required_action.type` is
@@ -2668,6 +2744,7 @@ async def submit_tool_outputs(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def submit_tool_outputs(
         self,
         run_id: str,
@@ -2680,7 +2757,7 @@ async def submit_tool_outputs(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | AsyncStream[AssistantStreamEvent]:
         """
         When a run has the `status: "requires_action"` and `required_action.type` is
@@ -2705,20 +2782,22 @@ async def submit_tool_outputs(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     @required_args(["thread_id", "tool_outputs"], ["thread_id", "stream", "tool_outputs"])
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def submit_tool_outputs(
         self,
         run_id: str,
         *,
         thread_id: str,
         tool_outputs: Iterable[run_submit_tool_outputs_params.ToolOutput],
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | AsyncStream[AssistantStreamEvent]:
         if not thread_id:
             raise ValueError(f"Expected a non-empty value for `thread_id` but received {thread_id!r}")
@@ -2732,7 +2811,9 @@ async def submit_tool_outputs(
                     "tool_outputs": tool_outputs,
                     "stream": stream,
                 },
-                run_submit_tool_outputs_params.RunSubmitToolOutputsParams,
+                run_submit_tool_outputs_params.RunSubmitToolOutputsParamsStreaming
+                if stream
+                else run_submit_tool_outputs_params.RunSubmitToolOutputsParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -2742,13 +2823,14 @@ async def submit_tool_outputs(
             stream_cls=AsyncStream[AssistantStreamEvent],
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def submit_tool_outputs_and_poll(
         self,
         *,
         tool_outputs: Iterable[run_submit_tool_outputs_params.ToolOutput],
         run_id: str,
         thread_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        poll_interval_ms: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -2761,7 +2843,7 @@ async def submit_tool_outputs_and_poll(
         More information on Run lifecycles can be found here:
         https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps
         """
-        run = await self.submit_tool_outputs(
+        run = await self.submit_tool_outputs(  # pyright: ignore[reportDeprecated]
             run_id=run_id,
             thread_id=thread_id,
             tool_outputs=tool_outputs,
@@ -2771,7 +2853,7 @@ async def submit_tool_outputs_and_poll(
             extra_body=extra_body,
             timeout=timeout,
         )
-        return await self.poll(
+        return await self.poll(  # pyright: ignore[reportDeprecated]
             run_id=run.id,
             thread_id=thread_id,
             extra_headers=extra_headers,
@@ -2782,6 +2864,7 @@ async def submit_tool_outputs_and_poll(
         )
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs_stream(
         self,
         *,
@@ -2803,6 +2886,7 @@ def submit_tool_outputs_stream(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs_stream(
         self,
         *,
@@ -2824,6 +2908,7 @@ def submit_tool_outputs_stream(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def submit_tool_outputs_stream(
         self,
         *,
@@ -2881,23 +2966,35 @@ class RunsWithRawResponse:
     def __init__(self, runs: Runs) -> None:
         self._runs = runs
 
-        self.create = _legacy_response.to_raw_response_wrapper(
-            runs.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                runs.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = _legacy_response.to_raw_response_wrapper(
-            runs.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                runs.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = _legacy_response.to_raw_response_wrapper(
-            runs.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                runs.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = _legacy_response.to_raw_response_wrapper(
-            runs.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                runs.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.cancel = _legacy_response.to_raw_response_wrapper(
-            runs.cancel,
+        self.cancel = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                runs.cancel,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.submit_tool_outputs = _legacy_response.to_raw_response_wrapper(
-            runs.submit_tool_outputs,
+        self.submit_tool_outputs = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                runs.submit_tool_outputs,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
@@ -2909,23 +3006,35 @@ class AsyncRunsWithRawResponse:
     def __init__(self, runs: AsyncRuns) -> None:
         self._runs = runs
 
-        self.create = _legacy_response.async_to_raw_response_wrapper(
-            runs.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                runs.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
-            runs.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                runs.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = _legacy_response.async_to_raw_response_wrapper(
-            runs.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                runs.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = _legacy_response.async_to_raw_response_wrapper(
-            runs.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                runs.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.cancel = _legacy_response.async_to_raw_response_wrapper(
-            runs.cancel,
+        self.cancel = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                runs.cancel,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.submit_tool_outputs = _legacy_response.async_to_raw_response_wrapper(
-            runs.submit_tool_outputs,
+        self.submit_tool_outputs = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                runs.submit_tool_outputs,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
@@ -2937,23 +3046,35 @@ class RunsWithStreamingResponse:
     def __init__(self, runs: Runs) -> None:
         self._runs = runs
 
-        self.create = to_streamed_response_wrapper(
-            runs.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                runs.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = to_streamed_response_wrapper(
-            runs.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                runs.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = to_streamed_response_wrapper(
-            runs.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                runs.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = to_streamed_response_wrapper(
-            runs.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                runs.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.cancel = to_streamed_response_wrapper(
-            runs.cancel,
+        self.cancel = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                runs.cancel,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.submit_tool_outputs = to_streamed_response_wrapper(
-            runs.submit_tool_outputs,
+        self.submit_tool_outputs = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                runs.submit_tool_outputs,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
@@ -2965,23 +3086,35 @@ class AsyncRunsWithStreamingResponse:
     def __init__(self, runs: AsyncRuns) -> None:
         self._runs = runs
 
-        self.create = async_to_streamed_response_wrapper(
-            runs.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                runs.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = async_to_streamed_response_wrapper(
-            runs.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                runs.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = async_to_streamed_response_wrapper(
-            runs.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                runs.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = async_to_streamed_response_wrapper(
-            runs.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                runs.list,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.cancel = async_to_streamed_response_wrapper(
-            runs.cancel,
+        self.cancel = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                runs.cancel,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.submit_tool_outputs = async_to_streamed_response_wrapper(
-            runs.submit_tool_outputs,
+        self.submit_tool_outputs = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                runs.submit_tool_outputs,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
diff --git a/src/openai/resources/beta/threads/runs/steps.py b/src/openai/resources/beta/threads/runs/steps.py
index 709c729d45..254a94435c 100644
--- a/src/openai/resources/beta/threads/runs/steps.py
+++ b/src/openai/resources/beta/threads/runs/steps.py
@@ -2,17 +2,15 @@
 
 from __future__ import annotations
 
+import typing_extensions
 from typing import List
 from typing_extensions import Literal
 
 import httpx
 
 from ..... import _legacy_response
-from ....._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ....._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ....._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ....._utils import maybe_transform, async_maybe_transform
 from ....._compat import cached_property
 from ....._resource import SyncAPIResource, AsyncAPIResource
 from ....._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -45,19 +43,20 @@ def with_streaming_response(self) -> StepsWithStreamingResponse:
         """
         return StepsWithStreamingResponse(self)
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def retrieve(
         self,
         step_id: str,
         *,
         thread_id: str,
         run_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> RunStep:
         """
         Retrieves a run step.
@@ -98,22 +97,23 @@ def retrieve(
             cast_to=RunStep,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def list(
         self,
         run_id: str,
         *,
         thread_id: str,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        include: List[RunStepInclude] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[RunStep]:
         """
         Returns a list of run steps belonging to a run.
@@ -199,19 +199,20 @@ def with_streaming_response(self) -> AsyncStepsWithStreamingResponse:
         """
         return AsyncStepsWithStreamingResponse(self)
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def retrieve(
         self,
         step_id: str,
         *,
         thread_id: str,
         run_id: str,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
+        include: List[RunStepInclude] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> RunStep:
         """
         Retrieves a run step.
@@ -252,22 +253,23 @@ async def retrieve(
             cast_to=RunStep,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def list(
         self,
         run_id: str,
         *,
         thread_id: str,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        include: List[RunStepInclude] | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        include: List[RunStepInclude] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[RunStep, AsyncCursorPage[RunStep]]:
         """
         Returns a list of run steps belonging to a run.
@@ -337,11 +339,15 @@ class StepsWithRawResponse:
     def __init__(self, steps: Steps) -> None:
         self._steps = steps
 
-        self.retrieve = _legacy_response.to_raw_response_wrapper(
-            steps.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                steps.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = _legacy_response.to_raw_response_wrapper(
-            steps.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                steps.list,  # pyright: ignore[reportDeprecated],
+            )
         )
 
 
@@ -349,11 +355,15 @@ class AsyncStepsWithRawResponse:
     def __init__(self, steps: AsyncSteps) -> None:
         self._steps = steps
 
-        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
-            steps.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                steps.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = _legacy_response.async_to_raw_response_wrapper(
-            steps.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                steps.list,  # pyright: ignore[reportDeprecated],
+            )
         )
 
 
@@ -361,11 +371,15 @@ class StepsWithStreamingResponse:
     def __init__(self, steps: Steps) -> None:
         self._steps = steps
 
-        self.retrieve = to_streamed_response_wrapper(
-            steps.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                steps.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = to_streamed_response_wrapper(
-            steps.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                steps.list,  # pyright: ignore[reportDeprecated],
+            )
         )
 
 
@@ -373,9 +387,13 @@ class AsyncStepsWithStreamingResponse:
     def __init__(self, steps: AsyncSteps) -> None:
         self._steps = steps
 
-        self.retrieve = async_to_streamed_response_wrapper(
-            steps.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                steps.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.list = async_to_streamed_response_wrapper(
-            steps.list,
+        self.list = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                steps.list,  # pyright: ignore[reportDeprecated],
+            )
         )
diff --git a/src/openai/resources/beta/threads/threads.py b/src/openai/resources/beta/threads/threads.py
index d88559bdeb..681d3c2933 100644
--- a/src/openai/resources/beta/threads/threads.py
+++ b/src/openai/resources/beta/threads/threads.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import typing_extensions
 from typing import Union, Iterable, Optional
 from functools import partial
 from typing_extensions import Literal, overload
@@ -17,12 +18,8 @@
     MessagesWithStreamingResponse,
     AsyncMessagesWithStreamingResponse,
 )
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ...._utils import (
-    required_args,
-    maybe_transform,
-    async_maybe_transform,
-)
+from ...._types import NOT_GIVEN, Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import required_args, maybe_transform, async_maybe_transform
 from .runs.runs import (
     Runs,
     AsyncRuns,
@@ -54,6 +51,7 @@
 from ....types.shared.chat_model import ChatModel
 from ....types.beta.thread_deleted import ThreadDeleted
 from ....types.shared_params.metadata import Metadata
+from ....types.beta.assistant_tool_param import AssistantToolParam
 from ....types.beta.assistant_stream_event import AssistantStreamEvent
 from ....types.beta.assistant_tool_choice_option_param import AssistantToolChoiceOptionParam
 from ....types.beta.assistant_response_format_option_param import AssistantResponseFormatOptionParam
@@ -89,18 +87,19 @@ def with_streaming_response(self) -> ThreadsWithStreamingResponse:
         """
         return ThreadsWithStreamingResponse(self)
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create(
         self,
         *,
-        messages: Iterable[thread_create_params.Message] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_params.ToolResources] | NotGiven = NOT_GIVEN,
+        messages: Iterable[thread_create_params.Message] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        tool_resources: Optional[thread_create_params.ToolResources] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Thread:
         """
         Create a thread.
@@ -146,6 +145,7 @@ def create(
             cast_to=Thread,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def retrieve(
         self,
         thread_id: str,
@@ -155,7 +155,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Thread:
         """
         Retrieves a thread.
@@ -180,18 +180,19 @@ def retrieve(
             cast_to=Thread,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def update(
         self,
         thread_id: str,
         *,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_update_params.ToolResources] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
+        tool_resources: Optional[thread_update_params.ToolResources] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Thread:
         """
         Modifies a thread.
@@ -235,6 +236,7 @@ def update(
             cast_to=Thread,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def delete(
         self,
         thread_id: str,
@@ -244,7 +246,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ThreadDeleted:
         """
         Delete a thread.
@@ -270,31 +272,32 @@ def delete(
         )
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create_and_run(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Create a thread and run it in one request.
@@ -390,7 +393,7 @@ def create_and_run(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -403,31 +406,32 @@ def create_and_run(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create_and_run(
         self,
         *,
         assistant_id: str,
         stream: Literal[True],
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Stream[AssistantStreamEvent]:
         """
         Create a thread and run it in one request.
@@ -523,7 +527,7 @@ def create_and_run(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -536,31 +540,32 @@ def create_and_run(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create_and_run(
         self,
         *,
         assistant_id: str,
         stream: bool,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | Stream[AssistantStreamEvent]:
         """
         Create a thread and run it in one request.
@@ -656,7 +661,7 @@ def create_and_run(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -668,32 +673,34 @@ def create_and_run(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     @required_args(["assistant_id"], ["assistant_id", "stream"])
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     def create_and_run(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | Stream[AssistantStreamEvent]:
         extra_headers = {"OpenAI-Beta": "assistants=v2", **(extra_headers or {})}
         return self._post(
@@ -717,7 +724,9 @@ def create_and_run(
                     "top_p": top_p,
                     "truncation_strategy": truncation_strategy,
                 },
-                thread_create_and_run_params.ThreadCreateAndRunParams,
+                thread_create_and_run_params.ThreadCreateAndRunParamsStreaming
+                if stream
+                else thread_create_and_run_params.ThreadCreateAndRunParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -731,21 +740,21 @@ def create_and_run_poll(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -758,7 +767,7 @@ def create_and_run_poll(
         More information on Run lifecycles can be found here:
         https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps
         """
-        run = self.create_and_run(
+        run = self.create_and_run(  # pyright: ignore[reportDeprecated]
             assistant_id=assistant_id,
             instructions=instructions,
             max_completion_tokens=max_completion_tokens,
@@ -780,27 +789,27 @@ def create_and_run_poll(
             extra_body=extra_body,
             timeout=timeout,
         )
-        return self.runs.poll(run.id, run.thread_id, extra_headers, extra_query, extra_body, timeout, poll_interval_ms)
+        return self.runs.poll(run.id, run.thread_id, extra_headers, extra_query, extra_body, timeout, poll_interval_ms)  # pyright: ignore[reportDeprecated]
 
     @overload
     def create_and_run_stream(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -816,20 +825,20 @@ def create_and_run_stream(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         event_handler: AssistantEventHandlerT,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -845,20 +854,20 @@ def create_and_run_stream(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         event_handler: AssistantEventHandlerT | None = None,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -936,18 +945,19 @@ def with_streaming_response(self) -> AsyncThreadsWithStreamingResponse:
         """
         return AsyncThreadsWithStreamingResponse(self)
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create(
         self,
         *,
-        messages: Iterable[thread_create_params.Message] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_params.ToolResources] | NotGiven = NOT_GIVEN,
+        messages: Iterable[thread_create_params.Message] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        tool_resources: Optional[thread_create_params.ToolResources] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Thread:
         """
         Create a thread.
@@ -993,6 +1003,7 @@ async def create(
             cast_to=Thread,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def retrieve(
         self,
         thread_id: str,
@@ -1002,7 +1013,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Thread:
         """
         Retrieves a thread.
@@ -1027,18 +1038,19 @@ async def retrieve(
             cast_to=Thread,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def update(
         self,
         thread_id: str,
         *,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_update_params.ToolResources] | NotGiven = NOT_GIVEN,
+        metadata: Optional[Metadata] | Omit = omit,
+        tool_resources: Optional[thread_update_params.ToolResources] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Thread:
         """
         Modifies a thread.
@@ -1082,6 +1094,7 @@ async def update(
             cast_to=Thread,
         )
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def delete(
         self,
         thread_id: str,
@@ -1091,7 +1104,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ThreadDeleted:
         """
         Delete a thread.
@@ -1117,31 +1130,32 @@ async def delete(
         )
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create_and_run(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run:
         """
         Create a thread and run it in one request.
@@ -1237,7 +1251,7 @@ async def create_and_run(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -1250,31 +1264,32 @@ async def create_and_run(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create_and_run(
         self,
         *,
         assistant_id: str,
         stream: Literal[True],
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncStream[AssistantStreamEvent]:
         """
         Create a thread and run it in one request.
@@ -1370,7 +1385,7 @@ async def create_and_run(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -1383,31 +1398,32 @@ async def create_and_run(
         ...
 
     @overload
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create_and_run(
         self,
         *,
         assistant_id: str,
         stream: bool,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | AsyncStream[AssistantStreamEvent]:
         """
         Create a thread and run it in one request.
@@ -1503,7 +1519,7 @@ async def create_and_run(
               We generally recommend altering this or temperature but not both.
 
           truncation_strategy: Controls for how a thread will be truncated prior to the run. Use this to
-              control the intial context window of the run.
+              control the initial context window of the run.
 
           extra_headers: Send extra headers
 
@@ -1515,32 +1531,34 @@ async def create_and_run(
         """
         ...
 
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     @required_args(["assistant_id"], ["assistant_id", "stream"])
+    @typing_extensions.deprecated("The Assistants API is deprecated in favor of the Responses API")
     async def create_and_run(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Run | AsyncStream[AssistantStreamEvent]:
         extra_headers = {"OpenAI-Beta": "assistants=v2", **(extra_headers or {})}
         return await self._post(
@@ -1564,7 +1582,9 @@ async def create_and_run(
                     "top_p": top_p,
                     "truncation_strategy": truncation_strategy,
                 },
-                thread_create_and_run_params.ThreadCreateAndRunParams,
+                thread_create_and_run_params.ThreadCreateAndRunParamsStreaming
+                if stream
+                else thread_create_and_run_params.ThreadCreateAndRunParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -1578,21 +1598,21 @@ async def create_and_run_poll(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -1605,7 +1625,7 @@ async def create_and_run_poll(
         More information on Run lifecycles can be found here:
         https://platform.openai.com/docs/assistants/how-it-works/runs-and-run-steps
         """
-        run = await self.create_and_run(
+        run = await self.create_and_run(  # pyright: ignore[reportDeprecated]
             assistant_id=assistant_id,
             instructions=instructions,
             max_completion_tokens=max_completion_tokens,
@@ -1627,7 +1647,7 @@ async def create_and_run_poll(
             extra_body=extra_body,
             timeout=timeout,
         )
-        return await self.runs.poll(
+        return await self.runs.poll(  # pyright: ignore[reportDeprecated]
             run.id, run.thread_id, extra_headers, extra_query, extra_body, timeout, poll_interval_ms
         )
 
@@ -1636,20 +1656,20 @@ def create_and_run_stream(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -1665,20 +1685,20 @@ def create_and_run_stream(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         event_handler: AsyncAssistantEventHandlerT,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -1694,20 +1714,20 @@ def create_and_run_stream(
         self,
         *,
         assistant_id: str,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_prompt_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: Union[str, ChatModel, None] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        response_format: Optional[AssistantResponseFormatOptionParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        thread: thread_create_and_run_params.Thread | NotGiven = NOT_GIVEN,
-        tool_choice: Optional[AssistantToolChoiceOptionParam] | NotGiven = NOT_GIVEN,
-        tool_resources: Optional[thread_create_and_run_params.ToolResources] | NotGiven = NOT_GIVEN,
-        tools: Optional[Iterable[thread_create_and_run_params.Tool]] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | NotGiven = NOT_GIVEN,
+        instructions: Optional[str] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_prompt_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: Union[str, ChatModel, None] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        response_format: Optional[AssistantResponseFormatOptionParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        thread: thread_create_and_run_params.Thread | Omit = omit,
+        tool_choice: Optional[AssistantToolChoiceOptionParam] | Omit = omit,
+        tool_resources: Optional[thread_create_and_run_params.ToolResources] | Omit = omit,
+        tools: Optional[Iterable[AssistantToolParam]] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation_strategy: Optional[thread_create_and_run_params.TruncationStrategy] | Omit = omit,
         event_handler: AsyncAssistantEventHandlerT | None = None,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -1763,20 +1783,30 @@ class ThreadsWithRawResponse:
     def __init__(self, threads: Threads) -> None:
         self._threads = threads
 
-        self.create = _legacy_response.to_raw_response_wrapper(
-            threads.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                threads.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = _legacy_response.to_raw_response_wrapper(
-            threads.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                threads.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = _legacy_response.to_raw_response_wrapper(
-            threads.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                threads.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = _legacy_response.to_raw_response_wrapper(
-            threads.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                threads.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.create_and_run = _legacy_response.to_raw_response_wrapper(
-            threads.create_and_run,
+        self.create_and_run = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.to_raw_response_wrapper(
+                threads.create_and_run,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
@@ -1792,20 +1822,30 @@ class AsyncThreadsWithRawResponse:
     def __init__(self, threads: AsyncThreads) -> None:
         self._threads = threads
 
-        self.create = _legacy_response.async_to_raw_response_wrapper(
-            threads.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                threads.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
-            threads.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                threads.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = _legacy_response.async_to_raw_response_wrapper(
-            threads.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                threads.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = _legacy_response.async_to_raw_response_wrapper(
-            threads.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                threads.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.create_and_run = _legacy_response.async_to_raw_response_wrapper(
-            threads.create_and_run,
+        self.create_and_run = (  # pyright: ignore[reportDeprecated]
+            _legacy_response.async_to_raw_response_wrapper(
+                threads.create_and_run,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
@@ -1821,20 +1861,30 @@ class ThreadsWithStreamingResponse:
     def __init__(self, threads: Threads) -> None:
         self._threads = threads
 
-        self.create = to_streamed_response_wrapper(
-            threads.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                threads.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = to_streamed_response_wrapper(
-            threads.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                threads.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = to_streamed_response_wrapper(
-            threads.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                threads.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = to_streamed_response_wrapper(
-            threads.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                threads.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.create_and_run = to_streamed_response_wrapper(
-            threads.create_and_run,
+        self.create_and_run = (  # pyright: ignore[reportDeprecated]
+            to_streamed_response_wrapper(
+                threads.create_and_run,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
@@ -1850,20 +1900,30 @@ class AsyncThreadsWithStreamingResponse:
     def __init__(self, threads: AsyncThreads) -> None:
         self._threads = threads
 
-        self.create = async_to_streamed_response_wrapper(
-            threads.create,
+        self.create = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                threads.create,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.retrieve = async_to_streamed_response_wrapper(
-            threads.retrieve,
+        self.retrieve = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                threads.retrieve,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.update = async_to_streamed_response_wrapper(
-            threads.update,
+        self.update = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                threads.update,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.delete = async_to_streamed_response_wrapper(
-            threads.delete,
+        self.delete = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                threads.delete,  # pyright: ignore[reportDeprecated],
+            )
         )
-        self.create_and_run = async_to_streamed_response_wrapper(
-            threads.create_and_run,
+        self.create_and_run = (  # pyright: ignore[reportDeprecated]
+            async_to_streamed_response_wrapper(
+                threads.create_and_run,  # pyright: ignore[reportDeprecated],
+            )
         )
 
     @cached_property
diff --git a/src/openai/resources/chat/completions/completions.py b/src/openai/resources/chat/completions/completions.py
index d28be012c9..c205011d10 100644
--- a/src/openai/resources/chat/completions/completions.py
+++ b/src/openai/resources/chat/completions/completions.py
@@ -3,7 +3,8 @@
 from __future__ import annotations
 
 import inspect
-from typing import Dict, List, Union, Iterable, Optional
+from typing import Dict, List, Type, Union, Iterable, Optional, cast
+from functools import partial
 from typing_extensions import Literal, overload
 
 import httpx
@@ -18,12 +19,8 @@
     MessagesWithStreamingResponse,
     AsyncMessagesWithStreamingResponse,
 )
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ...._utils import (
-    required_args,
-    maybe_transform,
-    async_maybe_transform,
-)
+from ...._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from ...._utils import required_args, maybe_transform, async_maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
 from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -36,15 +33,23 @@
     completion_update_params,
 )
 from ...._base_client import AsyncPaginator, make_request_options
+from ....lib._parsing import (
+    ResponseFormatT,
+    validate_input_tools as _validate_input_tools,
+    parse_chat_completion as _parse_chat_completion,
+    type_to_response_format_param as _type_to_response_format,
+)
+from ....lib.streaming.chat import ChatCompletionStreamManager, AsyncChatCompletionStreamManager
 from ....types.shared.chat_model import ChatModel
 from ....types.chat.chat_completion import ChatCompletion
 from ....types.shared_params.metadata import Metadata
 from ....types.shared.reasoning_effort import ReasoningEffort
 from ....types.chat.chat_completion_chunk import ChatCompletionChunk
+from ....types.chat.parsed_chat_completion import ParsedChatCompletion
 from ....types.chat.chat_completion_deleted import ChatCompletionDeleted
-from ....types.chat.chat_completion_tool_param import ChatCompletionToolParam
 from ....types.chat.chat_completion_audio_param import ChatCompletionAudioParam
 from ....types.chat.chat_completion_message_param import ChatCompletionMessageParam
+from ....types.chat.chat_completion_tool_union_param import ChatCompletionToolUnionParam
 from ....types.chat.chat_completion_stream_options_param import ChatCompletionStreamOptionsParam
 from ....types.chat.chat_completion_prediction_content_param import ChatCompletionPredictionContentParam
 from ....types.chat.chat_completion_tool_choice_option_param import ChatCompletionToolChoiceOptionParam
@@ -76,47 +81,206 @@ def with_streaming_response(self) -> CompletionsWithStreamingResponse:
         """
         return CompletionsWithStreamingResponse(self)
 
+    def parse(
+        self,
+        *,
+        messages: Iterable[ChatCompletionMessageParam],
+        model: Union[str, ChatModel],
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        response_format: type[ResponseFormatT] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ParsedChatCompletion[ResponseFormatT]:
+        """Wrapper over the `client.chat.completions.create()` method that provides richer integrations with Python specific types
+        & returns a `ParsedChatCompletion` object, which is a subclass of the standard `ChatCompletion` class.
+
+        You can pass a pydantic model to this method and it will automatically convert the model
+        into a JSON schema, send it to the API and parse the response content back into the given model.
+
+        This method will also automatically parse `function` tool calls if:
+        - You use the `openai.pydantic_function_tool()` helper method
+        - You mark your tool schema with `"strict": True`
+
+        Example usage:
+        ```py
+        from pydantic import BaseModel
+        from openai import OpenAI
+
+
+        class Step(BaseModel):
+            explanation: str
+            output: str
+
+
+        class MathResponse(BaseModel):
+            steps: List[Step]
+            final_answer: str
+
+
+        client = OpenAI()
+        completion = client.chat.completions.parse(
+            model="gpt-4o-2024-08-06",
+            messages=[
+                {"role": "system", "content": "You are a helpful math tutor."},
+                {"role": "user", "content": "solve 8x + 31 = 2"},
+            ],
+            response_format=MathResponse,
+        )
+
+        message = completion.choices[0].message
+        if message.parsed:
+            print(message.parsed.steps)
+            print("answer: ", message.parsed.final_answer)
+        ```
+        """
+        chat_completion_tools = _validate_input_tools(tools)
+
+        extra_headers = {
+            "X-Stainless-Helper-Method": "chat.completions.parse",
+            **(extra_headers or {}),
+        }
+
+        def parser(raw_completion: ChatCompletion) -> ParsedChatCompletion[ResponseFormatT]:
+            return _parse_chat_completion(
+                response_format=response_format,
+                chat_completion=raw_completion,
+                input_tools=chat_completion_tools,
+            )
+
+        return self._post(
+            "/chat/completions",
+            body=maybe_transform(
+                {
+                    "messages": messages,
+                    "model": model,
+                    "audio": audio,
+                    "frequency_penalty": frequency_penalty,
+                    "function_call": function_call,
+                    "functions": functions,
+                    "logit_bias": logit_bias,
+                    "logprobs": logprobs,
+                    "max_completion_tokens": max_completion_tokens,
+                    "max_tokens": max_tokens,
+                    "metadata": metadata,
+                    "modalities": modalities,
+                    "n": n,
+                    "parallel_tool_calls": parallel_tool_calls,
+                    "prediction": prediction,
+                    "presence_penalty": presence_penalty,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
+                    "reasoning_effort": reasoning_effort,
+                    "response_format": _type_to_response_format(response_format),
+                    "safety_identifier": safety_identifier,
+                    "seed": seed,
+                    "service_tier": service_tier,
+                    "stop": stop,
+                    "store": store,
+                    "stream": False,
+                    "stream_options": stream_options,
+                    "temperature": temperature,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "top_logprobs": top_logprobs,
+                    "top_p": top_p,
+                    "user": user,
+                    "verbosity": verbosity,
+                    "web_search_options": web_search_options,
+                },
+                completion_create_params.CompletionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                post_parser=parser,
+            ),
+            # we turn the `ChatCompletion` instance into a `ParsedChatCompletion`
+            # in the `parser` function above
+            cast_to=cast(Type[ParsedChatCompletion[ResponseFormatT]], ChatCompletion),
+            stream=False,
+        )
+
     @overload
     def create(
         self,
         *,
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion:
         """
         **Starting a new project?** We recommend trying
@@ -145,7 +309,7 @@ def create(
               [images](https://platform.openai.com/docs/guides/vision), and
               [audio](https://platform.openai.com/docs/guides/audio).
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
               wide range of models with different capabilities, performance characteristics,
               and price points. Refer to the
               [model guide](https://platform.openai.com/docs/models) to browse and compare
@@ -201,7 +365,7 @@ def create(
 
               This value is now deprecated in favor of `max_completion_tokens`, and is not
               compatible with
-              [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+              [o-series models](https://platform.openai.com/docs/guides/reasoning).
 
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
@@ -236,12 +400,27 @@ def create(
               whether they appear in the text so far, increasing the model's likelihood to
               talk about new topics.
 
-          reasoning_effort: **o-series models only**
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
 
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: An object specifying the format that the model must output.
 
@@ -254,34 +433,46 @@ def create(
               ensures the message the model generates is valid JSON. Using `json_schema` is
               preferred for models that support it.
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
           seed: This feature is in Beta. If specified, our system will make a best effort to
               sample deterministically, such that repeated requests with the same `seed` and
               parameters should return the same result. Determinism is not guaranteed, and you
               should refer to the `system_fingerprint` response parameter to monitor changes
               in the backend.
 
-          service_tier: Specifies the latency tier to use for processing the request. This parameter is
-              relevant for customers subscribed to the scale tier service:
+          service_tier: Specifies the processing type used for serving the request.
 
-              - If set to 'auto', and the Project is Scale tier enabled, the system will
-                utilize scale tier credits until they are exhausted.
-              - If set to 'auto', and the Project is not Scale tier enabled, the request will
-                be processed using the default service tier with a lower uptime SLA and no
-                latency guarentee.
-              - If set to 'default', the request will be processed using the default service
-                tier with a lower uptime SLA and no latency guarentee.
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
               - When not set, the default behavior is 'auto'.
 
-              When this parameter is set, the response body will include the `service_tier`
-              utilized.
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           store: Whether or not to store the output of this chat completion request for use in
               our [model distillation](https://platform.openai.com/docs/guides/distillation)
               or [evals](https://platform.openai.com/docs/guides/evals) products.
 
+              Supports text and image inputs. Note: image inputs over 8MB will be dropped.
+
           stream: If set to true, the model response data will be streamed to the client as it is
               generated using
               [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
@@ -308,9 +499,9 @@ def create(
               `none` is the default when no tools are present. `auto` is the default if tools
               are present.
 
-          tools: A list of tools the model may call. Currently, only functions are supported as a
-              tool. Use this to provide a list of functions the model may generate JSON inputs
-              for. A max of 128 functions are supported.
+          tools: A list of tools the model may call. You can provide either
+              [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
+              or [function tools](https://platform.openai.com/docs/guides/function-calling).
 
           top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
               return at each token position, each with an associated log probability.
@@ -322,9 +513,15 @@ def create(
 
               We generally recommend altering this or `temperature` but not both.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          verbosity: Constrains the verbosity of the model's response. Lower values will result in
+              more concise responses, while higher values will result in more verbose
+              responses. Currently supported values are `low`, `medium`, and `high`.
 
           web_search_options: This tool searches the web for relevant results to use in a response. Learn more
               about the
@@ -347,40 +544,44 @@ def create(
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
         stream: Literal[True],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Stream[ChatCompletionChunk]:
         """
         **Starting a new project?** We recommend trying
@@ -409,7 +610,7 @@ def create(
               [images](https://platform.openai.com/docs/guides/vision), and
               [audio](https://platform.openai.com/docs/guides/audio).
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
               wide range of models with different capabilities, performance characteristics,
               and price points. Refer to the
               [model guide](https://platform.openai.com/docs/models) to browse and compare
@@ -474,7 +675,7 @@ def create(
 
               This value is now deprecated in favor of `max_completion_tokens`, and is not
               compatible with
-              [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+              [o-series models](https://platform.openai.com/docs/guides/reasoning).
 
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
@@ -509,12 +710,27 @@ def create(
               whether they appear in the text so far, increasing the model's likelihood to
               talk about new topics.
 
-          reasoning_effort: **o-series models only**
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
 
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: An object specifying the format that the model must output.
 
@@ -527,34 +743,46 @@ def create(
               ensures the message the model generates is valid JSON. Using `json_schema` is
               preferred for models that support it.
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
           seed: This feature is in Beta. If specified, our system will make a best effort to
               sample deterministically, such that repeated requests with the same `seed` and
               parameters should return the same result. Determinism is not guaranteed, and you
               should refer to the `system_fingerprint` response parameter to monitor changes
               in the backend.
 
-          service_tier: Specifies the latency tier to use for processing the request. This parameter is
-              relevant for customers subscribed to the scale tier service:
+          service_tier: Specifies the processing type used for serving the request.
 
-              - If set to 'auto', and the Project is Scale tier enabled, the system will
-                utilize scale tier credits until they are exhausted.
-              - If set to 'auto', and the Project is not Scale tier enabled, the request will
-                be processed using the default service tier with a lower uptime SLA and no
-                latency guarentee.
-              - If set to 'default', the request will be processed using the default service
-                tier with a lower uptime SLA and no latency guarentee.
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
               - When not set, the default behavior is 'auto'.
 
-              When this parameter is set, the response body will include the `service_tier`
-              utilized.
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           store: Whether or not to store the output of this chat completion request for use in
               our [model distillation](https://platform.openai.com/docs/guides/distillation)
               or [evals](https://platform.openai.com/docs/guides/evals) products.
 
+              Supports text and image inputs. Note: image inputs over 8MB will be dropped.
+
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
 
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
@@ -572,9 +800,9 @@ def create(
               `none` is the default when no tools are present. `auto` is the default if tools
               are present.
 
-          tools: A list of tools the model may call. Currently, only functions are supported as a
-              tool. Use this to provide a list of functions the model may generate JSON inputs
-              for. A max of 128 functions are supported.
+          tools: A list of tools the model may call. You can provide either
+              [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
+              or [function tools](https://platform.openai.com/docs/guides/function-calling).
 
           top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
               return at each token position, each with an associated log probability.
@@ -586,9 +814,15 @@ def create(
 
               We generally recommend altering this or `temperature` but not both.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          verbosity: Constrains the verbosity of the model's response. Lower values will result in
+              more concise responses, while higher values will result in more verbose
+              responses. Currently supported values are `low`, `medium`, and `high`.
 
           web_search_options: This tool searches the web for relevant results to use in a response. Learn more
               about the
@@ -611,40 +845,44 @@ def create(
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
         stream: bool,
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion | Stream[ChatCompletionChunk]:
         """
         **Starting a new project?** We recommend trying
@@ -673,7 +911,7 @@ def create(
               [images](https://platform.openai.com/docs/guides/vision), and
               [audio](https://platform.openai.com/docs/guides/audio).
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
               wide range of models with different capabilities, performance characteristics,
               and price points. Refer to the
               [model guide](https://platform.openai.com/docs/models) to browse and compare
@@ -738,7 +976,7 @@ def create(
 
               This value is now deprecated in favor of `max_completion_tokens`, and is not
               compatible with
-              [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+              [o-series models](https://platform.openai.com/docs/guides/reasoning).
 
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
@@ -773,12 +1011,27 @@ def create(
               whether they appear in the text so far, increasing the model's likelihood to
               talk about new topics.
 
-          reasoning_effort: **o-series models only**
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
 
-              Constrains effort on reasoning for
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
+
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: An object specifying the format that the model must output.
 
@@ -791,34 +1044,46 @@ def create(
               ensures the message the model generates is valid JSON. Using `json_schema` is
               preferred for models that support it.
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
           seed: This feature is in Beta. If specified, our system will make a best effort to
               sample deterministically, such that repeated requests with the same `seed` and
               parameters should return the same result. Determinism is not guaranteed, and you
               should refer to the `system_fingerprint` response parameter to monitor changes
               in the backend.
 
-          service_tier: Specifies the latency tier to use for processing the request. This parameter is
-              relevant for customers subscribed to the scale tier service:
+          service_tier: Specifies the processing type used for serving the request.
 
-              - If set to 'auto', and the Project is Scale tier enabled, the system will
-                utilize scale tier credits until they are exhausted.
-              - If set to 'auto', and the Project is not Scale tier enabled, the request will
-                be processed using the default service tier with a lower uptime SLA and no
-                latency guarentee.
-              - If set to 'default', the request will be processed using the default service
-                tier with a lower uptime SLA and no latency guarentee.
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
               - When not set, the default behavior is 'auto'.
 
-              When this parameter is set, the response body will include the `service_tier`
-              utilized.
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           store: Whether or not to store the output of this chat completion request for use in
               our [model distillation](https://platform.openai.com/docs/guides/distillation)
               or [evals](https://platform.openai.com/docs/guides/evals) products.
 
+              Supports text and image inputs. Note: image inputs over 8MB will be dropped.
+
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
 
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
@@ -836,9 +1101,9 @@ def create(
               `none` is the default when no tools are present. `auto` is the default if tools
               are present.
 
-          tools: A list of tools the model may call. Currently, only functions are supported as a
-              tool. Use this to provide a list of functions the model may generate JSON inputs
-              for. A max of 128 functions are supported.
+          tools: A list of tools the model may call. You can provide either
+              [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
+              or [function tools](https://platform.openai.com/docs/guides/function-calling).
 
           top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
               return at each token position, each with an associated log probability.
@@ -850,9 +1115,15 @@ def create(
 
               We generally recommend altering this or `temperature` but not both.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          verbosity: Constrains the verbosity of the model's response. Lower values will result in
+              more concise responses, while higher values will result in more verbose
+              responses. Currently supported values are `low`, `medium`, and `high`.
 
           web_search_options: This tool searches the web for relevant results to use in a response. Learn more
               about the
@@ -874,41 +1145,45 @@ def create(
         *,
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion | Stream[ChatCompletionChunk]:
         validate_response_format(response_format)
         return self._post(
@@ -931,8 +1206,11 @@ def create(
                     "parallel_tool_calls": parallel_tool_calls,
                     "prediction": prediction,
                     "presence_penalty": presence_penalty,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
                     "reasoning_effort": reasoning_effort,
                     "response_format": response_format,
+                    "safety_identifier": safety_identifier,
                     "seed": seed,
                     "service_tier": service_tier,
                     "stop": stop,
@@ -945,9 +1223,12 @@ def create(
                     "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "user": user,
+                    "verbosity": verbosity,
                     "web_search_options": web_search_options,
                 },
-                completion_create_params.CompletionCreateParams,
+                completion_create_params.CompletionCreateParamsStreaming
+                if stream
+                else completion_create_params.CompletionCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -966,7 +1247,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion:
         """Get a stored chat completion.
 
@@ -1002,7 +1283,7 @@ def update(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion:
         """Modify a stored chat completion.
 
@@ -1040,17 +1321,17 @@ def update(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: str | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: str | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[ChatCompletion]:
         """List stored Chat Completions.
 
@@ -1062,10 +1343,12 @@ def list(
 
           limit: Number of Chat Completions to retrieve.
 
-          metadata:
-              A list of metadata keys to filter the Chat Completions by. Example:
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
 
-              `metadata[key1]=value1&metadata[key2]=value2`
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
 
           model: The model used to generate the Chat Completions.
 
@@ -1111,7 +1394,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletionDeleted:
         """Delete a stored chat completion.
 
@@ -1137,6 +1420,125 @@ def delete(
             cast_to=ChatCompletionDeleted,
         )
 
+    def stream(
+        self,
+        *,
+        messages: Iterable[ChatCompletionMessageParam],
+        model: Union[str, ChatModel],
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | type[ResponseFormatT] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ChatCompletionStreamManager[ResponseFormatT]:
+        """Wrapper over the `client.chat.completions.create(stream=True)` method that provides a more granular event API
+        and automatic accumulation of each delta.
+
+        This also supports all of the parsing utilities that `.parse()` does.
+
+        Unlike `.create(stream=True)`, the `.stream()` method requires usage within a context manager to prevent accidental leakage of the response:
+
+        ```py
+        with client.chat.completions.stream(
+            model="gpt-4o-2024-08-06",
+            messages=[...],
+        ) as stream:
+            for event in stream:
+                if event.type == "content.delta":
+                    print(event.delta, flush=True, end="")
+        ```
+
+        When the context manager is entered, a `ChatCompletionStream` instance is returned which, like `.create(stream=True)` is an iterator. The full list of events that are yielded by the iterator are outlined in [these docs](https://github.com/openai/openai-python/blob/main/helpers.md#chat-completions-events).
+
+        When the context manager exits, the response will be closed, however the `stream` instance is still available outside
+        the context manager.
+        """
+        extra_headers = {
+            "X-Stainless-Helper-Method": "chat.completions.stream",
+            **(extra_headers or {}),
+        }
+
+        api_request: partial[Stream[ChatCompletionChunk]] = partial(
+            self.create,
+            messages=messages,
+            model=model,
+            audio=audio,
+            stream=True,
+            response_format=_type_to_response_format(response_format),
+            frequency_penalty=frequency_penalty,
+            function_call=function_call,
+            functions=functions,
+            logit_bias=logit_bias,
+            logprobs=logprobs,
+            max_completion_tokens=max_completion_tokens,
+            max_tokens=max_tokens,
+            metadata=metadata,
+            modalities=modalities,
+            n=n,
+            parallel_tool_calls=parallel_tool_calls,
+            prediction=prediction,
+            presence_penalty=presence_penalty,
+            prompt_cache_key=prompt_cache_key,
+            prompt_cache_retention=prompt_cache_retention,
+            reasoning_effort=reasoning_effort,
+            safety_identifier=safety_identifier,
+            seed=seed,
+            service_tier=service_tier,
+            store=store,
+            stop=stop,
+            stream_options=stream_options,
+            temperature=temperature,
+            tool_choice=tool_choice,
+            tools=tools,
+            top_logprobs=top_logprobs,
+            top_p=top_p,
+            user=user,
+            verbosity=verbosity,
+            web_search_options=web_search_options,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return ChatCompletionStreamManager(
+            api_request,
+            response_format=response_format,
+            input_tools=tools,
+        )
+
 
 class AsyncCompletions(AsyncAPIResource):
     @cached_property
@@ -1162,47 +1564,206 @@ def with_streaming_response(self) -> AsyncCompletionsWithStreamingResponse:
         """
         return AsyncCompletionsWithStreamingResponse(self)
 
+    async def parse(
+        self,
+        *,
+        messages: Iterable[ChatCompletionMessageParam],
+        model: Union[str, ChatModel],
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        response_format: type[ResponseFormatT] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ParsedChatCompletion[ResponseFormatT]:
+        """Wrapper over the `client.chat.completions.create()` method that provides richer integrations with Python specific types
+        & returns a `ParsedChatCompletion` object, which is a subclass of the standard `ChatCompletion` class.
+
+        You can pass a pydantic model to this method and it will automatically convert the model
+        into a JSON schema, send it to the API and parse the response content back into the given model.
+
+        This method will also automatically parse `function` tool calls if:
+        - You use the `openai.pydantic_function_tool()` helper method
+        - You mark your tool schema with `"strict": True`
+
+        Example usage:
+        ```py
+        from pydantic import BaseModel
+        from openai import AsyncOpenAI
+
+
+        class Step(BaseModel):
+            explanation: str
+            output: str
+
+
+        class MathResponse(BaseModel):
+            steps: List[Step]
+            final_answer: str
+
+
+        client = AsyncOpenAI()
+        completion = await client.chat.completions.parse(
+            model="gpt-4o-2024-08-06",
+            messages=[
+                {"role": "system", "content": "You are a helpful math tutor."},
+                {"role": "user", "content": "solve 8x + 31 = 2"},
+            ],
+            response_format=MathResponse,
+        )
+
+        message = completion.choices[0].message
+        if message.parsed:
+            print(message.parsed.steps)
+            print("answer: ", message.parsed.final_answer)
+        ```
+        """
+        _validate_input_tools(tools)
+
+        extra_headers = {
+            "X-Stainless-Helper-Method": "chat.completions.parse",
+            **(extra_headers or {}),
+        }
+
+        def parser(raw_completion: ChatCompletion) -> ParsedChatCompletion[ResponseFormatT]:
+            return _parse_chat_completion(
+                response_format=response_format,
+                chat_completion=raw_completion,
+                input_tools=tools,
+            )
+
+        return await self._post(
+            "/chat/completions",
+            body=await async_maybe_transform(
+                {
+                    "messages": messages,
+                    "model": model,
+                    "audio": audio,
+                    "frequency_penalty": frequency_penalty,
+                    "function_call": function_call,
+                    "functions": functions,
+                    "logit_bias": logit_bias,
+                    "logprobs": logprobs,
+                    "max_completion_tokens": max_completion_tokens,
+                    "max_tokens": max_tokens,
+                    "metadata": metadata,
+                    "modalities": modalities,
+                    "n": n,
+                    "parallel_tool_calls": parallel_tool_calls,
+                    "prediction": prediction,
+                    "presence_penalty": presence_penalty,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
+                    "reasoning_effort": reasoning_effort,
+                    "response_format": _type_to_response_format(response_format),
+                    "safety_identifier": safety_identifier,
+                    "seed": seed,
+                    "service_tier": service_tier,
+                    "store": store,
+                    "stop": stop,
+                    "stream": False,
+                    "stream_options": stream_options,
+                    "temperature": temperature,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "top_logprobs": top_logprobs,
+                    "top_p": top_p,
+                    "user": user,
+                    "verbosity": verbosity,
+                    "web_search_options": web_search_options,
+                },
+                completion_create_params.CompletionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                post_parser=parser,
+            ),
+            # we turn the `ChatCompletion` instance into a `ParsedChatCompletion`
+            # in the `parser` function above
+            cast_to=cast(Type[ParsedChatCompletion[ResponseFormatT]], ChatCompletion),
+            stream=False,
+        )
+
     @overload
     async def create(
         self,
         *,
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion:
         """
         **Starting a new project?** We recommend trying
@@ -1231,7 +1792,7 @@ async def create(
               [images](https://platform.openai.com/docs/guides/vision), and
               [audio](https://platform.openai.com/docs/guides/audio).
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
               wide range of models with different capabilities, performance characteristics,
               and price points. Refer to the
               [model guide](https://platform.openai.com/docs/models) to browse and compare
@@ -1287,7 +1848,7 @@ async def create(
 
               This value is now deprecated in favor of `max_completion_tokens`, and is not
               compatible with
-              [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+              [o-series models](https://platform.openai.com/docs/guides/reasoning).
 
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
@@ -1322,12 +1883,27 @@ async def create(
               whether they appear in the text so far, increasing the model's likelihood to
               talk about new topics.
 
-          reasoning_effort: **o-series models only**
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
 
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: An object specifying the format that the model must output.
 
@@ -1340,34 +1916,46 @@ async def create(
               ensures the message the model generates is valid JSON. Using `json_schema` is
               preferred for models that support it.
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
           seed: This feature is in Beta. If specified, our system will make a best effort to
               sample deterministically, such that repeated requests with the same `seed` and
               parameters should return the same result. Determinism is not guaranteed, and you
               should refer to the `system_fingerprint` response parameter to monitor changes
               in the backend.
 
-          service_tier: Specifies the latency tier to use for processing the request. This parameter is
-              relevant for customers subscribed to the scale tier service:
+          service_tier: Specifies the processing type used for serving the request.
 
-              - If set to 'auto', and the Project is Scale tier enabled, the system will
-                utilize scale tier credits until they are exhausted.
-              - If set to 'auto', and the Project is not Scale tier enabled, the request will
-                be processed using the default service tier with a lower uptime SLA and no
-                latency guarentee.
-              - If set to 'default', the request will be processed using the default service
-                tier with a lower uptime SLA and no latency guarentee.
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
               - When not set, the default behavior is 'auto'.
 
-              When this parameter is set, the response body will include the `service_tier`
-              utilized.
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           store: Whether or not to store the output of this chat completion request for use in
               our [model distillation](https://platform.openai.com/docs/guides/distillation)
               or [evals](https://platform.openai.com/docs/guides/evals) products.
 
+              Supports text and image inputs. Note: image inputs over 8MB will be dropped.
+
           stream: If set to true, the model response data will be streamed to the client as it is
               generated using
               [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
@@ -1394,9 +1982,9 @@ async def create(
               `none` is the default when no tools are present. `auto` is the default if tools
               are present.
 
-          tools: A list of tools the model may call. Currently, only functions are supported as a
-              tool. Use this to provide a list of functions the model may generate JSON inputs
-              for. A max of 128 functions are supported.
+          tools: A list of tools the model may call. You can provide either
+              [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
+              or [function tools](https://platform.openai.com/docs/guides/function-calling).
 
           top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
               return at each token position, each with an associated log probability.
@@ -1408,9 +1996,15 @@ async def create(
 
               We generally recommend altering this or `temperature` but not both.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          verbosity: Constrains the verbosity of the model's response. Lower values will result in
+              more concise responses, while higher values will result in more verbose
+              responses. Currently supported values are `low`, `medium`, and `high`.
 
           web_search_options: This tool searches the web for relevant results to use in a response. Learn more
               about the
@@ -1433,40 +2027,44 @@ async def create(
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
         stream: Literal[True],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncStream[ChatCompletionChunk]:
         """
         **Starting a new project?** We recommend trying
@@ -1495,7 +2093,7 @@ async def create(
               [images](https://platform.openai.com/docs/guides/vision), and
               [audio](https://platform.openai.com/docs/guides/audio).
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
               wide range of models with different capabilities, performance characteristics,
               and price points. Refer to the
               [model guide](https://platform.openai.com/docs/models) to browse and compare
@@ -1560,7 +2158,7 @@ async def create(
 
               This value is now deprecated in favor of `max_completion_tokens`, and is not
               compatible with
-              [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+              [o-series models](https://platform.openai.com/docs/guides/reasoning).
 
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
@@ -1595,12 +2193,27 @@ async def create(
               whether they appear in the text so far, increasing the model's likelihood to
               talk about new topics.
 
-          reasoning_effort: **o-series models only**
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
 
-              Constrains effort on reasoning for
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
+
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: An object specifying the format that the model must output.
 
@@ -1613,34 +2226,46 @@ async def create(
               ensures the message the model generates is valid JSON. Using `json_schema` is
               preferred for models that support it.
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
           seed: This feature is in Beta. If specified, our system will make a best effort to
               sample deterministically, such that repeated requests with the same `seed` and
               parameters should return the same result. Determinism is not guaranteed, and you
               should refer to the `system_fingerprint` response parameter to monitor changes
               in the backend.
 
-          service_tier: Specifies the latency tier to use for processing the request. This parameter is
-              relevant for customers subscribed to the scale tier service:
+          service_tier: Specifies the processing type used for serving the request.
 
-              - If set to 'auto', and the Project is Scale tier enabled, the system will
-                utilize scale tier credits until they are exhausted.
-              - If set to 'auto', and the Project is not Scale tier enabled, the request will
-                be processed using the default service tier with a lower uptime SLA and no
-                latency guarentee.
-              - If set to 'default', the request will be processed using the default service
-                tier with a lower uptime SLA and no latency guarentee.
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
               - When not set, the default behavior is 'auto'.
 
-              When this parameter is set, the response body will include the `service_tier`
-              utilized.
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           store: Whether or not to store the output of this chat completion request for use in
               our [model distillation](https://platform.openai.com/docs/guides/distillation)
               or [evals](https://platform.openai.com/docs/guides/evals) products.
 
+              Supports text and image inputs. Note: image inputs over 8MB will be dropped.
+
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
 
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
@@ -1658,9 +2283,9 @@ async def create(
               `none` is the default when no tools are present. `auto` is the default if tools
               are present.
 
-          tools: A list of tools the model may call. Currently, only functions are supported as a
-              tool. Use this to provide a list of functions the model may generate JSON inputs
-              for. A max of 128 functions are supported.
+          tools: A list of tools the model may call. You can provide either
+              [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
+              or [function tools](https://platform.openai.com/docs/guides/function-calling).
 
           top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
               return at each token position, each with an associated log probability.
@@ -1672,9 +2297,15 @@ async def create(
 
               We generally recommend altering this or `temperature` but not both.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          verbosity: Constrains the verbosity of the model's response. Lower values will result in
+              more concise responses, while higher values will result in more verbose
+              responses. Currently supported values are `low`, `medium`, and `high`.
 
           web_search_options: This tool searches the web for relevant results to use in a response. Learn more
               about the
@@ -1697,40 +2328,44 @@ async def create(
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
         stream: bool,
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
         """
         **Starting a new project?** We recommend trying
@@ -1759,7 +2394,7 @@ async def create(
               [images](https://platform.openai.com/docs/guides/vision), and
               [audio](https://platform.openai.com/docs/guides/audio).
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
               wide range of models with different capabilities, performance characteristics,
               and price points. Refer to the
               [model guide](https://platform.openai.com/docs/models) to browse and compare
@@ -1824,7 +2459,7 @@ async def create(
 
               This value is now deprecated in favor of `max_completion_tokens`, and is not
               compatible with
-              [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+              [o-series models](https://platform.openai.com/docs/guides/reasoning).
 
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
@@ -1859,12 +2494,27 @@ async def create(
               whether they appear in the text so far, increasing the model's likelihood to
               talk about new topics.
 
-          reasoning_effort: **o-series models only**
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
 
-              Constrains effort on reasoning for
+          reasoning_effort: Constrains effort on reasoning for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-              supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-              result in faster responses and fewer tokens used on reasoning in a response.
+              supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+              reasoning effort can result in faster responses and fewer tokens used on
+              reasoning in a response.
+
+              - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+                reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+                calls are supported for all reasoning values in gpt-5.1.
+              - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+                support `none`.
+              - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
 
           response_format: An object specifying the format that the model must output.
 
@@ -1877,34 +2527,46 @@ async def create(
               ensures the message the model generates is valid JSON. Using `json_schema` is
               preferred for models that support it.
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
           seed: This feature is in Beta. If specified, our system will make a best effort to
               sample deterministically, such that repeated requests with the same `seed` and
               parameters should return the same result. Determinism is not guaranteed, and you
               should refer to the `system_fingerprint` response parameter to monitor changes
               in the backend.
 
-          service_tier: Specifies the latency tier to use for processing the request. This parameter is
-              relevant for customers subscribed to the scale tier service:
+          service_tier: Specifies the processing type used for serving the request.
 
-              - If set to 'auto', and the Project is Scale tier enabled, the system will
-                utilize scale tier credits until they are exhausted.
-              - If set to 'auto', and the Project is not Scale tier enabled, the request will
-                be processed using the default service tier with a lower uptime SLA and no
-                latency guarentee.
-              - If set to 'default', the request will be processed using the default service
-                tier with a lower uptime SLA and no latency guarentee.
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
               - When not set, the default behavior is 'auto'.
 
-              When this parameter is set, the response body will include the `service_tier`
-              utilized.
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           store: Whether or not to store the output of this chat completion request for use in
               our [model distillation](https://platform.openai.com/docs/guides/distillation)
               or [evals](https://platform.openai.com/docs/guides/evals) products.
 
+              Supports text and image inputs. Note: image inputs over 8MB will be dropped.
+
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
 
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
@@ -1922,9 +2584,9 @@ async def create(
               `none` is the default when no tools are present. `auto` is the default if tools
               are present.
 
-          tools: A list of tools the model may call. Currently, only functions are supported as a
-              tool. Use this to provide a list of functions the model may generate JSON inputs
-              for. A max of 128 functions are supported.
+          tools: A list of tools the model may call. You can provide either
+              [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
+              or [function tools](https://platform.openai.com/docs/guides/function-calling).
 
           top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
               return at each token position, each with an associated log probability.
@@ -1936,9 +2598,15 @@ async def create(
 
               We generally recommend altering this or `temperature` but not both.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          verbosity: Constrains the verbosity of the model's response. Lower values will result in
+              more concise responses, while higher values will result in more verbose
+              responses. Currently supported values are `low`, `medium`, and `high`.
 
           web_search_options: This tool searches the web for relevant results to use in a response. Learn more
               about the
@@ -1960,41 +2628,45 @@ async def create(
         *,
         messages: Iterable[ChatCompletionMessageParam],
         model: Union[str, ChatModel],
-        audio: Optional[ChatCompletionAudioParam] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        function_call: completion_create_params.FunctionCall | NotGiven = NOT_GIVEN,
-        functions: Iterable[completion_create_params.Function] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[bool] | NotGiven = NOT_GIVEN,
-        max_completion_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        modalities: Optional[List[Literal["text", "audio"]]] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
-        prediction: Optional[ChatCompletionPredictionContentParam] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        reasoning_effort: Optional[ReasoningEffort] | NotGiven = NOT_GIVEN,
-        response_format: completion_create_params.ResponseFormat | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        service_tier: Optional[Literal["auto", "default"]] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven = NOT_GIVEN,
-        tools: Iterable[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
-        top_logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        web_search_options: completion_create_params.WebSearchOptions | NotGiven = NOT_GIVEN,
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
         validate_response_format(response_format)
         return await self._post(
@@ -2017,8 +2689,11 @@ async def create(
                     "parallel_tool_calls": parallel_tool_calls,
                     "prediction": prediction,
                     "presence_penalty": presence_penalty,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
                     "reasoning_effort": reasoning_effort,
                     "response_format": response_format,
+                    "safety_identifier": safety_identifier,
                     "seed": seed,
                     "service_tier": service_tier,
                     "stop": stop,
@@ -2031,9 +2706,12 @@ async def create(
                     "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "user": user,
+                    "verbosity": verbosity,
                     "web_search_options": web_search_options,
                 },
-                completion_create_params.CompletionCreateParams,
+                completion_create_params.CompletionCreateParamsStreaming
+                if stream
+                else completion_create_params.CompletionCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -2052,7 +2730,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion:
         """Get a stored chat completion.
 
@@ -2088,7 +2766,7 @@ async def update(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletion:
         """Modify a stored chat completion.
 
@@ -2126,17 +2804,17 @@ async def update(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        model: str | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: str | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[ChatCompletion, AsyncCursorPage[ChatCompletion]]:
         """List stored Chat Completions.
 
@@ -2148,10 +2826,12 @@ def list(
 
           limit: Number of Chat Completions to retrieve.
 
-          metadata:
-              A list of metadata keys to filter the Chat Completions by. Example:
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
 
-              `metadata[key1]=value1&metadata[key2]=value2`
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
 
           model: The model used to generate the Chat Completions.
 
@@ -2197,7 +2877,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ChatCompletionDeleted:
         """Delete a stored chat completion.
 
@@ -2223,11 +2903,134 @@ async def delete(
             cast_to=ChatCompletionDeleted,
         )
 
+    def stream(
+        self,
+        *,
+        messages: Iterable[ChatCompletionMessageParam],
+        model: Union[str, ChatModel],
+        audio: Optional[ChatCompletionAudioParam] | Omit = omit,
+        response_format: completion_create_params.ResponseFormat | type[ResponseFormatT] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        function_call: completion_create_params.FunctionCall | Omit = omit,
+        functions: Iterable[completion_create_params.Function] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[bool] | Omit = omit,
+        max_completion_tokens: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        modalities: Optional[List[Literal["text", "audio"]]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        parallel_tool_calls: bool | Omit = omit,
+        prediction: Optional[ChatCompletionPredictionContentParam] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning_effort: Optional[ReasoningEffort] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        tool_choice: ChatCompletionToolChoiceOptionParam | Omit = omit,
+        tools: Iterable[ChatCompletionToolUnionParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
+        web_search_options: completion_create_params.WebSearchOptions | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncChatCompletionStreamManager[ResponseFormatT]:
+        """Wrapper over the `client.chat.completions.create(stream=True)` method that provides a more granular event API
+        and automatic accumulation of each delta.
+
+        This also supports all of the parsing utilities that `.parse()` does.
+
+        Unlike `.create(stream=True)`, the `.stream()` method requires usage within a context manager to prevent accidental leakage of the response:
+
+        ```py
+        async with client.chat.completions.stream(
+            model="gpt-4o-2024-08-06",
+            messages=[...],
+        ) as stream:
+            async for event in stream:
+                if event.type == "content.delta":
+                    print(event.delta, flush=True, end="")
+        ```
+
+        When the context manager is entered, an `AsyncChatCompletionStream` instance is returned which, like `.create(stream=True)` is an async iterator. The full list of events that are yielded by the iterator are outlined in [these docs](https://github.com/openai/openai-python/blob/main/helpers.md#chat-completions-events).
+
+        When the context manager exits, the response will be closed, however the `stream` instance is still available outside
+        the context manager.
+        """
+        _validate_input_tools(tools)
+
+        extra_headers = {
+            "X-Stainless-Helper-Method": "chat.completions.stream",
+            **(extra_headers or {}),
+        }
+
+        api_request = self.create(
+            messages=messages,
+            model=model,
+            audio=audio,
+            stream=True,
+            response_format=_type_to_response_format(response_format),
+            frequency_penalty=frequency_penalty,
+            function_call=function_call,
+            functions=functions,
+            logit_bias=logit_bias,
+            logprobs=logprobs,
+            max_completion_tokens=max_completion_tokens,
+            max_tokens=max_tokens,
+            metadata=metadata,
+            modalities=modalities,
+            n=n,
+            parallel_tool_calls=parallel_tool_calls,
+            prediction=prediction,
+            presence_penalty=presence_penalty,
+            prompt_cache_key=prompt_cache_key,
+            prompt_cache_retention=prompt_cache_retention,
+            reasoning_effort=reasoning_effort,
+            safety_identifier=safety_identifier,
+            seed=seed,
+            service_tier=service_tier,
+            stop=stop,
+            store=store,
+            stream_options=stream_options,
+            temperature=temperature,
+            tool_choice=tool_choice,
+            tools=tools,
+            top_logprobs=top_logprobs,
+            top_p=top_p,
+            user=user,
+            verbosity=verbosity,
+            web_search_options=web_search_options,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+        return AsyncChatCompletionStreamManager(
+            api_request,
+            response_format=response_format,
+            input_tools=tools,
+        )
+
 
 class CompletionsWithRawResponse:
     def __init__(self, completions: Completions) -> None:
         self._completions = completions
 
+        self.parse = _legacy_response.to_raw_response_wrapper(
+            completions.parse,
+        )
         self.create = _legacy_response.to_raw_response_wrapper(
             completions.create,
         )
@@ -2253,6 +3056,9 @@ class AsyncCompletionsWithRawResponse:
     def __init__(self, completions: AsyncCompletions) -> None:
         self._completions = completions
 
+        self.parse = _legacy_response.async_to_raw_response_wrapper(
+            completions.parse,
+        )
         self.create = _legacy_response.async_to_raw_response_wrapper(
             completions.create,
         )
@@ -2278,6 +3084,9 @@ class CompletionsWithStreamingResponse:
     def __init__(self, completions: Completions) -> None:
         self._completions = completions
 
+        self.parse = to_streamed_response_wrapper(
+            completions.parse,
+        )
         self.create = to_streamed_response_wrapper(
             completions.create,
         )
@@ -2303,6 +3112,9 @@ class AsyncCompletionsWithStreamingResponse:
     def __init__(self, completions: AsyncCompletions) -> None:
         self._completions = completions
 
+        self.parse = async_to_streamed_response_wrapper(
+            completions.parse,
+        )
         self.create = async_to_streamed_response_wrapper(
             completions.create,
         )
@@ -2327,5 +3139,5 @@ def messages(self) -> AsyncMessagesWithStreamingResponse:
 def validate_response_format(response_format: object) -> None:
     if inspect.isclass(response_format) and issubclass(response_format, pydantic.BaseModel):
         raise TypeError(
-            "You tried to pass a `BaseModel` class to `chat.completions.create()`; You must use `beta.chat.completions.parse()` instead"
+            "You tried to pass a `BaseModel` class to `chat.completions.create()`; You must use `chat.completions.parse()` instead"
         )
diff --git a/src/openai/resources/chat/completions/messages.py b/src/openai/resources/chat/completions/messages.py
index fac15fba8b..3d6dc79cd6 100644
--- a/src/openai/resources/chat/completions/messages.py
+++ b/src/openai/resources/chat/completions/messages.py
@@ -7,7 +7,7 @@
 import httpx
 
 from .... import _legacy_response
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from ...._utils import maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
@@ -44,15 +44,15 @@ def list(
         self,
         completion_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[ChatCompletionStoreMessage]:
         """Get the messages in a stored chat completion.
 
@@ -122,15 +122,15 @@ def list(
         self,
         completion_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[ChatCompletionStoreMessage, AsyncCursorPage[ChatCompletionStoreMessage]]:
         """Get the messages in a stored chat completion.
 
diff --git a/src/openai/resources/completions.py b/src/openai/resources/completions.py
index 171f509352..2f2284a622 100644
--- a/src/openai/resources/completions.py
+++ b/src/openai/resources/completions.py
@@ -2,19 +2,15 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Iterable, Optional
+from typing import Dict, Union, Iterable, Optional
 from typing_extensions import Literal, overload
 
 import httpx
 
 from .. import _legacy_response
 from ..types import completion_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
-    required_args,
-    maybe_transform,
-    async_maybe_transform,
-)
+from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from .._utils import required_args, maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -53,29 +49,29 @@ def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Completion:
         """
         Creates a completion for the provided prompt and parameters.
@@ -159,7 +155,9 @@ def create(
               Determinism is not guaranteed, and you should refer to the `system_fingerprint`
               response parameter to monitor changes in the backend.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           stream: Whether to stream back partial progress. If set, tokens will be sent as
@@ -206,29 +204,29 @@ def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
         stream: Literal[True],
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Stream[Completion]:
         """
         Creates a completion for the provided prompt and parameters.
@@ -319,7 +317,9 @@ def create(
               Determinism is not guaranteed, and you should refer to the `system_fingerprint`
               response parameter to monitor changes in the backend.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
@@ -359,29 +359,29 @@ def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
         stream: bool,
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Completion | Stream[Completion]:
         """
         Creates a completion for the provided prompt and parameters.
@@ -472,7 +472,9 @@ def create(
               Determinism is not guaranteed, and you should refer to the `system_fingerprint`
               response parameter to monitor changes in the backend.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
@@ -512,29 +514,29 @@ def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Completion | Stream[Completion]:
         return self._post(
             "/completions",
@@ -559,7 +561,9 @@ def create(
                     "top_p": top_p,
                     "user": user,
                 },
-                completion_create_params.CompletionCreateParams,
+                completion_create_params.CompletionCreateParamsStreaming
+                if stream
+                else completion_create_params.CompletionCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -595,29 +599,29 @@ async def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Completion:
         """
         Creates a completion for the provided prompt and parameters.
@@ -701,7 +705,9 @@ async def create(
               Determinism is not guaranteed, and you should refer to the `system_fingerprint`
               response parameter to monitor changes in the backend.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           stream: Whether to stream back partial progress. If set, tokens will be sent as
@@ -748,29 +754,29 @@ async def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
         stream: Literal[True],
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncStream[Completion]:
         """
         Creates a completion for the provided prompt and parameters.
@@ -861,7 +867,9 @@ async def create(
               Determinism is not guaranteed, and you should refer to the `system_fingerprint`
               response parameter to monitor changes in the backend.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
@@ -901,29 +909,29 @@ async def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
         stream: bool,
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Completion | AsyncStream[Completion]:
         """
         Creates a completion for the provided prompt and parameters.
@@ -1014,7 +1022,9 @@ async def create(
               Determinism is not guaranteed, and you should refer to the `system_fingerprint`
               response parameter to monitor changes in the backend.
 
-          stop: Up to 4 sequences where the API will stop generating further tokens. The
+          stop: Not supported with latest reasoning models `o3` and `o4-mini`.
+
+              Up to 4 sequences where the API will stop generating further tokens. The
               returned text will not contain the stop sequence.
 
           stream_options: Options for streaming response. Only set this when you set `stream: true`.
@@ -1054,29 +1064,29 @@ async def create(
         self,
         *,
         model: Union[str, Literal["gpt-3.5-turbo-instruct", "davinci-002", "babbage-002"]],
-        prompt: Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None],
-        best_of: Optional[int] | NotGiven = NOT_GIVEN,
-        echo: Optional[bool] | NotGiven = NOT_GIVEN,
-        frequency_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        logit_bias: Optional[Dict[str, int]] | NotGiven = NOT_GIVEN,
-        logprobs: Optional[int] | NotGiven = NOT_GIVEN,
-        max_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        presence_penalty: Optional[float] | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        stop: Union[Optional[str], List[str], None] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        stream_options: Optional[ChatCompletionStreamOptionsParam] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None],
+        best_of: Optional[int] | Omit = omit,
+        echo: Optional[bool] | Omit = omit,
+        frequency_penalty: Optional[float] | Omit = omit,
+        logit_bias: Optional[Dict[str, int]] | Omit = omit,
+        logprobs: Optional[int] | Omit = omit,
+        max_tokens: Optional[int] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        presence_penalty: Optional[float] | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        stop: Union[Optional[str], SequenceNotStr[str], None] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[ChatCompletionStreamOptionsParam] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Completion | AsyncStream[Completion]:
         return await self._post(
             "/completions",
@@ -1101,7 +1111,9 @@ async def create(
                     "top_p": top_p,
                     "user": user,
                 },
-                completion_create_params.CompletionCreateParams,
+                completion_create_params.CompletionCreateParamsStreaming
+                if stream
+                else completion_create_params.CompletionCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
diff --git a/src/openai/resources/containers/__init__.py b/src/openai/resources/containers/__init__.py
new file mode 100644
index 0000000000..dc1936780b
--- /dev/null
+++ b/src/openai/resources/containers/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .files import (
+    Files,
+    AsyncFiles,
+    FilesWithRawResponse,
+    AsyncFilesWithRawResponse,
+    FilesWithStreamingResponse,
+    AsyncFilesWithStreamingResponse,
+)
+from .containers import (
+    Containers,
+    AsyncContainers,
+    ContainersWithRawResponse,
+    AsyncContainersWithRawResponse,
+    ContainersWithStreamingResponse,
+    AsyncContainersWithStreamingResponse,
+)
+
+__all__ = [
+    "Files",
+    "AsyncFiles",
+    "FilesWithRawResponse",
+    "AsyncFilesWithRawResponse",
+    "FilesWithStreamingResponse",
+    "AsyncFilesWithStreamingResponse",
+    "Containers",
+    "AsyncContainers",
+    "ContainersWithRawResponse",
+    "AsyncContainersWithRawResponse",
+    "ContainersWithStreamingResponse",
+    "AsyncContainersWithStreamingResponse",
+]
diff --git a/src/openai/resources/containers/containers.py b/src/openai/resources/containers/containers.py
new file mode 100644
index 0000000000..dcdc3e1a3e
--- /dev/null
+++ b/src/openai/resources/containers/containers.py
@@ -0,0 +1,510 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from ... import _legacy_response
+from ...types import container_list_params, container_create_params
+from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, SequenceNotStr, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from .files.files import (
+    Files,
+    AsyncFiles,
+    FilesWithRawResponse,
+    AsyncFilesWithRawResponse,
+    FilesWithStreamingResponse,
+    AsyncFilesWithStreamingResponse,
+)
+from ...pagination import SyncCursorPage, AsyncCursorPage
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.container_list_response import ContainerListResponse
+from ...types.container_create_response import ContainerCreateResponse
+from ...types.container_retrieve_response import ContainerRetrieveResponse
+
+__all__ = ["Containers", "AsyncContainers"]
+
+
+class Containers(SyncAPIResource):
+    @cached_property
+    def files(self) -> Files:
+        return Files(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ContainersWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return ContainersWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ContainersWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return ContainersWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        name: str,
+        expires_after: container_create_params.ExpiresAfter | Omit = omit,
+        file_ids: SequenceNotStr[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ContainerCreateResponse:
+        """
+        Create Container
+
+        Args:
+          name: Name of the container to create.
+
+          expires_after: Container expiration time in seconds relative to the 'anchor' time.
+
+          file_ids: IDs of files to copy to the container.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/containers",
+            body=maybe_transform(
+                {
+                    "name": name,
+                    "expires_after": expires_after,
+                    "file_ids": file_ids,
+                },
+                container_create_params.ContainerCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ContainerCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        container_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ContainerRetrieveResponse:
+        """
+        Retrieve Container
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        return self._get(
+            f"/containers/{container_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ContainerRetrieveResponse,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncCursorPage[ContainerListResponse]:
+        """List Containers
+
+        Args:
+          after: A cursor for use in pagination.
+
+        `after` is an object ID that defines your place
+              in the list. For instance, if you make a list request and receive 100 objects,
+              ending with obj_foo, your subsequent call can include after=obj_foo in order to
+              fetch the next page of the list.
+
+          limit: A limit on the number of objects to be returned. Limit can range between 1 and
+              100, and the default is 20.
+
+          order: Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+              order and `desc` for descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/containers",
+            page=SyncCursorPage[ContainerListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    container_list_params.ContainerListParams,
+                ),
+            ),
+            model=ContainerListResponse,
+        )
+
+    def delete(
+        self,
+        container_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Delete Container
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/containers/{container_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncContainers(AsyncAPIResource):
+    @cached_property
+    def files(self) -> AsyncFiles:
+        return AsyncFiles(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncContainersWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncContainersWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncContainersWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncContainersWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        name: str,
+        expires_after: container_create_params.ExpiresAfter | Omit = omit,
+        file_ids: SequenceNotStr[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ContainerCreateResponse:
+        """
+        Create Container
+
+        Args:
+          name: Name of the container to create.
+
+          expires_after: Container expiration time in seconds relative to the 'anchor' time.
+
+          file_ids: IDs of files to copy to the container.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/containers",
+            body=await async_maybe_transform(
+                {
+                    "name": name,
+                    "expires_after": expires_after,
+                    "file_ids": file_ids,
+                },
+                container_create_params.ContainerCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ContainerCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        container_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ContainerRetrieveResponse:
+        """
+        Retrieve Container
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        return await self._get(
+            f"/containers/{container_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ContainerRetrieveResponse,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[ContainerListResponse, AsyncCursorPage[ContainerListResponse]]:
+        """List Containers
+
+        Args:
+          after: A cursor for use in pagination.
+
+        `after` is an object ID that defines your place
+              in the list. For instance, if you make a list request and receive 100 objects,
+              ending with obj_foo, your subsequent call can include after=obj_foo in order to
+              fetch the next page of the list.
+
+          limit: A limit on the number of objects to be returned. Limit can range between 1 and
+              100, and the default is 20.
+
+          order: Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+              order and `desc` for descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/containers",
+            page=AsyncCursorPage[ContainerListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    container_list_params.ContainerListParams,
+                ),
+            ),
+            model=ContainerListResponse,
+        )
+
+    async def delete(
+        self,
+        container_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Delete Container
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/containers/{container_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class ContainersWithRawResponse:
+    def __init__(self, containers: Containers) -> None:
+        self._containers = containers
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            containers.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            containers.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            containers.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            containers.delete,
+        )
+
+    @cached_property
+    def files(self) -> FilesWithRawResponse:
+        return FilesWithRawResponse(self._containers.files)
+
+
+class AsyncContainersWithRawResponse:
+    def __init__(self, containers: AsyncContainers) -> None:
+        self._containers = containers
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            containers.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            containers.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            containers.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            containers.delete,
+        )
+
+    @cached_property
+    def files(self) -> AsyncFilesWithRawResponse:
+        return AsyncFilesWithRawResponse(self._containers.files)
+
+
+class ContainersWithStreamingResponse:
+    def __init__(self, containers: Containers) -> None:
+        self._containers = containers
+
+        self.create = to_streamed_response_wrapper(
+            containers.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            containers.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            containers.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            containers.delete,
+        )
+
+    @cached_property
+    def files(self) -> FilesWithStreamingResponse:
+        return FilesWithStreamingResponse(self._containers.files)
+
+
+class AsyncContainersWithStreamingResponse:
+    def __init__(self, containers: AsyncContainers) -> None:
+        self._containers = containers
+
+        self.create = async_to_streamed_response_wrapper(
+            containers.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            containers.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            containers.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            containers.delete,
+        )
+
+    @cached_property
+    def files(self) -> AsyncFilesWithStreamingResponse:
+        return AsyncFilesWithStreamingResponse(self._containers.files)
diff --git a/src/openai/resources/containers/files/__init__.py b/src/openai/resources/containers/files/__init__.py
new file mode 100644
index 0000000000..f71f7dbf55
--- /dev/null
+++ b/src/openai/resources/containers/files/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .files import (
+    Files,
+    AsyncFiles,
+    FilesWithRawResponse,
+    AsyncFilesWithRawResponse,
+    FilesWithStreamingResponse,
+    AsyncFilesWithStreamingResponse,
+)
+from .content import (
+    Content,
+    AsyncContent,
+    ContentWithRawResponse,
+    AsyncContentWithRawResponse,
+    ContentWithStreamingResponse,
+    AsyncContentWithStreamingResponse,
+)
+
+__all__ = [
+    "Content",
+    "AsyncContent",
+    "ContentWithRawResponse",
+    "AsyncContentWithRawResponse",
+    "ContentWithStreamingResponse",
+    "AsyncContentWithStreamingResponse",
+    "Files",
+    "AsyncFiles",
+    "FilesWithRawResponse",
+    "AsyncFilesWithRawResponse",
+    "FilesWithStreamingResponse",
+    "AsyncFilesWithStreamingResponse",
+]
diff --git a/src/openai/resources/containers/files/content.py b/src/openai/resources/containers/files/content.py
new file mode 100644
index 0000000000..a3dbd0e8c7
--- /dev/null
+++ b/src/openai/resources/containers/files/content.py
@@ -0,0 +1,173 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Query, Headers, NotGiven, not_given
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import (
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+    to_custom_streamed_response_wrapper,
+    async_to_custom_streamed_response_wrapper,
+)
+from ...._base_client import make_request_options
+
+__all__ = ["Content", "AsyncContent"]
+
+
+class Content(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ContentWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return ContentWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ContentWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return ContentWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        file_id: str,
+        *,
+        container_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        """
+        Retrieve Container File Content
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        return self._get(
+            f"/containers/{container_id}/files/{file_id}/content",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
+
+
+class AsyncContent(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncContentWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncContentWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncContentWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncContentWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        file_id: str,
+        *,
+        container_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        """
+        Retrieve Container File Content
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        return await self._get(
+            f"/containers/{container_id}/files/{file_id}/content",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
+
+
+class ContentWithRawResponse:
+    def __init__(self, content: Content) -> None:
+        self._content = content
+
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            content.retrieve,
+        )
+
+
+class AsyncContentWithRawResponse:
+    def __init__(self, content: AsyncContent) -> None:
+        self._content = content
+
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            content.retrieve,
+        )
+
+
+class ContentWithStreamingResponse:
+    def __init__(self, content: Content) -> None:
+        self._content = content
+
+        self.retrieve = to_custom_streamed_response_wrapper(
+            content.retrieve,
+            StreamedBinaryAPIResponse,
+        )
+
+
+class AsyncContentWithStreamingResponse:
+    def __init__(self, content: AsyncContent) -> None:
+        self._content = content
+
+        self.retrieve = async_to_custom_streamed_response_wrapper(
+            content.retrieve,
+            AsyncStreamedBinaryAPIResponse,
+        )
diff --git a/src/openai/resources/containers/files/files.py b/src/openai/resources/containers/files/files.py
new file mode 100644
index 0000000000..a472cfc9f3
--- /dev/null
+++ b/src/openai/resources/containers/files/files.py
@@ -0,0 +1,545 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Mapping, cast
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from .content import (
+    Content,
+    AsyncContent,
+    ContentWithRawResponse,
+    AsyncContentWithRawResponse,
+    ContentWithStreamingResponse,
+    AsyncContentWithStreamingResponse,
+)
+from ...._types import Body, Omit, Query, Headers, NoneType, NotGiven, FileTypes, omit, not_given
+from ...._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncCursorPage, AsyncCursorPage
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.containers import file_list_params, file_create_params
+from ....types.containers.file_list_response import FileListResponse
+from ....types.containers.file_create_response import FileCreateResponse
+from ....types.containers.file_retrieve_response import FileRetrieveResponse
+
+__all__ = ["Files", "AsyncFiles"]
+
+
+class Files(SyncAPIResource):
+    @cached_property
+    def content(self) -> Content:
+        return Content(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> FilesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return FilesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FilesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return FilesWithStreamingResponse(self)
+
+    def create(
+        self,
+        container_id: str,
+        *,
+        file: FileTypes | Omit = omit,
+        file_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileCreateResponse:
+        """
+        Create a Container File
+
+        You can send either a multipart/form-data request with the raw file content, or
+        a JSON request with a file ID.
+
+        Args:
+          file: The File object (not file name) to be uploaded.
+
+          file_id: Name of the file to create.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        body = deepcopy_minimal(
+            {
+                "file": file,
+                "file_id": file_id,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return self._post(
+            f"/containers/{container_id}/files",
+            body=maybe_transform(body, file_create_params.FileCreateParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        file_id: str,
+        *,
+        container_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileRetrieveResponse:
+        """
+        Retrieve Container File
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        return self._get(
+            f"/containers/{container_id}/files/{file_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileRetrieveResponse,
+        )
+
+    def list(
+        self,
+        container_id: str,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncCursorPage[FileListResponse]:
+        """List Container files
+
+        Args:
+          after: A cursor for use in pagination.
+
+        `after` is an object ID that defines your place
+              in the list. For instance, if you make a list request and receive 100 objects,
+              ending with obj_foo, your subsequent call can include after=obj_foo in order to
+              fetch the next page of the list.
+
+          limit: A limit on the number of objects to be returned. Limit can range between 1 and
+              100, and the default is 20.
+
+          order: Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+              order and `desc` for descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        return self._get_api_list(
+            f"/containers/{container_id}/files",
+            page=SyncCursorPage[FileListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    file_list_params.FileListParams,
+                ),
+            ),
+            model=FileListResponse,
+        )
+
+    def delete(
+        self,
+        file_id: str,
+        *,
+        container_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Delete Container File
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/containers/{container_id}/files/{file_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncFiles(AsyncAPIResource):
+    @cached_property
+    def content(self) -> AsyncContent:
+        return AsyncContent(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncFilesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFilesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFilesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncFilesWithStreamingResponse(self)
+
+    async def create(
+        self,
+        container_id: str,
+        *,
+        file: FileTypes | Omit = omit,
+        file_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileCreateResponse:
+        """
+        Create a Container File
+
+        You can send either a multipart/form-data request with the raw file content, or
+        a JSON request with a file ID.
+
+        Args:
+          file: The File object (not file name) to be uploaded.
+
+          file_id: Name of the file to create.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        body = deepcopy_minimal(
+            {
+                "file": file,
+                "file_id": file_id,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            f"/containers/{container_id}/files",
+            body=await async_maybe_transform(body, file_create_params.FileCreateParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        file_id: str,
+        *,
+        container_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileRetrieveResponse:
+        """
+        Retrieve Container File
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        return await self._get(
+            f"/containers/{container_id}/files/{file_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileRetrieveResponse,
+        )
+
+    def list(
+        self,
+        container_id: str,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[FileListResponse, AsyncCursorPage[FileListResponse]]:
+        """List Container files
+
+        Args:
+          after: A cursor for use in pagination.
+
+        `after` is an object ID that defines your place
+              in the list. For instance, if you make a list request and receive 100 objects,
+              ending with obj_foo, your subsequent call can include after=obj_foo in order to
+              fetch the next page of the list.
+
+          limit: A limit on the number of objects to be returned. Limit can range between 1 and
+              100, and the default is 20.
+
+          order: Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+              order and `desc` for descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        return self._get_api_list(
+            f"/containers/{container_id}/files",
+            page=AsyncCursorPage[FileListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    file_list_params.FileListParams,
+                ),
+            ),
+            model=FileListResponse,
+        )
+
+    async def delete(
+        self,
+        file_id: str,
+        *,
+        container_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Delete Container File
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not container_id:
+            raise ValueError(f"Expected a non-empty value for `container_id` but received {container_id!r}")
+        if not file_id:
+            raise ValueError(f"Expected a non-empty value for `file_id` but received {file_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/containers/{container_id}/files/{file_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class FilesWithRawResponse:
+    def __init__(self, files: Files) -> None:
+        self._files = files
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            files.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            files.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            files.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            files.delete,
+        )
+
+    @cached_property
+    def content(self) -> ContentWithRawResponse:
+        return ContentWithRawResponse(self._files.content)
+
+
+class AsyncFilesWithRawResponse:
+    def __init__(self, files: AsyncFiles) -> None:
+        self._files = files
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            files.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            files.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            files.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            files.delete,
+        )
+
+    @cached_property
+    def content(self) -> AsyncContentWithRawResponse:
+        return AsyncContentWithRawResponse(self._files.content)
+
+
+class FilesWithStreamingResponse:
+    def __init__(self, files: Files) -> None:
+        self._files = files
+
+        self.create = to_streamed_response_wrapper(
+            files.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            files.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            files.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            files.delete,
+        )
+
+    @cached_property
+    def content(self) -> ContentWithStreamingResponse:
+        return ContentWithStreamingResponse(self._files.content)
+
+
+class AsyncFilesWithStreamingResponse:
+    def __init__(self, files: AsyncFiles) -> None:
+        self._files = files
+
+        self.create = async_to_streamed_response_wrapper(
+            files.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            files.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            files.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            files.delete,
+        )
+
+    @cached_property
+    def content(self) -> AsyncContentWithStreamingResponse:
+        return AsyncContentWithStreamingResponse(self._files.content)
diff --git a/src/openai/resources/conversations/__init__.py b/src/openai/resources/conversations/__init__.py
new file mode 100644
index 0000000000..c6c4fd6ee4
--- /dev/null
+++ b/src/openai/resources/conversations/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .items import (
+    Items,
+    AsyncItems,
+    ItemsWithRawResponse,
+    AsyncItemsWithRawResponse,
+    ItemsWithStreamingResponse,
+    AsyncItemsWithStreamingResponse,
+)
+from .conversations import (
+    Conversations,
+    AsyncConversations,
+    ConversationsWithRawResponse,
+    AsyncConversationsWithRawResponse,
+    ConversationsWithStreamingResponse,
+    AsyncConversationsWithStreamingResponse,
+)
+
+__all__ = [
+    "Items",
+    "AsyncItems",
+    "ItemsWithRawResponse",
+    "AsyncItemsWithRawResponse",
+    "ItemsWithStreamingResponse",
+    "AsyncItemsWithStreamingResponse",
+    "Conversations",
+    "AsyncConversations",
+    "ConversationsWithRawResponse",
+    "AsyncConversationsWithRawResponse",
+    "ConversationsWithStreamingResponse",
+    "AsyncConversationsWithStreamingResponse",
+]
diff --git a/src/openai/resources/conversations/conversations.py b/src/openai/resources/conversations/conversations.py
new file mode 100644
index 0000000000..da037a4e22
--- /dev/null
+++ b/src/openai/resources/conversations/conversations.py
@@ -0,0 +1,486 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+
+import httpx
+
+from ... import _legacy_response
+from .items import (
+    Items,
+    AsyncItems,
+    ItemsWithRawResponse,
+    AsyncItemsWithRawResponse,
+    ItemsWithStreamingResponse,
+    AsyncItemsWithStreamingResponse,
+)
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ..._base_client import make_request_options
+from ...types.conversations import conversation_create_params, conversation_update_params
+from ...types.shared_params.metadata import Metadata
+from ...types.conversations.conversation import Conversation
+from ...types.responses.response_input_item_param import ResponseInputItemParam
+from ...types.conversations.conversation_deleted_resource import ConversationDeletedResource
+
+__all__ = ["Conversations", "AsyncConversations"]
+
+
+class Conversations(SyncAPIResource):
+    @cached_property
+    def items(self) -> Items:
+        return Items(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ConversationsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return ConversationsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ConversationsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return ConversationsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        items: Optional[Iterable[ResponseInputItemParam]] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Create a conversation.
+
+        Args:
+          items: Initial items to include in the conversation context. You may add up to 20 items
+              at a time.
+
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/conversations",
+            body=maybe_transform(
+                {
+                    "items": items,
+                    "metadata": metadata,
+                },
+                conversation_create_params.ConversationCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+    def retrieve(
+        self,
+        conversation_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Get a conversation
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return self._get(
+            f"/conversations/{conversation_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+    def update(
+        self,
+        conversation_id: str,
+        *,
+        metadata: Optional[Metadata],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Update a conversation
+
+        Args:
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return self._post(
+            f"/conversations/{conversation_id}",
+            body=maybe_transform({"metadata": metadata}, conversation_update_params.ConversationUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+    def delete(
+        self,
+        conversation_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ConversationDeletedResource:
+        """Delete a conversation.
+
+        Items in the conversation will not be deleted.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return self._delete(
+            f"/conversations/{conversation_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ConversationDeletedResource,
+        )
+
+
+class AsyncConversations(AsyncAPIResource):
+    @cached_property
+    def items(self) -> AsyncItems:
+        return AsyncItems(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncConversationsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncConversationsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncConversationsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncConversationsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        items: Optional[Iterable[ResponseInputItemParam]] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Create a conversation.
+
+        Args:
+          items: Initial items to include in the conversation context. You may add up to 20 items
+              at a time.
+
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/conversations",
+            body=await async_maybe_transform(
+                {
+                    "items": items,
+                    "metadata": metadata,
+                },
+                conversation_create_params.ConversationCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+    async def retrieve(
+        self,
+        conversation_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Get a conversation
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return await self._get(
+            f"/conversations/{conversation_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+    async def update(
+        self,
+        conversation_id: str,
+        *,
+        metadata: Optional[Metadata],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Update a conversation
+
+        Args:
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return await self._post(
+            f"/conversations/{conversation_id}",
+            body=await async_maybe_transform(
+                {"metadata": metadata}, conversation_update_params.ConversationUpdateParams
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+    async def delete(
+        self,
+        conversation_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ConversationDeletedResource:
+        """Delete a conversation.
+
+        Items in the conversation will not be deleted.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return await self._delete(
+            f"/conversations/{conversation_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ConversationDeletedResource,
+        )
+
+
+class ConversationsWithRawResponse:
+    def __init__(self, conversations: Conversations) -> None:
+        self._conversations = conversations
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            conversations.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            conversations.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            conversations.update,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            conversations.delete,
+        )
+
+    @cached_property
+    def items(self) -> ItemsWithRawResponse:
+        return ItemsWithRawResponse(self._conversations.items)
+
+
+class AsyncConversationsWithRawResponse:
+    def __init__(self, conversations: AsyncConversations) -> None:
+        self._conversations = conversations
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            conversations.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            conversations.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            conversations.update,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            conversations.delete,
+        )
+
+    @cached_property
+    def items(self) -> AsyncItemsWithRawResponse:
+        return AsyncItemsWithRawResponse(self._conversations.items)
+
+
+class ConversationsWithStreamingResponse:
+    def __init__(self, conversations: Conversations) -> None:
+        self._conversations = conversations
+
+        self.create = to_streamed_response_wrapper(
+            conversations.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            conversations.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            conversations.update,
+        )
+        self.delete = to_streamed_response_wrapper(
+            conversations.delete,
+        )
+
+    @cached_property
+    def items(self) -> ItemsWithStreamingResponse:
+        return ItemsWithStreamingResponse(self._conversations.items)
+
+
+class AsyncConversationsWithStreamingResponse:
+    def __init__(self, conversations: AsyncConversations) -> None:
+        self._conversations = conversations
+
+        self.create = async_to_streamed_response_wrapper(
+            conversations.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            conversations.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            conversations.update,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            conversations.delete,
+        )
+
+    @cached_property
+    def items(self) -> AsyncItemsWithStreamingResponse:
+        return AsyncItemsWithStreamingResponse(self._conversations.items)
diff --git a/src/openai/resources/conversations/items.py b/src/openai/resources/conversations/items.py
new file mode 100644
index 0000000000..3dba144849
--- /dev/null
+++ b/src/openai/resources/conversations/items.py
@@ -0,0 +1,557 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Any, List, Iterable, cast
+from typing_extensions import Literal
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...pagination import SyncConversationCursorPage, AsyncConversationCursorPage
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.conversations import item_list_params, item_create_params, item_retrieve_params
+from ...types.conversations.conversation import Conversation
+from ...types.responses.response_includable import ResponseIncludable
+from ...types.conversations.conversation_item import ConversationItem
+from ...types.responses.response_input_item_param import ResponseInputItemParam
+from ...types.conversations.conversation_item_list import ConversationItemList
+
+__all__ = ["Items", "AsyncItems"]
+
+
+class Items(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ItemsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return ItemsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ItemsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return ItemsWithStreamingResponse(self)
+
+    def create(
+        self,
+        conversation_id: str,
+        *,
+        items: Iterable[ResponseInputItemParam],
+        include: List[ResponseIncludable] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ConversationItemList:
+        """
+        Create items in a conversation with the given ID.
+
+        Args:
+          items: The items to add to the conversation. You may add up to 20 items at a time.
+
+          include: Additional fields to include in the response. See the `include` parameter for
+              [listing Conversation items above](https://platform.openai.com/docs/api-reference/conversations/list-items#conversations_list_items-include)
+              for more information.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return self._post(
+            f"/conversations/{conversation_id}/items",
+            body=maybe_transform({"items": items}, item_create_params.ItemCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"include": include}, item_create_params.ItemCreateParams),
+            ),
+            cast_to=ConversationItemList,
+        )
+
+    def retrieve(
+        self,
+        item_id: str,
+        *,
+        conversation_id: str,
+        include: List[ResponseIncludable] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ConversationItem:
+        """
+        Get a single item from a conversation with the given IDs.
+
+        Args:
+          include: Additional fields to include in the response. See the `include` parameter for
+              [listing Conversation items above](https://platform.openai.com/docs/api-reference/conversations/list-items#conversations_list_items-include)
+              for more information.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        if not item_id:
+            raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}")
+        return cast(
+            ConversationItem,
+            self._get(
+                f"/conversations/{conversation_id}/items/{item_id}",
+                options=make_request_options(
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                    query=maybe_transform({"include": include}, item_retrieve_params.ItemRetrieveParams),
+                ),
+                cast_to=cast(Any, ConversationItem),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def list(
+        self,
+        conversation_id: str,
+        *,
+        after: str | Omit = omit,
+        include: List[ResponseIncludable] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncConversationCursorPage[ConversationItem]:
+        """
+        List all items for a conversation with the given ID.
+
+        Args:
+          after: An item ID to list items after, used in pagination.
+
+          include: Specify additional output data to include in the model response. Currently
+              supported values are:
+
+              - `web_search_call.action.sources`: Include the sources of the web search tool
+                call.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
+              - `computer_call_output.output.image_url`: Include image urls from the computer
+                call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
+
+          limit: A limit on the number of objects to be returned. Limit can range between 1 and
+              100, and the default is 20.
+
+          order: The order to return the input items in. Default is `desc`.
+
+              - `asc`: Return the input items in ascending order.
+              - `desc`: Return the input items in descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return self._get_api_list(
+            f"/conversations/{conversation_id}/items",
+            page=SyncConversationCursorPage[ConversationItem],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "include": include,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    item_list_params.ItemListParams,
+                ),
+            ),
+            model=cast(Any, ConversationItem),  # Union types cannot be passed in as arguments in the type system
+        )
+
+    def delete(
+        self,
+        item_id: str,
+        *,
+        conversation_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Delete an item from a conversation with the given IDs.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        if not item_id:
+            raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}")
+        return self._delete(
+            f"/conversations/{conversation_id}/items/{item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+
+class AsyncItems(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncItemsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncItemsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncItemsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncItemsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        conversation_id: str,
+        *,
+        items: Iterable[ResponseInputItemParam],
+        include: List[ResponseIncludable] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ConversationItemList:
+        """
+        Create items in a conversation with the given ID.
+
+        Args:
+          items: The items to add to the conversation. You may add up to 20 items at a time.
+
+          include: Additional fields to include in the response. See the `include` parameter for
+              [listing Conversation items above](https://platform.openai.com/docs/api-reference/conversations/list-items#conversations_list_items-include)
+              for more information.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return await self._post(
+            f"/conversations/{conversation_id}/items",
+            body=await async_maybe_transform({"items": items}, item_create_params.ItemCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"include": include}, item_create_params.ItemCreateParams),
+            ),
+            cast_to=ConversationItemList,
+        )
+
+    async def retrieve(
+        self,
+        item_id: str,
+        *,
+        conversation_id: str,
+        include: List[ResponseIncludable] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ConversationItem:
+        """
+        Get a single item from a conversation with the given IDs.
+
+        Args:
+          include: Additional fields to include in the response. See the `include` parameter for
+              [listing Conversation items above](https://platform.openai.com/docs/api-reference/conversations/list-items#conversations_list_items-include)
+              for more information.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        if not item_id:
+            raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}")
+        return cast(
+            ConversationItem,
+            await self._get(
+                f"/conversations/{conversation_id}/items/{item_id}",
+                options=make_request_options(
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                    query=await async_maybe_transform({"include": include}, item_retrieve_params.ItemRetrieveParams),
+                ),
+                cast_to=cast(Any, ConversationItem),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def list(
+        self,
+        conversation_id: str,
+        *,
+        after: str | Omit = omit,
+        include: List[ResponseIncludable] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[ConversationItem, AsyncConversationCursorPage[ConversationItem]]:
+        """
+        List all items for a conversation with the given ID.
+
+        Args:
+          after: An item ID to list items after, used in pagination.
+
+          include: Specify additional output data to include in the model response. Currently
+              supported values are:
+
+              - `web_search_call.action.sources`: Include the sources of the web search tool
+                call.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
+              - `computer_call_output.output.image_url`: Include image urls from the computer
+                call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
+
+          limit: A limit on the number of objects to be returned. Limit can range between 1 and
+              100, and the default is 20.
+
+          order: The order to return the input items in. Default is `desc`.
+
+              - `asc`: Return the input items in ascending order.
+              - `desc`: Return the input items in descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        return self._get_api_list(
+            f"/conversations/{conversation_id}/items",
+            page=AsyncConversationCursorPage[ConversationItem],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "include": include,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    item_list_params.ItemListParams,
+                ),
+            ),
+            model=cast(Any, ConversationItem),  # Union types cannot be passed in as arguments in the type system
+        )
+
+    async def delete(
+        self,
+        item_id: str,
+        *,
+        conversation_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Conversation:
+        """
+        Delete an item from a conversation with the given IDs.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not conversation_id:
+            raise ValueError(f"Expected a non-empty value for `conversation_id` but received {conversation_id!r}")
+        if not item_id:
+            raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}")
+        return await self._delete(
+            f"/conversations/{conversation_id}/items/{item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Conversation,
+        )
+
+
+class ItemsWithRawResponse:
+    def __init__(self, items: Items) -> None:
+        self._items = items
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            items.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            items.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            items.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            items.delete,
+        )
+
+
+class AsyncItemsWithRawResponse:
+    def __init__(self, items: AsyncItems) -> None:
+        self._items = items
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            items.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            items.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            items.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            items.delete,
+        )
+
+
+class ItemsWithStreamingResponse:
+    def __init__(self, items: Items) -> None:
+        self._items = items
+
+        self.create = to_streamed_response_wrapper(
+            items.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            items.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            items.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            items.delete,
+        )
+
+
+class AsyncItemsWithStreamingResponse:
+    def __init__(self, items: AsyncItems) -> None:
+        self._items = items
+
+        self.create = async_to_streamed_response_wrapper(
+            items.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            items.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            items.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            items.delete,
+        )
diff --git a/src/openai/resources/embeddings.py b/src/openai/resources/embeddings.py
index a392d5eb17..5dc3dfa9b3 100644
--- a/src/openai/resources/embeddings.py
+++ b/src/openai/resources/embeddings.py
@@ -4,14 +4,14 @@
 
 import array
 import base64
-from typing import List, Union, Iterable, cast
+from typing import Union, Iterable, cast
 from typing_extensions import Literal
 
 import httpx
 
 from .. import _legacy_response
 from ..types import embedding_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
 from .._utils import is_given, maybe_transform
 from .._compat import cached_property
 from .._extras import numpy as np, has_numpy
@@ -47,17 +47,17 @@ def with_streaming_response(self) -> EmbeddingsWithStreamingResponse:
     def create(
         self,
         *,
-        input: Union[str, List[str], Iterable[int], Iterable[Iterable[int]]],
+        input: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]]],
         model: Union[str, EmbeddingModel],
-        dimensions: int | NotGiven = NOT_GIVEN,
-        encoding_format: Literal["float", "base64"] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        dimensions: int | Omit = omit,
+        encoding_format: Literal["float", "base64"] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> CreateEmbeddingResponse:
         """
         Creates an embedding vector representing the input text.
@@ -66,11 +66,12 @@ def create(
           input: Input text to embed, encoded as a string or array of tokens. To embed multiple
               inputs in a single request, pass an array of strings or array of token arrays.
               The input must not exceed the max input tokens for the model (8192 tokens for
-              `text-embedding-ada-002`), cannot be an empty string, and any array must be 2048
+              all embedding models), cannot be an empty string, and any array must be 2048
               dimensions or less.
               [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
-              for counting tokens. Some models may also impose a limit on total number of
-              tokens summed across inputs.
+              for counting tokens. In addition to the per-input token limit, all embedding
+              models enforce a maximum of 300,000 tokens summed across all inputs in a single
+              request.
 
           model: ID of the model to use. You can use the
               [List models](https://platform.openai.com/docs/api-reference/models/list) API to
@@ -111,6 +112,9 @@ def parser(obj: CreateEmbeddingResponse) -> CreateEmbeddingResponse:
                 # don't modify the response object if a user explicitly asked for a format
                 return obj
 
+            if not obj.data:
+                raise ValueError("No embedding data received")
+
             for embedding in obj.data:
                 data = cast(object, embedding.embedding)
                 if not isinstance(data, str):
@@ -162,17 +166,17 @@ def with_streaming_response(self) -> AsyncEmbeddingsWithStreamingResponse:
     async def create(
         self,
         *,
-        input: Union[str, List[str], Iterable[int], Iterable[Iterable[int]]],
+        input: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]]],
         model: Union[str, EmbeddingModel],
-        dimensions: int | NotGiven = NOT_GIVEN,
-        encoding_format: Literal["float", "base64"] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        dimensions: int | Omit = omit,
+        encoding_format: Literal["float", "base64"] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> CreateEmbeddingResponse:
         """
         Creates an embedding vector representing the input text.
@@ -181,11 +185,12 @@ async def create(
           input: Input text to embed, encoded as a string or array of tokens. To embed multiple
               inputs in a single request, pass an array of strings or array of token arrays.
               The input must not exceed the max input tokens for the model (8192 tokens for
-              `text-embedding-ada-002`), cannot be an empty string, and any array must be 2048
+              all embedding models), cannot be an empty string, and any array must be 2048
               dimensions or less.
               [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
-              for counting tokens. Some models may also impose a limit on total number of
-              tokens summed across inputs.
+              for counting tokens. In addition to the per-input token limit, all embedding
+              models enforce a maximum of 300,000 tokens summed across all inputs in a single
+              request.
 
           model: ID of the model to use. You can use the
               [List models](https://platform.openai.com/docs/api-reference/models/list) API to
@@ -226,6 +231,9 @@ def parser(obj: CreateEmbeddingResponse) -> CreateEmbeddingResponse:
                 # don't modify the response object if a user explicitly asked for a format
                 return obj
 
+            if not obj.data:
+                raise ValueError("No embedding data received")
+
             for embedding in obj.data:
                 data = cast(object, embedding.embedding)
                 if not isinstance(data, str):
diff --git a/src/openai/resources/evals/__init__.py b/src/openai/resources/evals/__init__.py
new file mode 100644
index 0000000000..84f707511d
--- /dev/null
+++ b/src/openai/resources/evals/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .runs import (
+    Runs,
+    AsyncRuns,
+    RunsWithRawResponse,
+    AsyncRunsWithRawResponse,
+    RunsWithStreamingResponse,
+    AsyncRunsWithStreamingResponse,
+)
+from .evals import (
+    Evals,
+    AsyncEvals,
+    EvalsWithRawResponse,
+    AsyncEvalsWithRawResponse,
+    EvalsWithStreamingResponse,
+    AsyncEvalsWithStreamingResponse,
+)
+
+__all__ = [
+    "Runs",
+    "AsyncRuns",
+    "RunsWithRawResponse",
+    "AsyncRunsWithRawResponse",
+    "RunsWithStreamingResponse",
+    "AsyncRunsWithStreamingResponse",
+    "Evals",
+    "AsyncEvals",
+    "EvalsWithRawResponse",
+    "AsyncEvalsWithRawResponse",
+    "EvalsWithStreamingResponse",
+    "AsyncEvalsWithStreamingResponse",
+]
diff --git a/src/openai/resources/evals/evals.py b/src/openai/resources/evals/evals.py
new file mode 100644
index 0000000000..40c4a3e9a3
--- /dev/null
+++ b/src/openai/resources/evals/evals.py
@@ -0,0 +1,662 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ... import _legacy_response
+from ...types import eval_list_params, eval_create_params, eval_update_params
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from .runs.runs import (
+    Runs,
+    AsyncRuns,
+    RunsWithRawResponse,
+    AsyncRunsWithRawResponse,
+    RunsWithStreamingResponse,
+    AsyncRunsWithStreamingResponse,
+)
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...pagination import SyncCursorPage, AsyncCursorPage
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.eval_list_response import EvalListResponse
+from ...types.eval_create_response import EvalCreateResponse
+from ...types.eval_delete_response import EvalDeleteResponse
+from ...types.eval_update_response import EvalUpdateResponse
+from ...types.eval_retrieve_response import EvalRetrieveResponse
+from ...types.shared_params.metadata import Metadata
+
+__all__ = ["Evals", "AsyncEvals"]
+
+
+class Evals(SyncAPIResource):
+    @cached_property
+    def runs(self) -> Runs:
+        return Runs(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> EvalsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return EvalsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> EvalsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return EvalsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        data_source_config: eval_create_params.DataSourceConfig,
+        testing_criteria: Iterable[eval_create_params.TestingCriterion],
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalCreateResponse:
+        """
+        Create the structure of an evaluation that can be used to test a model's
+        performance. An evaluation is a set of testing criteria and the config for a
+        data source, which dictates the schema of the data used in the evaluation. After
+        creating an evaluation, you can run it on different models and model parameters.
+        We support several types of graders and datasources. For more information, see
+        the [Evals guide](https://platform.openai.com/docs/guides/evals).
+
+        Args:
+          data_source_config: The configuration for the data source used for the evaluation runs. Dictates the
+              schema of the data used in the evaluation.
+
+          testing_criteria: A list of graders for all eval runs in this group. Graders can reference
+              variables in the data source using double curly braces notation, like
+              `{{item.variable_name}}`. To reference the model's output, use the `sample`
+              namespace (ie, `{{sample.output_text}}`).
+
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          name: The name of the evaluation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/evals",
+            body=maybe_transform(
+                {
+                    "data_source_config": data_source_config,
+                    "testing_criteria": testing_criteria,
+                    "metadata": metadata,
+                    "name": name,
+                },
+                eval_create_params.EvalCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        eval_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalRetrieveResponse:
+        """
+        Get an evaluation by ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return self._get(
+            f"/evals/{eval_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalRetrieveResponse,
+        )
+
+    def update(
+        self,
+        eval_id: str,
+        *,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalUpdateResponse:
+        """
+        Update certain properties of an evaluation.
+
+        Args:
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          name: Rename the evaluation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return self._post(
+            f"/evals/{eval_id}",
+            body=maybe_transform(
+                {
+                    "metadata": metadata,
+                    "name": name,
+                },
+                eval_update_params.EvalUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalUpdateResponse,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        order_by: Literal["created_at", "updated_at"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncCursorPage[EvalListResponse]:
+        """
+        List evaluations for a project.
+
+        Args:
+          after: Identifier for the last eval from the previous pagination request.
+
+          limit: Number of evals to retrieve.
+
+          order: Sort order for evals by timestamp. Use `asc` for ascending order or `desc` for
+              descending order.
+
+          order_by: Evals can be ordered by creation time or last updated time. Use `created_at` for
+              creation time or `updated_at` for last updated time.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/evals",
+            page=SyncCursorPage[EvalListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "order_by": order_by,
+                    },
+                    eval_list_params.EvalListParams,
+                ),
+            ),
+            model=EvalListResponse,
+        )
+
+    def delete(
+        self,
+        eval_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalDeleteResponse:
+        """
+        Delete an evaluation.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return self._delete(
+            f"/evals/{eval_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalDeleteResponse,
+        )
+
+
+class AsyncEvals(AsyncAPIResource):
+    @cached_property
+    def runs(self) -> AsyncRuns:
+        return AsyncRuns(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncEvalsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncEvalsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncEvalsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncEvalsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        data_source_config: eval_create_params.DataSourceConfig,
+        testing_criteria: Iterable[eval_create_params.TestingCriterion],
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalCreateResponse:
+        """
+        Create the structure of an evaluation that can be used to test a model's
+        performance. An evaluation is a set of testing criteria and the config for a
+        data source, which dictates the schema of the data used in the evaluation. After
+        creating an evaluation, you can run it on different models and model parameters.
+        We support several types of graders and datasources. For more information, see
+        the [Evals guide](https://platform.openai.com/docs/guides/evals).
+
+        Args:
+          data_source_config: The configuration for the data source used for the evaluation runs. Dictates the
+              schema of the data used in the evaluation.
+
+          testing_criteria: A list of graders for all eval runs in this group. Graders can reference
+              variables in the data source using double curly braces notation, like
+              `{{item.variable_name}}`. To reference the model's output, use the `sample`
+              namespace (ie, `{{sample.output_text}}`).
+
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          name: The name of the evaluation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/evals",
+            body=await async_maybe_transform(
+                {
+                    "data_source_config": data_source_config,
+                    "testing_criteria": testing_criteria,
+                    "metadata": metadata,
+                    "name": name,
+                },
+                eval_create_params.EvalCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        eval_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalRetrieveResponse:
+        """
+        Get an evaluation by ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return await self._get(
+            f"/evals/{eval_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalRetrieveResponse,
+        )
+
+    async def update(
+        self,
+        eval_id: str,
+        *,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalUpdateResponse:
+        """
+        Update certain properties of an evaluation.
+
+        Args:
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          name: Rename the evaluation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return await self._post(
+            f"/evals/{eval_id}",
+            body=await async_maybe_transform(
+                {
+                    "metadata": metadata,
+                    "name": name,
+                },
+                eval_update_params.EvalUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalUpdateResponse,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        order_by: Literal["created_at", "updated_at"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[EvalListResponse, AsyncCursorPage[EvalListResponse]]:
+        """
+        List evaluations for a project.
+
+        Args:
+          after: Identifier for the last eval from the previous pagination request.
+
+          limit: Number of evals to retrieve.
+
+          order: Sort order for evals by timestamp. Use `asc` for ascending order or `desc` for
+              descending order.
+
+          order_by: Evals can be ordered by creation time or last updated time. Use `created_at` for
+              creation time or `updated_at` for last updated time.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/evals",
+            page=AsyncCursorPage[EvalListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "order_by": order_by,
+                    },
+                    eval_list_params.EvalListParams,
+                ),
+            ),
+            model=EvalListResponse,
+        )
+
+    async def delete(
+        self,
+        eval_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EvalDeleteResponse:
+        """
+        Delete an evaluation.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return await self._delete(
+            f"/evals/{eval_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EvalDeleteResponse,
+        )
+
+
+class EvalsWithRawResponse:
+    def __init__(self, evals: Evals) -> None:
+        self._evals = evals
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            evals.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            evals.retrieve,
+        )
+        self.update = _legacy_response.to_raw_response_wrapper(
+            evals.update,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            evals.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            evals.delete,
+        )
+
+    @cached_property
+    def runs(self) -> RunsWithRawResponse:
+        return RunsWithRawResponse(self._evals.runs)
+
+
+class AsyncEvalsWithRawResponse:
+    def __init__(self, evals: AsyncEvals) -> None:
+        self._evals = evals
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            evals.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            evals.retrieve,
+        )
+        self.update = _legacy_response.async_to_raw_response_wrapper(
+            evals.update,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            evals.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            evals.delete,
+        )
+
+    @cached_property
+    def runs(self) -> AsyncRunsWithRawResponse:
+        return AsyncRunsWithRawResponse(self._evals.runs)
+
+
+class EvalsWithStreamingResponse:
+    def __init__(self, evals: Evals) -> None:
+        self._evals = evals
+
+        self.create = to_streamed_response_wrapper(
+            evals.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            evals.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            evals.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            evals.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            evals.delete,
+        )
+
+    @cached_property
+    def runs(self) -> RunsWithStreamingResponse:
+        return RunsWithStreamingResponse(self._evals.runs)
+
+
+class AsyncEvalsWithStreamingResponse:
+    def __init__(self, evals: AsyncEvals) -> None:
+        self._evals = evals
+
+        self.create = async_to_streamed_response_wrapper(
+            evals.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            evals.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            evals.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            evals.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            evals.delete,
+        )
+
+    @cached_property
+    def runs(self) -> AsyncRunsWithStreamingResponse:
+        return AsyncRunsWithStreamingResponse(self._evals.runs)
diff --git a/src/openai/resources/evals/runs/__init__.py b/src/openai/resources/evals/runs/__init__.py
new file mode 100644
index 0000000000..d189f16fb7
--- /dev/null
+++ b/src/openai/resources/evals/runs/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .runs import (
+    Runs,
+    AsyncRuns,
+    RunsWithRawResponse,
+    AsyncRunsWithRawResponse,
+    RunsWithStreamingResponse,
+    AsyncRunsWithStreamingResponse,
+)
+from .output_items import (
+    OutputItems,
+    AsyncOutputItems,
+    OutputItemsWithRawResponse,
+    AsyncOutputItemsWithRawResponse,
+    OutputItemsWithStreamingResponse,
+    AsyncOutputItemsWithStreamingResponse,
+)
+
+__all__ = [
+    "OutputItems",
+    "AsyncOutputItems",
+    "OutputItemsWithRawResponse",
+    "AsyncOutputItemsWithRawResponse",
+    "OutputItemsWithStreamingResponse",
+    "AsyncOutputItemsWithStreamingResponse",
+    "Runs",
+    "AsyncRuns",
+    "RunsWithRawResponse",
+    "AsyncRunsWithRawResponse",
+    "RunsWithStreamingResponse",
+    "AsyncRunsWithStreamingResponse",
+]
diff --git a/src/openai/resources/evals/runs/output_items.py b/src/openai/resources/evals/runs/output_items.py
new file mode 100644
index 0000000000..c2dee72122
--- /dev/null
+++ b/src/openai/resources/evals/runs/output_items.py
@@ -0,0 +1,315 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncCursorPage, AsyncCursorPage
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.evals.runs import output_item_list_params
+from ....types.evals.runs.output_item_list_response import OutputItemListResponse
+from ....types.evals.runs.output_item_retrieve_response import OutputItemRetrieveResponse
+
+__all__ = ["OutputItems", "AsyncOutputItems"]
+
+
+class OutputItems(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> OutputItemsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return OutputItemsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> OutputItemsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return OutputItemsWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        output_item_id: str,
+        *,
+        eval_id: str,
+        run_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> OutputItemRetrieveResponse:
+        """
+        Get an evaluation run output item by ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        if not output_item_id:
+            raise ValueError(f"Expected a non-empty value for `output_item_id` but received {output_item_id!r}")
+        return self._get(
+            f"/evals/{eval_id}/runs/{run_id}/output_items/{output_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OutputItemRetrieveResponse,
+        )
+
+    def list(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        status: Literal["fail", "pass"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncCursorPage[OutputItemListResponse]:
+        """
+        Get a list of output items for an evaluation run.
+
+        Args:
+          after: Identifier for the last output item from the previous pagination request.
+
+          limit: Number of output items to retrieve.
+
+          order: Sort order for output items by timestamp. Use `asc` for ascending order or
+              `desc` for descending order. Defaults to `asc`.
+
+          status: Filter output items by status. Use `failed` to filter by failed output items or
+              `pass` to filter by passed output items.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return self._get_api_list(
+            f"/evals/{eval_id}/runs/{run_id}/output_items",
+            page=SyncCursorPage[OutputItemListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "status": status,
+                    },
+                    output_item_list_params.OutputItemListParams,
+                ),
+            ),
+            model=OutputItemListResponse,
+        )
+
+
+class AsyncOutputItems(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncOutputItemsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncOutputItemsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncOutputItemsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncOutputItemsWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        output_item_id: str,
+        *,
+        eval_id: str,
+        run_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> OutputItemRetrieveResponse:
+        """
+        Get an evaluation run output item by ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        if not output_item_id:
+            raise ValueError(f"Expected a non-empty value for `output_item_id` but received {output_item_id!r}")
+        return await self._get(
+            f"/evals/{eval_id}/runs/{run_id}/output_items/{output_item_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=OutputItemRetrieveResponse,
+        )
+
+    def list(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        status: Literal["fail", "pass"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[OutputItemListResponse, AsyncCursorPage[OutputItemListResponse]]:
+        """
+        Get a list of output items for an evaluation run.
+
+        Args:
+          after: Identifier for the last output item from the previous pagination request.
+
+          limit: Number of output items to retrieve.
+
+          order: Sort order for output items by timestamp. Use `asc` for ascending order or
+              `desc` for descending order. Defaults to `asc`.
+
+          status: Filter output items by status. Use `failed` to filter by failed output items or
+              `pass` to filter by passed output items.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return self._get_api_list(
+            f"/evals/{eval_id}/runs/{run_id}/output_items",
+            page=AsyncCursorPage[OutputItemListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "status": status,
+                    },
+                    output_item_list_params.OutputItemListParams,
+                ),
+            ),
+            model=OutputItemListResponse,
+        )
+
+
+class OutputItemsWithRawResponse:
+    def __init__(self, output_items: OutputItems) -> None:
+        self._output_items = output_items
+
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            output_items.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            output_items.list,
+        )
+
+
+class AsyncOutputItemsWithRawResponse:
+    def __init__(self, output_items: AsyncOutputItems) -> None:
+        self._output_items = output_items
+
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            output_items.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            output_items.list,
+        )
+
+
+class OutputItemsWithStreamingResponse:
+    def __init__(self, output_items: OutputItems) -> None:
+        self._output_items = output_items
+
+        self.retrieve = to_streamed_response_wrapper(
+            output_items.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            output_items.list,
+        )
+
+
+class AsyncOutputItemsWithStreamingResponse:
+    def __init__(self, output_items: AsyncOutputItems) -> None:
+        self._output_items = output_items
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            output_items.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            output_items.list,
+        )
diff --git a/src/openai/resources/evals/runs/runs.py b/src/openai/resources/evals/runs/runs.py
new file mode 100644
index 0000000000..b747b198f8
--- /dev/null
+++ b/src/openai/resources/evals/runs/runs.py
@@ -0,0 +1,634 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from .output_items import (
+    OutputItems,
+    AsyncOutputItems,
+    OutputItemsWithRawResponse,
+    AsyncOutputItemsWithRawResponse,
+    OutputItemsWithStreamingResponse,
+    AsyncOutputItemsWithStreamingResponse,
+)
+from ....pagination import SyncCursorPage, AsyncCursorPage
+from ....types.evals import run_list_params, run_create_params
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.shared_params.metadata import Metadata
+from ....types.evals.run_list_response import RunListResponse
+from ....types.evals.run_cancel_response import RunCancelResponse
+from ....types.evals.run_create_response import RunCreateResponse
+from ....types.evals.run_delete_response import RunDeleteResponse
+from ....types.evals.run_retrieve_response import RunRetrieveResponse
+
+__all__ = ["Runs", "AsyncRuns"]
+
+
+class Runs(SyncAPIResource):
+    @cached_property
+    def output_items(self) -> OutputItems:
+        return OutputItems(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> RunsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return RunsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RunsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return RunsWithStreamingResponse(self)
+
+    def create(
+        self,
+        eval_id: str,
+        *,
+        data_source: run_create_params.DataSource,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunCreateResponse:
+        """
+        Kicks off a new run for a given evaluation, specifying the data source, and what
+        model configuration to use to test. The datasource will be validated against the
+        schema specified in the config of the evaluation.
+
+        Args:
+          data_source: Details about the run's data source.
+
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          name: The name of the run.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return self._post(
+            f"/evals/{eval_id}/runs",
+            body=maybe_transform(
+                {
+                    "data_source": data_source,
+                    "metadata": metadata,
+                    "name": name,
+                },
+                run_create_params.RunCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunRetrieveResponse:
+        """
+        Get an evaluation run by ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return self._get(
+            f"/evals/{eval_id}/runs/{run_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunRetrieveResponse,
+        )
+
+    def list(
+        self,
+        eval_id: str,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        status: Literal["queued", "in_progress", "completed", "canceled", "failed"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncCursorPage[RunListResponse]:
+        """
+        Get a list of runs for an evaluation.
+
+        Args:
+          after: Identifier for the last run from the previous pagination request.
+
+          limit: Number of runs to retrieve.
+
+          order: Sort order for runs by timestamp. Use `asc` for ascending order or `desc` for
+              descending order. Defaults to `asc`.
+
+          status: Filter runs by status. One of `queued` | `in_progress` | `failed` | `completed`
+              | `canceled`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return self._get_api_list(
+            f"/evals/{eval_id}/runs",
+            page=SyncCursorPage[RunListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "status": status,
+                    },
+                    run_list_params.RunListParams,
+                ),
+            ),
+            model=RunListResponse,
+        )
+
+    def delete(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunDeleteResponse:
+        """
+        Delete an eval run.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return self._delete(
+            f"/evals/{eval_id}/runs/{run_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunDeleteResponse,
+        )
+
+    def cancel(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunCancelResponse:
+        """
+        Cancel an ongoing evaluation run.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return self._post(
+            f"/evals/{eval_id}/runs/{run_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunCancelResponse,
+        )
+
+
+class AsyncRuns(AsyncAPIResource):
+    @cached_property
+    def output_items(self) -> AsyncOutputItems:
+        return AsyncOutputItems(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncRunsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncRunsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRunsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncRunsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        eval_id: str,
+        *,
+        data_source: run_create_params.DataSource,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunCreateResponse:
+        """
+        Kicks off a new run for a given evaluation, specifying the data source, and what
+        model configuration to use to test. The datasource will be validated against the
+        schema specified in the config of the evaluation.
+
+        Args:
+          data_source: Details about the run's data source.
+
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
+              querying for objects via API or the dashboard.
+
+              Keys are strings with a maximum length of 64 characters. Values are strings with
+              a maximum length of 512 characters.
+
+          name: The name of the run.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return await self._post(
+            f"/evals/{eval_id}/runs",
+            body=await async_maybe_transform(
+                {
+                    "data_source": data_source,
+                    "metadata": metadata,
+                    "name": name,
+                },
+                run_create_params.RunCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunRetrieveResponse:
+        """
+        Get an evaluation run by ID.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return await self._get(
+            f"/evals/{eval_id}/runs/{run_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunRetrieveResponse,
+        )
+
+    def list(
+        self,
+        eval_id: str,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        status: Literal["queued", "in_progress", "completed", "canceled", "failed"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[RunListResponse, AsyncCursorPage[RunListResponse]]:
+        """
+        Get a list of runs for an evaluation.
+
+        Args:
+          after: Identifier for the last run from the previous pagination request.
+
+          limit: Number of runs to retrieve.
+
+          order: Sort order for runs by timestamp. Use `asc` for ascending order or `desc` for
+              descending order. Defaults to `asc`.
+
+          status: Filter runs by status. One of `queued` | `in_progress` | `failed` | `completed`
+              | `canceled`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        return self._get_api_list(
+            f"/evals/{eval_id}/runs",
+            page=AsyncCursorPage[RunListResponse],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "status": status,
+                    },
+                    run_list_params.RunListParams,
+                ),
+            ),
+            model=RunListResponse,
+        )
+
+    async def delete(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunDeleteResponse:
+        """
+        Delete an eval run.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return await self._delete(
+            f"/evals/{eval_id}/runs/{run_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunDeleteResponse,
+        )
+
+    async def cancel(
+        self,
+        run_id: str,
+        *,
+        eval_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> RunCancelResponse:
+        """
+        Cancel an ongoing evaluation run.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not eval_id:
+            raise ValueError(f"Expected a non-empty value for `eval_id` but received {eval_id!r}")
+        if not run_id:
+            raise ValueError(f"Expected a non-empty value for `run_id` but received {run_id!r}")
+        return await self._post(
+            f"/evals/{eval_id}/runs/{run_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RunCancelResponse,
+        )
+
+
+class RunsWithRawResponse:
+    def __init__(self, runs: Runs) -> None:
+        self._runs = runs
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            runs.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            runs.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            runs.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            runs.delete,
+        )
+        self.cancel = _legacy_response.to_raw_response_wrapper(
+            runs.cancel,
+        )
+
+    @cached_property
+    def output_items(self) -> OutputItemsWithRawResponse:
+        return OutputItemsWithRawResponse(self._runs.output_items)
+
+
+class AsyncRunsWithRawResponse:
+    def __init__(self, runs: AsyncRuns) -> None:
+        self._runs = runs
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            runs.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            runs.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            runs.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            runs.delete,
+        )
+        self.cancel = _legacy_response.async_to_raw_response_wrapper(
+            runs.cancel,
+        )
+
+    @cached_property
+    def output_items(self) -> AsyncOutputItemsWithRawResponse:
+        return AsyncOutputItemsWithRawResponse(self._runs.output_items)
+
+
+class RunsWithStreamingResponse:
+    def __init__(self, runs: Runs) -> None:
+        self._runs = runs
+
+        self.create = to_streamed_response_wrapper(
+            runs.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            runs.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            runs.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            runs.delete,
+        )
+        self.cancel = to_streamed_response_wrapper(
+            runs.cancel,
+        )
+
+    @cached_property
+    def output_items(self) -> OutputItemsWithStreamingResponse:
+        return OutputItemsWithStreamingResponse(self._runs.output_items)
+
+
+class AsyncRunsWithStreamingResponse:
+    def __init__(self, runs: AsyncRuns) -> None:
+        self._runs = runs
+
+        self.create = async_to_streamed_response_wrapper(
+            runs.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            runs.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            runs.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            runs.delete,
+        )
+        self.cancel = async_to_streamed_response_wrapper(
+            runs.cancel,
+        )
+
+    @cached_property
+    def output_items(self) -> AsyncOutputItemsWithStreamingResponse:
+        return AsyncOutputItemsWithStreamingResponse(self._runs.output_items)
diff --git a/src/openai/resources/files.py b/src/openai/resources/files.py
index 2eaa4a6401..cc117e7f15 100644
--- a/src/openai/resources/files.py
+++ b/src/openai/resources/files.py
@@ -11,13 +11,8 @@
 
 from .. import _legacy_response
 from ..types import FilePurpose, file_list_params, file_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from .._utils import (
-    extract_files,
-    maybe_transform,
-    deepcopy_minimal,
-    async_maybe_transform,
-)
+from .._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
+from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -62,33 +57,33 @@ def create(
         *,
         file: FileTypes,
         purpose: FilePurpose,
+        expires_after: file_create_params.ExpiresAfter | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FileObject:
         """Upload a file that can be used across various endpoints.
 
         Individual files can be
         up to 512 MB, and the size of all files uploaded by one organization can be up
-        to 100 GB.
-
-        The Assistants API supports files up to 2 million tokens and of specific file
-        types. See the
-        [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools) for
-        details.
-
-        The Fine-tuning API only supports `.jsonl` files. The input also has certain
-        required formats for fine-tuning
-        [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input) or
-        [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
-        models.
-
-        The Batch API only supports `.jsonl` files up to 200 MB in size. The input also
-        has a specific required
-        [format](https://platform.openai.com/docs/api-reference/batch/request-input).
+        to 1 TB.
+
+        - The Assistants API supports files up to 2 million tokens and of specific file
+          types. See the
+          [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools)
+          for details.
+        - The Fine-tuning API only supports `.jsonl` files. The input also has certain
+          required formats for fine-tuning
+          [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input)
+          or
+          [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
+          models.
+        - The Batch API only supports `.jsonl` files up to 200 MB in size. The input
+          also has a specific required
+          [format](https://platform.openai.com/docs/api-reference/batch/request-input).
 
         Please [contact us](https://help.openai.com/) if you need to increase these
         storage limits.
@@ -101,6 +96,9 @@ def create(
               fine-tuning - `vision`: Images used for vision fine-tuning - `user_data`:
               Flexible file type for any purpose - `evals`: Used for eval data sets
 
+          expires_after: The expiration policy for a file. By default, files with `purpose=batch` expire
+              after 30 days and all other files are persisted until they are manually deleted.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -113,6 +111,7 @@ def create(
             {
                 "file": file,
                 "purpose": purpose,
+                "expires_after": expires_after,
             }
         )
         files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
@@ -139,7 +138,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FileObject:
         """
         Returns information about a specific file.
@@ -166,16 +165,16 @@ def retrieve(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
-        purpose: str | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        purpose: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[FileObject]:
         """Returns a list of files.
 
@@ -233,10 +232,10 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FileDeleted:
         """
-        Delete a file.
+        Delete a file and remove it from all vector stores.
 
         Args:
           extra_headers: Send extra headers
@@ -266,7 +265,7 @@ def content(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> _legacy_response.HttpxBinaryResponseContent:
         """
         Returns the contents of the specified file.
@@ -301,7 +300,7 @@ def retrieve_content(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> str:
         """
         Returns the contents of the specified file.
@@ -374,33 +373,33 @@ async def create(
         *,
         file: FileTypes,
         purpose: FilePurpose,
+        expires_after: file_create_params.ExpiresAfter | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FileObject:
         """Upload a file that can be used across various endpoints.
 
         Individual files can be
         up to 512 MB, and the size of all files uploaded by one organization can be up
-        to 100 GB.
-
-        The Assistants API supports files up to 2 million tokens and of specific file
-        types. See the
-        [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools) for
-        details.
-
-        The Fine-tuning API only supports `.jsonl` files. The input also has certain
-        required formats for fine-tuning
-        [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input) or
-        [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
-        models.
-
-        The Batch API only supports `.jsonl` files up to 200 MB in size. The input also
-        has a specific required
-        [format](https://platform.openai.com/docs/api-reference/batch/request-input).
+        to 1 TB.
+
+        - The Assistants API supports files up to 2 million tokens and of specific file
+          types. See the
+          [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools)
+          for details.
+        - The Fine-tuning API only supports `.jsonl` files. The input also has certain
+          required formats for fine-tuning
+          [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input)
+          or
+          [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
+          models.
+        - The Batch API only supports `.jsonl` files up to 200 MB in size. The input
+          also has a specific required
+          [format](https://platform.openai.com/docs/api-reference/batch/request-input).
 
         Please [contact us](https://help.openai.com/) if you need to increase these
         storage limits.
@@ -413,6 +412,9 @@ async def create(
               fine-tuning - `vision`: Images used for vision fine-tuning - `user_data`:
               Flexible file type for any purpose - `evals`: Used for eval data sets
 
+          expires_after: The expiration policy for a file. By default, files with `purpose=batch` expire
+              after 30 days and all other files are persisted until they are manually deleted.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -425,6 +427,7 @@ async def create(
             {
                 "file": file,
                 "purpose": purpose,
+                "expires_after": expires_after,
             }
         )
         files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
@@ -451,7 +454,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FileObject:
         """
         Returns information about a specific file.
@@ -478,16 +481,16 @@ async def retrieve(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
-        purpose: str | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        purpose: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[FileObject, AsyncCursorPage[FileObject]]:
         """Returns a list of files.
 
@@ -545,10 +548,10 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FileDeleted:
         """
-        Delete a file.
+        Delete a file and remove it from all vector stores.
 
         Args:
           extra_headers: Send extra headers
@@ -578,7 +581,7 @@ async def content(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> _legacy_response.HttpxBinaryResponseContent:
         """
         Returns the contents of the specified file.
@@ -613,7 +616,7 @@ async def retrieve_content(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> str:
         """
         Returns the contents of the specified file.
@@ -682,7 +685,7 @@ def __init__(self, files: Files) -> None:
         )
         self.retrieve_content = (  # pyright: ignore[reportDeprecated]
             _legacy_response.to_raw_response_wrapper(
-                files.retrieve_content  # pyright: ignore[reportDeprecated],
+                files.retrieve_content,  # pyright: ignore[reportDeprecated],
             )
         )
 
@@ -708,7 +711,7 @@ def __init__(self, files: AsyncFiles) -> None:
         )
         self.retrieve_content = (  # pyright: ignore[reportDeprecated]
             _legacy_response.async_to_raw_response_wrapper(
-                files.retrieve_content  # pyright: ignore[reportDeprecated],
+                files.retrieve_content,  # pyright: ignore[reportDeprecated],
             )
         )
 
@@ -735,7 +738,7 @@ def __init__(self, files: Files) -> None:
         )
         self.retrieve_content = (  # pyright: ignore[reportDeprecated]
             to_streamed_response_wrapper(
-                files.retrieve_content  # pyright: ignore[reportDeprecated],
+                files.retrieve_content,  # pyright: ignore[reportDeprecated],
             )
         )
 
@@ -762,6 +765,6 @@ def __init__(self, files: AsyncFiles) -> None:
         )
         self.retrieve_content = (  # pyright: ignore[reportDeprecated]
             async_to_streamed_response_wrapper(
-                files.retrieve_content  # pyright: ignore[reportDeprecated],
+                files.retrieve_content,  # pyright: ignore[reportDeprecated],
             )
         )
diff --git a/src/openai/resources/fine_tuning/__init__.py b/src/openai/resources/fine_tuning/__init__.py
index 7765231fee..c76af83deb 100644
--- a/src/openai/resources/fine_tuning/__init__.py
+++ b/src/openai/resources/fine_tuning/__init__.py
@@ -8,6 +8,22 @@
     JobsWithStreamingResponse,
     AsyncJobsWithStreamingResponse,
 )
+from .alpha import (
+    Alpha,
+    AsyncAlpha,
+    AlphaWithRawResponse,
+    AsyncAlphaWithRawResponse,
+    AlphaWithStreamingResponse,
+    AsyncAlphaWithStreamingResponse,
+)
+from .checkpoints import (
+    Checkpoints,
+    AsyncCheckpoints,
+    CheckpointsWithRawResponse,
+    AsyncCheckpointsWithRawResponse,
+    CheckpointsWithStreamingResponse,
+    AsyncCheckpointsWithStreamingResponse,
+)
 from .fine_tuning import (
     FineTuning,
     AsyncFineTuning,
@@ -24,6 +40,18 @@
     "AsyncJobsWithRawResponse",
     "JobsWithStreamingResponse",
     "AsyncJobsWithStreamingResponse",
+    "Checkpoints",
+    "AsyncCheckpoints",
+    "CheckpointsWithRawResponse",
+    "AsyncCheckpointsWithRawResponse",
+    "CheckpointsWithStreamingResponse",
+    "AsyncCheckpointsWithStreamingResponse",
+    "Alpha",
+    "AsyncAlpha",
+    "AlphaWithRawResponse",
+    "AsyncAlphaWithRawResponse",
+    "AlphaWithStreamingResponse",
+    "AsyncAlphaWithStreamingResponse",
     "FineTuning",
     "AsyncFineTuning",
     "FineTuningWithRawResponse",
diff --git a/src/openai/resources/fine_tuning/alpha/__init__.py b/src/openai/resources/fine_tuning/alpha/__init__.py
new file mode 100644
index 0000000000..8bed8af4fd
--- /dev/null
+++ b/src/openai/resources/fine_tuning/alpha/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .alpha import (
+    Alpha,
+    AsyncAlpha,
+    AlphaWithRawResponse,
+    AsyncAlphaWithRawResponse,
+    AlphaWithStreamingResponse,
+    AsyncAlphaWithStreamingResponse,
+)
+from .graders import (
+    Graders,
+    AsyncGraders,
+    GradersWithRawResponse,
+    AsyncGradersWithRawResponse,
+    GradersWithStreamingResponse,
+    AsyncGradersWithStreamingResponse,
+)
+
+__all__ = [
+    "Graders",
+    "AsyncGraders",
+    "GradersWithRawResponse",
+    "AsyncGradersWithRawResponse",
+    "GradersWithStreamingResponse",
+    "AsyncGradersWithStreamingResponse",
+    "Alpha",
+    "AsyncAlpha",
+    "AlphaWithRawResponse",
+    "AsyncAlphaWithRawResponse",
+    "AlphaWithStreamingResponse",
+    "AsyncAlphaWithStreamingResponse",
+]
diff --git a/src/openai/resources/fine_tuning/alpha/alpha.py b/src/openai/resources/fine_tuning/alpha/alpha.py
new file mode 100644
index 0000000000..54c05fab69
--- /dev/null
+++ b/src/openai/resources/fine_tuning/alpha/alpha.py
@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .graders import (
+    Graders,
+    AsyncGraders,
+    GradersWithRawResponse,
+    AsyncGradersWithRawResponse,
+    GradersWithStreamingResponse,
+    AsyncGradersWithStreamingResponse,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["Alpha", "AsyncAlpha"]
+
+
+class Alpha(SyncAPIResource):
+    @cached_property
+    def graders(self) -> Graders:
+        return Graders(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AlphaWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AlphaWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AlphaWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AlphaWithStreamingResponse(self)
+
+
+class AsyncAlpha(AsyncAPIResource):
+    @cached_property
+    def graders(self) -> AsyncGraders:
+        return AsyncGraders(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncAlphaWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAlphaWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAlphaWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncAlphaWithStreamingResponse(self)
+
+
+class AlphaWithRawResponse:
+    def __init__(self, alpha: Alpha) -> None:
+        self._alpha = alpha
+
+    @cached_property
+    def graders(self) -> GradersWithRawResponse:
+        return GradersWithRawResponse(self._alpha.graders)
+
+
+class AsyncAlphaWithRawResponse:
+    def __init__(self, alpha: AsyncAlpha) -> None:
+        self._alpha = alpha
+
+    @cached_property
+    def graders(self) -> AsyncGradersWithRawResponse:
+        return AsyncGradersWithRawResponse(self._alpha.graders)
+
+
+class AlphaWithStreamingResponse:
+    def __init__(self, alpha: Alpha) -> None:
+        self._alpha = alpha
+
+    @cached_property
+    def graders(self) -> GradersWithStreamingResponse:
+        return GradersWithStreamingResponse(self._alpha.graders)
+
+
+class AsyncAlphaWithStreamingResponse:
+    def __init__(self, alpha: AsyncAlpha) -> None:
+        self._alpha = alpha
+
+    @cached_property
+    def graders(self) -> AsyncGradersWithStreamingResponse:
+        return AsyncGradersWithStreamingResponse(self._alpha.graders)
diff --git a/src/openai/resources/fine_tuning/alpha/graders.py b/src/openai/resources/fine_tuning/alpha/graders.py
new file mode 100644
index 0000000000..e7a9b925ea
--- /dev/null
+++ b/src/openai/resources/fine_tuning/alpha/graders.py
@@ -0,0 +1,282 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ...._base_client import make_request_options
+from ....types.fine_tuning.alpha import grader_run_params, grader_validate_params
+from ....types.fine_tuning.alpha.grader_run_response import GraderRunResponse
+from ....types.fine_tuning.alpha.grader_validate_response import GraderValidateResponse
+
+__all__ = ["Graders", "AsyncGraders"]
+
+
+class Graders(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> GradersWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return GradersWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> GradersWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return GradersWithStreamingResponse(self)
+
+    def run(
+        self,
+        *,
+        grader: grader_run_params.Grader,
+        model_sample: str,
+        item: object | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> GraderRunResponse:
+        """
+        Run a grader.
+
+        Args:
+          grader: The grader used for the fine-tuning job.
+
+          model_sample: The model sample to be evaluated. This value will be used to populate the
+              `sample` namespace. See
+              [the guide](https://platform.openai.com/docs/guides/graders) for more details.
+              The `output_json` variable will be populated if the model sample is a valid JSON
+              string.
+
+          item: The dataset item provided to the grader. This will be used to populate the
+              `item` namespace. See
+              [the guide](https://platform.openai.com/docs/guides/graders) for more details.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/fine_tuning/alpha/graders/run",
+            body=maybe_transform(
+                {
+                    "grader": grader,
+                    "model_sample": model_sample,
+                    "item": item,
+                },
+                grader_run_params.GraderRunParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=GraderRunResponse,
+        )
+
+    def validate(
+        self,
+        *,
+        grader: grader_validate_params.Grader,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> GraderValidateResponse:
+        """
+        Validate a grader.
+
+        Args:
+          grader: The grader used for the fine-tuning job.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/fine_tuning/alpha/graders/validate",
+            body=maybe_transform({"grader": grader}, grader_validate_params.GraderValidateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=GraderValidateResponse,
+        )
+
+
+class AsyncGraders(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncGradersWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncGradersWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncGradersWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncGradersWithStreamingResponse(self)
+
+    async def run(
+        self,
+        *,
+        grader: grader_run_params.Grader,
+        model_sample: str,
+        item: object | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> GraderRunResponse:
+        """
+        Run a grader.
+
+        Args:
+          grader: The grader used for the fine-tuning job.
+
+          model_sample: The model sample to be evaluated. This value will be used to populate the
+              `sample` namespace. See
+              [the guide](https://platform.openai.com/docs/guides/graders) for more details.
+              The `output_json` variable will be populated if the model sample is a valid JSON
+              string.
+
+          item: The dataset item provided to the grader. This will be used to populate the
+              `item` namespace. See
+              [the guide](https://platform.openai.com/docs/guides/graders) for more details.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/fine_tuning/alpha/graders/run",
+            body=await async_maybe_transform(
+                {
+                    "grader": grader,
+                    "model_sample": model_sample,
+                    "item": item,
+                },
+                grader_run_params.GraderRunParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=GraderRunResponse,
+        )
+
+    async def validate(
+        self,
+        *,
+        grader: grader_validate_params.Grader,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> GraderValidateResponse:
+        """
+        Validate a grader.
+
+        Args:
+          grader: The grader used for the fine-tuning job.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/fine_tuning/alpha/graders/validate",
+            body=await async_maybe_transform({"grader": grader}, grader_validate_params.GraderValidateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=GraderValidateResponse,
+        )
+
+
+class GradersWithRawResponse:
+    def __init__(self, graders: Graders) -> None:
+        self._graders = graders
+
+        self.run = _legacy_response.to_raw_response_wrapper(
+            graders.run,
+        )
+        self.validate = _legacy_response.to_raw_response_wrapper(
+            graders.validate,
+        )
+
+
+class AsyncGradersWithRawResponse:
+    def __init__(self, graders: AsyncGraders) -> None:
+        self._graders = graders
+
+        self.run = _legacy_response.async_to_raw_response_wrapper(
+            graders.run,
+        )
+        self.validate = _legacy_response.async_to_raw_response_wrapper(
+            graders.validate,
+        )
+
+
+class GradersWithStreamingResponse:
+    def __init__(self, graders: Graders) -> None:
+        self._graders = graders
+
+        self.run = to_streamed_response_wrapper(
+            graders.run,
+        )
+        self.validate = to_streamed_response_wrapper(
+            graders.validate,
+        )
+
+
+class AsyncGradersWithStreamingResponse:
+    def __init__(self, graders: AsyncGraders) -> None:
+        self._graders = graders
+
+        self.run = async_to_streamed_response_wrapper(
+            graders.run,
+        )
+        self.validate = async_to_streamed_response_wrapper(
+            graders.validate,
+        )
diff --git a/src/openai/resources/fine_tuning/checkpoints/__init__.py b/src/openai/resources/fine_tuning/checkpoints/__init__.py
new file mode 100644
index 0000000000..fdc37940f9
--- /dev/null
+++ b/src/openai/resources/fine_tuning/checkpoints/__init__.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .checkpoints import (
+    Checkpoints,
+    AsyncCheckpoints,
+    CheckpointsWithRawResponse,
+    AsyncCheckpointsWithRawResponse,
+    CheckpointsWithStreamingResponse,
+    AsyncCheckpointsWithStreamingResponse,
+)
+from .permissions import (
+    Permissions,
+    AsyncPermissions,
+    PermissionsWithRawResponse,
+    AsyncPermissionsWithRawResponse,
+    PermissionsWithStreamingResponse,
+    AsyncPermissionsWithStreamingResponse,
+)
+
+__all__ = [
+    "Permissions",
+    "AsyncPermissions",
+    "PermissionsWithRawResponse",
+    "AsyncPermissionsWithRawResponse",
+    "PermissionsWithStreamingResponse",
+    "AsyncPermissionsWithStreamingResponse",
+    "Checkpoints",
+    "AsyncCheckpoints",
+    "CheckpointsWithRawResponse",
+    "AsyncCheckpointsWithRawResponse",
+    "CheckpointsWithStreamingResponse",
+    "AsyncCheckpointsWithStreamingResponse",
+]
diff --git a/src/openai/resources/fine_tuning/checkpoints/checkpoints.py b/src/openai/resources/fine_tuning/checkpoints/checkpoints.py
new file mode 100644
index 0000000000..f59976a264
--- /dev/null
+++ b/src/openai/resources/fine_tuning/checkpoints/checkpoints.py
@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ...._compat import cached_property
+from .permissions import (
+    Permissions,
+    AsyncPermissions,
+    PermissionsWithRawResponse,
+    AsyncPermissionsWithRawResponse,
+    PermissionsWithStreamingResponse,
+    AsyncPermissionsWithStreamingResponse,
+)
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["Checkpoints", "AsyncCheckpoints"]
+
+
+class Checkpoints(SyncAPIResource):
+    @cached_property
+    def permissions(self) -> Permissions:
+        return Permissions(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> CheckpointsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return CheckpointsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CheckpointsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return CheckpointsWithStreamingResponse(self)
+
+
+class AsyncCheckpoints(AsyncAPIResource):
+    @cached_property
+    def permissions(self) -> AsyncPermissions:
+        return AsyncPermissions(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncCheckpointsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCheckpointsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCheckpointsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncCheckpointsWithStreamingResponse(self)
+
+
+class CheckpointsWithRawResponse:
+    def __init__(self, checkpoints: Checkpoints) -> None:
+        self._checkpoints = checkpoints
+
+    @cached_property
+    def permissions(self) -> PermissionsWithRawResponse:
+        return PermissionsWithRawResponse(self._checkpoints.permissions)
+
+
+class AsyncCheckpointsWithRawResponse:
+    def __init__(self, checkpoints: AsyncCheckpoints) -> None:
+        self._checkpoints = checkpoints
+
+    @cached_property
+    def permissions(self) -> AsyncPermissionsWithRawResponse:
+        return AsyncPermissionsWithRawResponse(self._checkpoints.permissions)
+
+
+class CheckpointsWithStreamingResponse:
+    def __init__(self, checkpoints: Checkpoints) -> None:
+        self._checkpoints = checkpoints
+
+    @cached_property
+    def permissions(self) -> PermissionsWithStreamingResponse:
+        return PermissionsWithStreamingResponse(self._checkpoints.permissions)
+
+
+class AsyncCheckpointsWithStreamingResponse:
+    def __init__(self, checkpoints: AsyncCheckpoints) -> None:
+        self._checkpoints = checkpoints
+
+    @cached_property
+    def permissions(self) -> AsyncPermissionsWithStreamingResponse:
+        return AsyncPermissionsWithStreamingResponse(self._checkpoints.permissions)
diff --git a/src/openai/resources/fine_tuning/checkpoints/permissions.py b/src/openai/resources/fine_tuning/checkpoints/permissions.py
new file mode 100644
index 0000000000..e7f55b82d9
--- /dev/null
+++ b/src/openai/resources/fine_tuning/checkpoints/permissions.py
@@ -0,0 +1,418 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from .... import _legacy_response
+from ...._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ....pagination import SyncPage, AsyncPage
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.fine_tuning.checkpoints import permission_create_params, permission_retrieve_params
+from ....types.fine_tuning.checkpoints.permission_create_response import PermissionCreateResponse
+from ....types.fine_tuning.checkpoints.permission_delete_response import PermissionDeleteResponse
+from ....types.fine_tuning.checkpoints.permission_retrieve_response import PermissionRetrieveResponse
+
+__all__ = ["Permissions", "AsyncPermissions"]
+
+
+class Permissions(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> PermissionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return PermissionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PermissionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return PermissionsWithStreamingResponse(self)
+
+    def create(
+        self,
+        fine_tuned_model_checkpoint: str,
+        *,
+        project_ids: SequenceNotStr[str],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncPage[PermissionCreateResponse]:
+        """
+        **NOTE:** Calling this endpoint requires an [admin API key](../admin-api-keys).
+
+        This enables organization owners to share fine-tuned models with other projects
+        in their organization.
+
+        Args:
+          project_ids: The project identifiers to grant access to.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuned_model_checkpoint:
+            raise ValueError(
+                f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
+            )
+        return self._get_api_list(
+            f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
+            page=SyncPage[PermissionCreateResponse],
+            body=maybe_transform({"project_ids": project_ids}, permission_create_params.PermissionCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            model=PermissionCreateResponse,
+            method="post",
+        )
+
+    def retrieve(
+        self,
+        fine_tuned_model_checkpoint: str,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["ascending", "descending"] | Omit = omit,
+        project_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> PermissionRetrieveResponse:
+        """
+        **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
+
+        Organization owners can use this endpoint to view all permissions for a
+        fine-tuned model checkpoint.
+
+        Args:
+          after: Identifier for the last permission ID from the previous pagination request.
+
+          limit: Number of permissions to retrieve.
+
+          order: The order in which to retrieve permissions.
+
+          project_id: The ID of the project to get permissions for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuned_model_checkpoint:
+            raise ValueError(
+                f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
+            )
+        return self._get(
+            f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "project_id": project_id,
+                    },
+                    permission_retrieve_params.PermissionRetrieveParams,
+                ),
+            ),
+            cast_to=PermissionRetrieveResponse,
+        )
+
+    def delete(
+        self,
+        permission_id: str,
+        *,
+        fine_tuned_model_checkpoint: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> PermissionDeleteResponse:
+        """
+        **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
+
+        Organization owners can use this endpoint to delete a permission for a
+        fine-tuned model checkpoint.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuned_model_checkpoint:
+            raise ValueError(
+                f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
+            )
+        if not permission_id:
+            raise ValueError(f"Expected a non-empty value for `permission_id` but received {permission_id!r}")
+        return self._delete(
+            f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions/{permission_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=PermissionDeleteResponse,
+        )
+
+
+class AsyncPermissions(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncPermissionsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncPermissionsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPermissionsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncPermissionsWithStreamingResponse(self)
+
+    def create(
+        self,
+        fine_tuned_model_checkpoint: str,
+        *,
+        project_ids: SequenceNotStr[str],
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[PermissionCreateResponse, AsyncPage[PermissionCreateResponse]]:
+        """
+        **NOTE:** Calling this endpoint requires an [admin API key](../admin-api-keys).
+
+        This enables organization owners to share fine-tuned models with other projects
+        in their organization.
+
+        Args:
+          project_ids: The project identifiers to grant access to.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuned_model_checkpoint:
+            raise ValueError(
+                f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
+            )
+        return self._get_api_list(
+            f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
+            page=AsyncPage[PermissionCreateResponse],
+            body=maybe_transform({"project_ids": project_ids}, permission_create_params.PermissionCreateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            model=PermissionCreateResponse,
+            method="post",
+        )
+
+    async def retrieve(
+        self,
+        fine_tuned_model_checkpoint: str,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["ascending", "descending"] | Omit = omit,
+        project_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> PermissionRetrieveResponse:
+        """
+        **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
+
+        Organization owners can use this endpoint to view all permissions for a
+        fine-tuned model checkpoint.
+
+        Args:
+          after: Identifier for the last permission ID from the previous pagination request.
+
+          limit: Number of permissions to retrieve.
+
+          order: The order in which to retrieve permissions.
+
+          project_id: The ID of the project to get permissions for.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuned_model_checkpoint:
+            raise ValueError(
+                f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
+            )
+        return await self._get(
+            f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                        "project_id": project_id,
+                    },
+                    permission_retrieve_params.PermissionRetrieveParams,
+                ),
+            ),
+            cast_to=PermissionRetrieveResponse,
+        )
+
+    async def delete(
+        self,
+        permission_id: str,
+        *,
+        fine_tuned_model_checkpoint: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> PermissionDeleteResponse:
+        """
+        **NOTE:** This endpoint requires an [admin API key](../admin-api-keys).
+
+        Organization owners can use this endpoint to delete a permission for a
+        fine-tuned model checkpoint.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuned_model_checkpoint:
+            raise ValueError(
+                f"Expected a non-empty value for `fine_tuned_model_checkpoint` but received {fine_tuned_model_checkpoint!r}"
+            )
+        if not permission_id:
+            raise ValueError(f"Expected a non-empty value for `permission_id` but received {permission_id!r}")
+        return await self._delete(
+            f"/fine_tuning/checkpoints/{fine_tuned_model_checkpoint}/permissions/{permission_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=PermissionDeleteResponse,
+        )
+
+
+class PermissionsWithRawResponse:
+    def __init__(self, permissions: Permissions) -> None:
+        self._permissions = permissions
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            permissions.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            permissions.retrieve,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            permissions.delete,
+        )
+
+
+class AsyncPermissionsWithRawResponse:
+    def __init__(self, permissions: AsyncPermissions) -> None:
+        self._permissions = permissions
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            permissions.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            permissions.retrieve,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            permissions.delete,
+        )
+
+
+class PermissionsWithStreamingResponse:
+    def __init__(self, permissions: Permissions) -> None:
+        self._permissions = permissions
+
+        self.create = to_streamed_response_wrapper(
+            permissions.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            permissions.retrieve,
+        )
+        self.delete = to_streamed_response_wrapper(
+            permissions.delete,
+        )
+
+
+class AsyncPermissionsWithStreamingResponse:
+    def __init__(self, permissions: AsyncPermissions) -> None:
+        self._permissions = permissions
+
+        self.create = async_to_streamed_response_wrapper(
+            permissions.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            permissions.retrieve,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            permissions.delete,
+        )
diff --git a/src/openai/resources/fine_tuning/fine_tuning.py b/src/openai/resources/fine_tuning/fine_tuning.py
index eebde07d81..25ae3e8cf4 100644
--- a/src/openai/resources/fine_tuning/fine_tuning.py
+++ b/src/openai/resources/fine_tuning/fine_tuning.py
@@ -12,6 +12,22 @@
     AsyncJobsWithStreamingResponse,
 )
 from ..._resource import SyncAPIResource, AsyncAPIResource
+from .alpha.alpha import (
+    Alpha,
+    AsyncAlpha,
+    AlphaWithRawResponse,
+    AsyncAlphaWithRawResponse,
+    AlphaWithStreamingResponse,
+    AsyncAlphaWithStreamingResponse,
+)
+from .checkpoints.checkpoints import (
+    Checkpoints,
+    AsyncCheckpoints,
+    CheckpointsWithRawResponse,
+    AsyncCheckpointsWithRawResponse,
+    CheckpointsWithStreamingResponse,
+    AsyncCheckpointsWithStreamingResponse,
+)
 
 __all__ = ["FineTuning", "AsyncFineTuning"]
 
@@ -21,6 +37,14 @@ class FineTuning(SyncAPIResource):
     def jobs(self) -> Jobs:
         return Jobs(self._client)
 
+    @cached_property
+    def checkpoints(self) -> Checkpoints:
+        return Checkpoints(self._client)
+
+    @cached_property
+    def alpha(self) -> Alpha:
+        return Alpha(self._client)
+
     @cached_property
     def with_raw_response(self) -> FineTuningWithRawResponse:
         """
@@ -46,6 +70,14 @@ class AsyncFineTuning(AsyncAPIResource):
     def jobs(self) -> AsyncJobs:
         return AsyncJobs(self._client)
 
+    @cached_property
+    def checkpoints(self) -> AsyncCheckpoints:
+        return AsyncCheckpoints(self._client)
+
+    @cached_property
+    def alpha(self) -> AsyncAlpha:
+        return AsyncAlpha(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncFineTuningWithRawResponse:
         """
@@ -74,6 +106,14 @@ def __init__(self, fine_tuning: FineTuning) -> None:
     def jobs(self) -> JobsWithRawResponse:
         return JobsWithRawResponse(self._fine_tuning.jobs)
 
+    @cached_property
+    def checkpoints(self) -> CheckpointsWithRawResponse:
+        return CheckpointsWithRawResponse(self._fine_tuning.checkpoints)
+
+    @cached_property
+    def alpha(self) -> AlphaWithRawResponse:
+        return AlphaWithRawResponse(self._fine_tuning.alpha)
+
 
 class AsyncFineTuningWithRawResponse:
     def __init__(self, fine_tuning: AsyncFineTuning) -> None:
@@ -83,6 +123,14 @@ def __init__(self, fine_tuning: AsyncFineTuning) -> None:
     def jobs(self) -> AsyncJobsWithRawResponse:
         return AsyncJobsWithRawResponse(self._fine_tuning.jobs)
 
+    @cached_property
+    def checkpoints(self) -> AsyncCheckpointsWithRawResponse:
+        return AsyncCheckpointsWithRawResponse(self._fine_tuning.checkpoints)
+
+    @cached_property
+    def alpha(self) -> AsyncAlphaWithRawResponse:
+        return AsyncAlphaWithRawResponse(self._fine_tuning.alpha)
+
 
 class FineTuningWithStreamingResponse:
     def __init__(self, fine_tuning: FineTuning) -> None:
@@ -92,6 +140,14 @@ def __init__(self, fine_tuning: FineTuning) -> None:
     def jobs(self) -> JobsWithStreamingResponse:
         return JobsWithStreamingResponse(self._fine_tuning.jobs)
 
+    @cached_property
+    def checkpoints(self) -> CheckpointsWithStreamingResponse:
+        return CheckpointsWithStreamingResponse(self._fine_tuning.checkpoints)
+
+    @cached_property
+    def alpha(self) -> AlphaWithStreamingResponse:
+        return AlphaWithStreamingResponse(self._fine_tuning.alpha)
+
 
 class AsyncFineTuningWithStreamingResponse:
     def __init__(self, fine_tuning: AsyncFineTuning) -> None:
@@ -100,3 +156,11 @@ def __init__(self, fine_tuning: AsyncFineTuning) -> None:
     @cached_property
     def jobs(self) -> AsyncJobsWithStreamingResponse:
         return AsyncJobsWithStreamingResponse(self._fine_tuning.jobs)
+
+    @cached_property
+    def checkpoints(self) -> AsyncCheckpointsWithStreamingResponse:
+        return AsyncCheckpointsWithStreamingResponse(self._fine_tuning.checkpoints)
+
+    @cached_property
+    def alpha(self) -> AsyncAlphaWithStreamingResponse:
+        return AsyncAlphaWithStreamingResponse(self._fine_tuning.alpha)
diff --git a/src/openai/resources/fine_tuning/jobs/checkpoints.py b/src/openai/resources/fine_tuning/jobs/checkpoints.py
index f86462e513..f65856f0c6 100644
--- a/src/openai/resources/fine_tuning/jobs/checkpoints.py
+++ b/src/openai/resources/fine_tuning/jobs/checkpoints.py
@@ -5,7 +5,7 @@
 import httpx
 
 from .... import _legacy_response
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from ...._utils import maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
@@ -45,14 +45,14 @@ def list(
         self,
         fine_tuning_job_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[FineTuningJobCheckpoint]:
         """
         List checkpoints for a fine-tuning job.
@@ -116,14 +116,14 @@ def list(
         self,
         fine_tuning_job_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[FineTuningJobCheckpoint, AsyncCursorPage[FineTuningJobCheckpoint]]:
         """
         List checkpoints for a fine-tuning job.
diff --git a/src/openai/resources/fine_tuning/jobs/jobs.py b/src/openai/resources/fine_tuning/jobs/jobs.py
index bbeff60bc6..b292e057cf 100644
--- a/src/openai/resources/fine_tuning/jobs/jobs.py
+++ b/src/openai/resources/fine_tuning/jobs/jobs.py
@@ -8,11 +8,8 @@
 import httpx
 
 from .... import _legacy_response
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ...._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ...._utils import maybe_transform, async_maybe_transform
 from ...._compat import cached_property
 from .checkpoints import (
     Checkpoints,
@@ -66,19 +63,19 @@ def create(
         *,
         model: Union[str, Literal["babbage-002", "davinci-002", "gpt-3.5-turbo", "gpt-4o-mini"]],
         training_file: str,
-        hyperparameters: job_create_params.Hyperparameters | NotGiven = NOT_GIVEN,
-        integrations: Optional[Iterable[job_create_params.Integration]] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        method: job_create_params.Method | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        validation_file: Optional[str] | NotGiven = NOT_GIVEN,
+        hyperparameters: job_create_params.Hyperparameters | Omit = omit,
+        integrations: Optional[Iterable[job_create_params.Integration]] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        method: job_create_params.Method | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        validation_file: Optional[str] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FineTuningJob:
         """
         Creates a fine-tuning job which begins the process of creating a new model from
@@ -87,7 +84,7 @@ def create(
         Response includes details of the enqueued job including job status and the name
         of the fine-tuned models once complete.
 
-        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
+        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
 
         Args:
           model: The name of the model to fine-tune. You can select one of the
@@ -108,7 +105,8 @@ def create(
               [preference](https://platform.openai.com/docs/api-reference/fine-tuning/preference-input)
               format.
 
-              See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
+              See the
+              [fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
               for more details.
 
           hyperparameters: The hyperparameters used for the fine-tuning job. This value is now deprecated
@@ -145,7 +143,8 @@ def create(
               Your dataset must be formatted as a JSONL file. You must upload your file with
               the purpose `fine-tune`.
 
-              See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
+              See the
+              [fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
               for more details.
 
           extra_headers: Send extra headers
@@ -187,12 +186,12 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FineTuningJob:
         """
         Get info about a fine-tuning job.
 
-        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
+        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
 
         Args:
           extra_headers: Send extra headers
@@ -216,15 +215,15 @@ def retrieve(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        metadata: Optional[Dict[str, str]] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        metadata: Optional[Dict[str, str]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[FineTuningJob]:
         """
         List your organization's fine-tuning jobs
@@ -274,7 +273,7 @@ def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FineTuningJob:
         """
         Immediately cancel a fine-tune job.
@@ -302,14 +301,14 @@ def list_events(
         self,
         fine_tuning_job_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[FineTuningJobEvent]:
         """
         Get status updates for a fine-tuning job.
@@ -348,6 +347,72 @@ def list_events(
             model=FineTuningJobEvent,
         )
 
+    def pause(
+        self,
+        fine_tuning_job_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FineTuningJob:
+        """
+        Pause a fine-tune job.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuning_job_id:
+            raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
+        return self._post(
+            f"/fine_tuning/jobs/{fine_tuning_job_id}/pause",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FineTuningJob,
+        )
+
+    def resume(
+        self,
+        fine_tuning_job_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FineTuningJob:
+        """
+        Resume a fine-tune job.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuning_job_id:
+            raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
+        return self._post(
+            f"/fine_tuning/jobs/{fine_tuning_job_id}/resume",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FineTuningJob,
+        )
+
 
 class AsyncJobs(AsyncAPIResource):
     @cached_property
@@ -378,19 +443,19 @@ async def create(
         *,
         model: Union[str, Literal["babbage-002", "davinci-002", "gpt-3.5-turbo", "gpt-4o-mini"]],
         training_file: str,
-        hyperparameters: job_create_params.Hyperparameters | NotGiven = NOT_GIVEN,
-        integrations: Optional[Iterable[job_create_params.Integration]] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        method: job_create_params.Method | NotGiven = NOT_GIVEN,
-        seed: Optional[int] | NotGiven = NOT_GIVEN,
-        suffix: Optional[str] | NotGiven = NOT_GIVEN,
-        validation_file: Optional[str] | NotGiven = NOT_GIVEN,
+        hyperparameters: job_create_params.Hyperparameters | Omit = omit,
+        integrations: Optional[Iterable[job_create_params.Integration]] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        method: job_create_params.Method | Omit = omit,
+        seed: Optional[int] | Omit = omit,
+        suffix: Optional[str] | Omit = omit,
+        validation_file: Optional[str] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FineTuningJob:
         """
         Creates a fine-tuning job which begins the process of creating a new model from
@@ -399,7 +464,7 @@ async def create(
         Response includes details of the enqueued job including job status and the name
         of the fine-tuned models once complete.
 
-        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
+        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
 
         Args:
           model: The name of the model to fine-tune. You can select one of the
@@ -420,7 +485,8 @@ async def create(
               [preference](https://platform.openai.com/docs/api-reference/fine-tuning/preference-input)
               format.
 
-              See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
+              See the
+              [fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
               for more details.
 
           hyperparameters: The hyperparameters used for the fine-tuning job. This value is now deprecated
@@ -457,7 +523,8 @@ async def create(
               Your dataset must be formatted as a JSONL file. You must upload your file with
               the purpose `fine-tune`.
 
-              See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
+              See the
+              [fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
               for more details.
 
           extra_headers: Send extra headers
@@ -499,12 +566,12 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FineTuningJob:
         """
         Get info about a fine-tuning job.
 
-        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
+        [Learn more about fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
 
         Args:
           extra_headers: Send extra headers
@@ -528,15 +595,15 @@ async def retrieve(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        metadata: Optional[Dict[str, str]] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        metadata: Optional[Dict[str, str]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[FineTuningJob, AsyncCursorPage[FineTuningJob]]:
         """
         List your organization's fine-tuning jobs
@@ -586,7 +653,7 @@ async def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> FineTuningJob:
         """
         Immediately cancel a fine-tune job.
@@ -614,14 +681,14 @@ def list_events(
         self,
         fine_tuning_job_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[FineTuningJobEvent, AsyncCursorPage[FineTuningJobEvent]]:
         """
         Get status updates for a fine-tuning job.
@@ -660,6 +727,72 @@ def list_events(
             model=FineTuningJobEvent,
         )
 
+    async def pause(
+        self,
+        fine_tuning_job_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FineTuningJob:
+        """
+        Pause a fine-tune job.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuning_job_id:
+            raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
+        return await self._post(
+            f"/fine_tuning/jobs/{fine_tuning_job_id}/pause",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FineTuningJob,
+        )
+
+    async def resume(
+        self,
+        fine_tuning_job_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FineTuningJob:
+        """
+        Resume a fine-tune job.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not fine_tuning_job_id:
+            raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
+        return await self._post(
+            f"/fine_tuning/jobs/{fine_tuning_job_id}/resume",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FineTuningJob,
+        )
+
 
 class JobsWithRawResponse:
     def __init__(self, jobs: Jobs) -> None:
@@ -680,6 +813,12 @@ def __init__(self, jobs: Jobs) -> None:
         self.list_events = _legacy_response.to_raw_response_wrapper(
             jobs.list_events,
         )
+        self.pause = _legacy_response.to_raw_response_wrapper(
+            jobs.pause,
+        )
+        self.resume = _legacy_response.to_raw_response_wrapper(
+            jobs.resume,
+        )
 
     @cached_property
     def checkpoints(self) -> CheckpointsWithRawResponse:
@@ -705,6 +844,12 @@ def __init__(self, jobs: AsyncJobs) -> None:
         self.list_events = _legacy_response.async_to_raw_response_wrapper(
             jobs.list_events,
         )
+        self.pause = _legacy_response.async_to_raw_response_wrapper(
+            jobs.pause,
+        )
+        self.resume = _legacy_response.async_to_raw_response_wrapper(
+            jobs.resume,
+        )
 
     @cached_property
     def checkpoints(self) -> AsyncCheckpointsWithRawResponse:
@@ -730,6 +875,12 @@ def __init__(self, jobs: Jobs) -> None:
         self.list_events = to_streamed_response_wrapper(
             jobs.list_events,
         )
+        self.pause = to_streamed_response_wrapper(
+            jobs.pause,
+        )
+        self.resume = to_streamed_response_wrapper(
+            jobs.resume,
+        )
 
     @cached_property
     def checkpoints(self) -> CheckpointsWithStreamingResponse:
@@ -755,6 +906,12 @@ def __init__(self, jobs: AsyncJobs) -> None:
         self.list_events = async_to_streamed_response_wrapper(
             jobs.list_events,
         )
+        self.pause = async_to_streamed_response_wrapper(
+            jobs.pause,
+        )
+        self.resume = async_to_streamed_response_wrapper(
+            jobs.resume,
+        )
 
     @cached_property
     def checkpoints(self) -> AsyncCheckpointsWithStreamingResponse:
diff --git a/src/openai/resources/images.py b/src/openai/resources/images.py
index 30473c14f7..265be6f743 100644
--- a/src/openai/resources/images.py
+++ b/src/openai/resources/images.py
@@ -3,25 +3,23 @@
 from __future__ import annotations
 
 from typing import Union, Mapping, Optional, cast
-from typing_extensions import Literal
+from typing_extensions import Literal, overload
 
 import httpx
 
 from .. import _legacy_response
 from ..types import image_edit_params, image_generate_params, image_create_variation_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from .._utils import (
-    extract_files,
-    maybe_transform,
-    deepcopy_minimal,
-    async_maybe_transform,
-)
+from .._types import Body, Omit, Query, Headers, NotGiven, FileTypes, SequenceNotStr, omit, not_given
+from .._utils import extract_files, required_args, maybe_transform, deepcopy_minimal, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from .._streaming import Stream, AsyncStream
 from .._base_client import make_request_options
 from ..types.image_model import ImageModel
 from ..types.images_response import ImagesResponse
+from ..types.image_gen_stream_event import ImageGenStreamEvent
+from ..types.image_edit_stream_event import ImageEditStreamEvent
 
 __all__ = ["Images", "AsyncImages"]
 
@@ -50,20 +48,21 @@ def create_variation(
         self,
         *,
         image: FileTypes,
-        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ImagesResponse:
-        """
-        Creates a variation of a given image.
+        """Creates a variation of a given image.
+
+        This endpoint only supports `dall-e-2`.
 
         Args:
           image: The image to use as the basis for the variation(s). Must be a valid PNG file,
@@ -72,8 +71,7 @@ def create_variation(
           model: The model to use for image generation. Only `dall-e-2` is supported at this
               time.
 
-          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
-              `n=1` is supported.
+          n: The number of images to generate. Must be between 1 and 10.
 
           response_format: The format in which the generated images are returned. Must be one of `url` or
               `b64_json`. URLs are only valid for 60 minutes after the image has been
@@ -119,49 +117,217 @@ def create_variation(
             cast_to=ImagesResponse,
         )
 
+    @overload
     def edit(
         self,
         *,
-        image: FileTypes,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
         prompt: str,
-        mask: FileTypes | NotGiven = NOT_GIVEN,
-        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ImagesResponse:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+              `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        Creates an edited or extended image given an original image and a prompt.
+        ...
+
+    @overload
+    def edit(
+        self,
+        *,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
+        prompt: str,
+        stream: Literal[True],
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Stream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
 
         Args:
-          image: The image to edit. Must be a valid PNG file, less than 4MB, and square. If mask
-              is not provided, image must have transparency, which will be used as the mask.
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
 
           prompt: A text description of the desired image(s). The maximum length is 1000
-              characters.
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+              `low`. Defaults to `low`.
 
           mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
-              indicate where `image` should be edited. Must be a valid PNG file, less than
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
               4MB, and have the same dimensions as `image`.
 
-          model: The model to use for image generation. Only `dall-e-2` is supported at this
-              time.
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
 
           n: The number of images to generate. Must be between 1 and 10.
 
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
           response_format: The format in which the generated images are returned. Must be one of `url` or
               `b64_json`. URLs are only valid for 60 minutes after the image has been
-              generated.
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
 
-          size: The size of the generated images. Must be one of `256x256`, `512x512`, or
-              `1024x1024`.
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
 
           user: A unique identifier representing your end-user, which can help OpenAI to monitor
               and detect abuse.
@@ -175,79 +341,391 @@ def edit(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @overload
+    def edit(
+        self,
+        *,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
+        prompt: str,
+        stream: bool,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | Stream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+              `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["image", "prompt"], ["image", "prompt", "stream"])
+    def edit(
+        self,
+        *,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | Stream[ImageEditStreamEvent]:
         body = deepcopy_minimal(
             {
                 "image": image,
                 "prompt": prompt,
+                "background": background,
+                "input_fidelity": input_fidelity,
                 "mask": mask,
                 "model": model,
                 "n": n,
+                "output_compression": output_compression,
+                "output_format": output_format,
+                "partial_images": partial_images,
+                "quality": quality,
                 "response_format": response_format,
                 "size": size,
+                "stream": stream,
                 "user": user,
             }
         )
-        files = extract_files(cast(Mapping[str, object], body), paths=[["image"], ["mask"]])
+        files = extract_files(cast(Mapping[str, object], body), paths=[["image"], ["image", "<array>"], ["mask"]])
         # It should be noted that the actual Content-Type header that will be
         # sent to the server will contain a `boundary` parameter, e.g.
         # multipart/form-data; boundary=---abc--
         extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
         return self._post(
             "/images/edits",
-            body=maybe_transform(body, image_edit_params.ImageEditParams),
+            body=maybe_transform(
+                body,
+                image_edit_params.ImageEditParamsStreaming if stream else image_edit_params.ImageEditParamsNonStreaming,
+            ),
             files=files,
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=Stream[ImageEditStreamEvent],
         )
 
+    @overload
     def generate(
         self,
         *,
         prompt: str,
-        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        quality: Literal["standard", "hd"] | NotGiven = NOT_GIVEN,
-        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN,
-        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ImagesResponse:
         """
         Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
 
         Args:
-          prompt: A text description of the desired image(s). The maximum length is 1000
-              characters for `dall-e-2` and 4000 characters for `dall-e-3`.
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
 
-          model: The model to use for image generation.
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
 
           n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
               `n=1` is supported.
 
-          quality: The quality of the image that will be generated. `hd` creates images with finer
-              details and greater consistency across the image. This param is only supported
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    def generate(
+        self,
+        *,
+        prompt: str,
+        stream: Literal[True],
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Stream[ImageGenStreamEvent]:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
+
+        Args:
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
               for `dall-e-3`.
 
-          response_format: The format in which the generated images are returned. Must be one of `url` or
-              `b64_json`. URLs are only valid for 60 minutes after the image has been
-              generated.
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
 
-          size: The size of the generated images. Must be one of `256x256`, `512x512`, or
-              `1024x1024` for `dall-e-2`. Must be one of `1024x1024`, `1792x1024`, or
-              `1024x1792` for `dall-e-3` models.
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
+
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
 
-          style: The style of the generated images. Must be one of `vivid` or `natural`. Vivid
-              causes the model to lean towards generating hyper-real and dramatic images.
-              Natural causes the model to produce more natural, less hyper-real looking
-              images. This param is only supported for `dall-e-3`.
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
 
           user: A unique identifier representing your end-user, which can help OpenAI to monitor
               and detect abuse.
@@ -261,25 +739,175 @@ def generate(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @overload
+    def generate(
+        self,
+        *,
+        prompt: str,
+        stream: bool,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | Stream[ImageGenStreamEvent]:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
+
+        Args:
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
+
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
+
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["prompt"], ["prompt", "stream"])
+    def generate(
+        self,
+        *,
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | Stream[ImageGenStreamEvent]:
         return self._post(
             "/images/generations",
             body=maybe_transform(
                 {
                     "prompt": prompt,
+                    "background": background,
                     "model": model,
+                    "moderation": moderation,
                     "n": n,
+                    "output_compression": output_compression,
+                    "output_format": output_format,
+                    "partial_images": partial_images,
                     "quality": quality,
                     "response_format": response_format,
                     "size": size,
+                    "stream": stream,
                     "style": style,
                     "user": user,
                 },
-                image_generate_params.ImageGenerateParams,
+                image_generate_params.ImageGenerateParamsStreaming
+                if stream
+                else image_generate_params.ImageGenerateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=Stream[ImageGenStreamEvent],
         )
 
 
@@ -307,20 +935,21 @@ async def create_variation(
         self,
         *,
         image: FileTypes,
-        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ImagesResponse:
-        """
-        Creates a variation of a given image.
+        """Creates a variation of a given image.
+
+        This endpoint only supports `dall-e-2`.
 
         Args:
           image: The image to use as the basis for the variation(s). Must be a valid PNG file,
@@ -329,8 +958,7 @@ async def create_variation(
           model: The model to use for image generation. Only `dall-e-2` is supported at this
               time.
 
-          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
-              `n=1` is supported.
+          n: The number of images to generate. Must be between 1 and 10.
 
           response_format: The format in which the generated images are returned. Must be one of `url` or
               `b64_json`. URLs are only valid for 60 minutes after the image has been
@@ -376,49 +1004,217 @@ async def create_variation(
             cast_to=ImagesResponse,
         )
 
+    @overload
     async def edit(
         self,
         *,
-        image: FileTypes,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
         prompt: str,
-        mask: FileTypes | NotGiven = NOT_GIVEN,
-        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ImagesResponse:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+              `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        Creates an edited or extended image given an original image and a prompt.
+        ...
+
+    @overload
+    async def edit(
+        self,
+        *,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
+        prompt: str,
+        stream: Literal[True],
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncStream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
 
         Args:
-          image: The image to edit. Must be a valid PNG file, less than 4MB, and square. If mask
-              is not provided, image must have transparency, which will be used as the mask.
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
 
           prompt: A text description of the desired image(s). The maximum length is 1000
-              characters.
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+              `low`. Defaults to `low`.
 
           mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
-              indicate where `image` should be edited. Must be a valid PNG file, less than
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
               4MB, and have the same dimensions as `image`.
 
-          model: The model to use for image generation. Only `dall-e-2` is supported at this
-              time.
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
 
           n: The number of images to generate. Must be between 1 and 10.
 
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
           response_format: The format in which the generated images are returned. Must be one of `url` or
               `b64_json`. URLs are only valid for 60 minutes after the image has been
-              generated.
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
 
-          size: The size of the generated images. Must be one of `256x256`, `512x512`, or
-              `1024x1024`.
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
 
           user: A unique identifier representing your end-user, which can help OpenAI to monitor
               and detect abuse.
@@ -432,79 +1228,391 @@ async def edit(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @overload
+    async def edit(
+        self,
+        *,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
+        prompt: str,
+        stream: bool,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | AsyncStream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+              `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["image", "prompt"], ["image", "prompt", "stream"])
+    async def edit(
+        self,
+        *,
+        image: Union[FileTypes, SequenceNotStr[FileTypes]],
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        input_fidelity: Optional[Literal["high", "low"]] | Omit = omit,
+        mask: FileTypes | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | AsyncStream[ImageEditStreamEvent]:
         body = deepcopy_minimal(
             {
                 "image": image,
                 "prompt": prompt,
+                "background": background,
+                "input_fidelity": input_fidelity,
                 "mask": mask,
                 "model": model,
                 "n": n,
+                "output_compression": output_compression,
+                "output_format": output_format,
+                "partial_images": partial_images,
+                "quality": quality,
                 "response_format": response_format,
                 "size": size,
+                "stream": stream,
                 "user": user,
             }
         )
-        files = extract_files(cast(Mapping[str, object], body), paths=[["image"], ["mask"]])
+        files = extract_files(cast(Mapping[str, object], body), paths=[["image"], ["image", "<array>"], ["mask"]])
         # It should be noted that the actual Content-Type header that will be
         # sent to the server will contain a `boundary` parameter, e.g.
         # multipart/form-data; boundary=---abc--
         extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
         return await self._post(
             "/images/edits",
-            body=await async_maybe_transform(body, image_edit_params.ImageEditParams),
+            body=await async_maybe_transform(
+                body,
+                image_edit_params.ImageEditParamsStreaming if stream else image_edit_params.ImageEditParamsNonStreaming,
+            ),
             files=files,
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=AsyncStream[ImageEditStreamEvent],
         )
 
+    @overload
     async def generate(
         self,
         *,
         prompt: str,
-        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        quality: Literal["standard", "hd"] | NotGiven = NOT_GIVEN,
-        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] | NotGiven = NOT_GIVEN,
-        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ImagesResponse:
         """
         Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
 
         Args:
-          prompt: A text description of the desired image(s). The maximum length is 1000
-              characters for `dall-e-2` and 4000 characters for `dall-e-3`.
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
 
-          model: The model to use for image generation.
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
 
           n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
               `n=1` is supported.
 
-          quality: The quality of the image that will be generated. `hd` creates images with finer
-              details and greater consistency across the image. This param is only supported
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    async def generate(
+        self,
+        *,
+        prompt: str,
+        stream: Literal[True],
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncStream[ImageGenStreamEvent]:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
+
+        Args:
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
               for `dall-e-3`.
 
-          response_format: The format in which the generated images are returned. Must be one of `url` or
-              `b64_json`. URLs are only valid for 60 minutes after the image has been
-              generated.
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
 
-          size: The size of the generated images. Must be one of `256x256`, `512x512`, or
-              `1024x1024` for `dall-e-2`. Must be one of `1024x1024`, `1792x1024`, or
-              `1024x1792` for `dall-e-3` models.
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
+
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
 
-          style: The style of the generated images. Must be one of `vivid` or `natural`. Vivid
-              causes the model to lean towards generating hyper-real and dramatic images.
-              Natural causes the model to produce more natural, less hyper-real looking
-              images. This param is only supported for `dall-e-3`.
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
 
           user: A unique identifier representing your end-user, which can help OpenAI to monitor
               and detect abuse.
@@ -518,25 +1626,175 @@ async def generate(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @overload
+    async def generate(
+        self,
+        *,
+        prompt: str,
+        stream: bool,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | AsyncStream[ImageGenStreamEvent]:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
+
+        Args:
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
+
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
+
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+              Note that the final image may be sent before the full number of partial images
+              are generated if the full image is generated more quickly.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["prompt"], ["prompt", "stream"])
+    async def generate(
+        self,
+        *,
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | Omit = omit,
+        model: Union[str, ImageModel, None] | Omit = omit,
+        moderation: Optional[Literal["low", "auto"]] | Omit = omit,
+        n: Optional[int] | Omit = omit,
+        output_compression: Optional[int] | Omit = omit,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | Omit = omit,
+        partial_images: Optional[int] | Omit = omit,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | Omit = omit,
+        response_format: Optional[Literal["url", "b64_json"]] | Omit = omit,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        style: Optional[Literal["vivid", "natural"]] | Omit = omit,
+        user: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ImagesResponse | AsyncStream[ImageGenStreamEvent]:
         return await self._post(
             "/images/generations",
             body=await async_maybe_transform(
                 {
                     "prompt": prompt,
+                    "background": background,
                     "model": model,
+                    "moderation": moderation,
                     "n": n,
+                    "output_compression": output_compression,
+                    "output_format": output_format,
+                    "partial_images": partial_images,
                     "quality": quality,
                     "response_format": response_format,
                     "size": size,
+                    "stream": stream,
                     "style": style,
                     "user": user,
                 },
-                image_generate_params.ImageGenerateParams,
+                image_generate_params.ImageGenerateParamsStreaming
+                if stream
+                else image_generate_params.ImageGenerateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=AsyncStream[ImageGenStreamEvent],
         )
 
 
diff --git a/src/openai/resources/models.py b/src/openai/resources/models.py
index a9693a6b0a..a8f7691055 100644
--- a/src/openai/resources/models.py
+++ b/src/openai/resources/models.py
@@ -5,7 +5,7 @@
 import httpx
 
 from .. import _legacy_response
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._types import Body, Query, Headers, NotGiven, not_given
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -49,7 +49,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Model:
         """
         Retrieves a model instance, providing basic information about the model such as
@@ -82,7 +82,7 @@ def list(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncPage[Model]:
         """
         Lists the currently available models, and provides basic information about each
@@ -106,7 +106,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ModelDeleted:
         """Delete a fine-tuned model.
 
@@ -162,7 +162,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Model:
         """
         Retrieves a model instance, providing basic information about the model such as
@@ -195,7 +195,7 @@ def list(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[Model, AsyncPage[Model]]:
         """
         Lists the currently available models, and provides basic information about each
@@ -219,7 +219,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ModelDeleted:
         """Delete a fine-tuned model.
 
diff --git a/src/openai/resources/moderations.py b/src/openai/resources/moderations.py
index a8f03142bc..5f378f71e7 100644
--- a/src/openai/resources/moderations.py
+++ b/src/openai/resources/moderations.py
@@ -2,17 +2,14 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable
+from typing import Union, Iterable
 
 import httpx
 
 from .. import _legacy_response
 from ..types import moderation_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -47,14 +44,14 @@ def with_streaming_response(self) -> ModerationsWithStreamingResponse:
     def create(
         self,
         *,
-        input: Union[str, List[str], Iterable[ModerationMultiModalInputParam]],
-        model: Union[str, ModerationModel] | NotGiven = NOT_GIVEN,
+        input: Union[str, SequenceNotStr[str], Iterable[ModerationMultiModalInputParam]],
+        model: Union[str, ModerationModel] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ModerationCreateResponse:
         """Classifies if text and/or image inputs are potentially harmful.
 
@@ -117,14 +114,14 @@ def with_streaming_response(self) -> AsyncModerationsWithStreamingResponse:
     async def create(
         self,
         *,
-        input: Union[str, List[str], Iterable[ModerationMultiModalInputParam]],
-        model: Union[str, ModerationModel] | NotGiven = NOT_GIVEN,
+        input: Union[str, SequenceNotStr[str], Iterable[ModerationMultiModalInputParam]],
+        model: Union[str, ModerationModel] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> ModerationCreateResponse:
         """Classifies if text and/or image inputs are potentially harmful.
 
diff --git a/src/openai/resources/realtime/__init__.py b/src/openai/resources/realtime/__init__.py
new file mode 100644
index 0000000000..c11841017f
--- /dev/null
+++ b/src/openai/resources/realtime/__init__.py
@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .calls import (
+    Calls,
+    AsyncCalls,
+    CallsWithRawResponse,
+    AsyncCallsWithRawResponse,
+    CallsWithStreamingResponse,
+    AsyncCallsWithStreamingResponse,
+)
+from .realtime import (
+    Realtime,
+    AsyncRealtime,
+    RealtimeWithRawResponse,
+    AsyncRealtimeWithRawResponse,
+    RealtimeWithStreamingResponse,
+    AsyncRealtimeWithStreamingResponse,
+)
+from .client_secrets import (
+    ClientSecrets,
+    AsyncClientSecrets,
+    ClientSecretsWithRawResponse,
+    AsyncClientSecretsWithRawResponse,
+    ClientSecretsWithStreamingResponse,
+    AsyncClientSecretsWithStreamingResponse,
+)
+
+__all__ = [
+    "ClientSecrets",
+    "AsyncClientSecrets",
+    "ClientSecretsWithRawResponse",
+    "AsyncClientSecretsWithRawResponse",
+    "ClientSecretsWithStreamingResponse",
+    "AsyncClientSecretsWithStreamingResponse",
+    "Calls",
+    "AsyncCalls",
+    "CallsWithRawResponse",
+    "AsyncCallsWithRawResponse",
+    "CallsWithStreamingResponse",
+    "AsyncCallsWithStreamingResponse",
+    "Realtime",
+    "AsyncRealtime",
+    "RealtimeWithRawResponse",
+    "AsyncRealtimeWithRawResponse",
+    "RealtimeWithStreamingResponse",
+    "AsyncRealtimeWithStreamingResponse",
+]
diff --git a/src/openai/resources/realtime/calls.py b/src/openai/resources/realtime/calls.py
new file mode 100644
index 0000000000..7d2c92fe86
--- /dev/null
+++ b/src/openai/resources/realtime/calls.py
@@ -0,0 +1,764 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+    to_streamed_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_custom_streamed_response_wrapper,
+    async_to_custom_streamed_response_wrapper,
+)
+from ..._base_client import make_request_options
+from ...types.realtime import (
+    call_refer_params,
+    call_accept_params,
+    call_create_params,
+    call_reject_params,
+)
+from ...types.responses.response_prompt_param import ResponsePromptParam
+from ...types.realtime.realtime_truncation_param import RealtimeTruncationParam
+from ...types.realtime.realtime_audio_config_param import RealtimeAudioConfigParam
+from ...types.realtime.realtime_tools_config_param import RealtimeToolsConfigParam
+from ...types.realtime.realtime_tracing_config_param import RealtimeTracingConfigParam
+from ...types.realtime.realtime_tool_choice_config_param import RealtimeToolChoiceConfigParam
+from ...types.realtime.realtime_session_create_request_param import RealtimeSessionCreateRequestParam
+
+__all__ = ["Calls", "AsyncCalls"]
+
+
+class Calls(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CallsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return CallsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CallsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return CallsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        sdp: str,
+        session: RealtimeSessionCreateRequestParam | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        """
+        Create a new Realtime API call over WebRTC and receive the SDP answer needed to
+        complete the peer connection.
+
+        Args:
+          sdp: WebRTC Session Description Protocol (SDP) offer generated by the caller.
+
+          session: Realtime session object configuration.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"Accept": "application/sdp", **(extra_headers or {})}
+        return self._post(
+            "/realtime/calls",
+            body=maybe_transform(
+                {
+                    "sdp": sdp,
+                    "session": session,
+                },
+                call_create_params.CallCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
+
+    def accept(
+        self,
+        call_id: str,
+        *,
+        type: Literal["realtime"],
+        audio: RealtimeAudioConfigParam | Omit = omit,
+        include: List[Literal["item.input_audio_transcription.logprobs"]] | Omit = omit,
+        instructions: str | Omit = omit,
+        max_output_tokens: Union[int, Literal["inf"]] | Omit = omit,
+        model: Union[
+            str,
+            Literal[
+                "gpt-realtime",
+                "gpt-realtime-2025-08-28",
+                "gpt-4o-realtime-preview",
+                "gpt-4o-realtime-preview-2024-10-01",
+                "gpt-4o-realtime-preview-2024-12-17",
+                "gpt-4o-realtime-preview-2025-06-03",
+                "gpt-4o-mini-realtime-preview",
+                "gpt-4o-mini-realtime-preview-2024-12-17",
+                "gpt-realtime-mini",
+                "gpt-realtime-mini-2025-10-06",
+                "gpt-audio-mini",
+                "gpt-audio-mini-2025-10-06",
+            ],
+        ]
+        | Omit = omit,
+        output_modalities: List[Literal["text", "audio"]] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        tool_choice: RealtimeToolChoiceConfigParam | Omit = omit,
+        tools: RealtimeToolsConfigParam | Omit = omit,
+        tracing: Optional[RealtimeTracingConfigParam] | Omit = omit,
+        truncation: RealtimeTruncationParam | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Accept an incoming SIP call and configure the realtime session that will handle
+        it.
+
+        Args:
+          type: The type of session to create. Always `realtime` for the Realtime API.
+
+          audio: Configuration for input and output audio.
+
+          include: Additional fields to include in server outputs.
+
+              `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+              transcription.
+
+          instructions: The default system instructions (i.e. system message) prepended to model calls.
+              This field allows the client to guide the model on desired responses. The model
+              can be instructed on response content and format, (e.g. "be extremely succinct",
+              "act friendly", "here are examples of good responses") and on audio behavior
+              (e.g. "talk quickly", "inject emotion into your voice", "laugh frequently"). The
+              instructions are not guaranteed to be followed by the model, but they provide
+              guidance to the model on the desired behavior.
+
+              Note that the server sets default instructions which will be used if this field
+              is not set and are visible in the `session.created` event at the start of the
+              session.
+
+          max_output_tokens: Maximum number of output tokens for a single assistant response, inclusive of
+              tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+              `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+
+          model: The Realtime model used for this session.
+
+          output_modalities: The set of modalities the model can respond with. It defaults to `["audio"]`,
+              indicating that the model will respond with audio plus a transcript. `["text"]`
+              can be used to make the model respond with text only. It is not possible to
+              request both `text` and `audio` at the same time.
+
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          tool_choice: How the model chooses tools. Provide one of the string modes or force a specific
+              function/MCP tool.
+
+          tools: Tools available to the model.
+
+          tracing: Realtime API can write session traces to the
+              [Traces Dashboard](/logs?api=traces). Set to null to disable tracing. Once
+              tracing is enabled for a session, the configuration cannot be modified.
+
+              `auto` will create a trace for the session with default values for the workflow
+              name, group id, and metadata.
+
+          truncation: When the number of tokens in a conversation exceeds the model's input token
+              limit, the conversation be truncated, meaning messages (starting from the
+              oldest) will not be included in the model's context. A 32k context model with
+              4,096 max output tokens can only include 28,224 tokens in the context before
+              truncation occurs. Clients can configure truncation behavior to truncate with a
+              lower max token limit, which is an effective way to control token usage and
+              cost. Truncation will reduce the number of cached tokens on the next turn
+              (busting the cache), since messages are dropped from the beginning of the
+              context. However, clients can also configure truncation to retain messages up to
+              a fraction of the maximum context size, which will reduce the need for future
+              truncations and thus improve the cache rate. Truncation can be disabled
+              entirely, which means the server will never truncate but would instead return an
+              error if the conversation exceeds the model's input token limit.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._post(
+            f"/realtime/calls/{call_id}/accept",
+            body=maybe_transform(
+                {
+                    "type": type,
+                    "audio": audio,
+                    "include": include,
+                    "instructions": instructions,
+                    "max_output_tokens": max_output_tokens,
+                    "model": model,
+                    "output_modalities": output_modalities,
+                    "prompt": prompt,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "tracing": tracing,
+                    "truncation": truncation,
+                },
+                call_accept_params.CallAcceptParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def hangup(
+        self,
+        call_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        End an active Realtime API call, whether it was initiated over SIP or WebRTC.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._post(
+            f"/realtime/calls/{call_id}/hangup",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def refer(
+        self,
+        call_id: str,
+        *,
+        target_uri: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Transfer an active SIP call to a new destination using the SIP REFER verb.
+
+        Args:
+          target_uri: URI that should appear in the SIP Refer-To header. Supports values like
+              `tel:+14155550123` or `sip:agent@example.com`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._post(
+            f"/realtime/calls/{call_id}/refer",
+            body=maybe_transform({"target_uri": target_uri}, call_refer_params.CallReferParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def reject(
+        self,
+        call_id: str,
+        *,
+        status_code: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Decline an incoming SIP call by returning a SIP status code to the caller.
+
+        Args:
+          status_code: SIP response code to send back to the caller. Defaults to `603` (Decline) when
+              omitted.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._post(
+            f"/realtime/calls/{call_id}/reject",
+            body=maybe_transform({"status_code": status_code}, call_reject_params.CallRejectParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncCalls(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCallsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCallsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCallsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncCallsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        sdp: str,
+        session: RealtimeSessionCreateRequestParam | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        """
+        Create a new Realtime API call over WebRTC and receive the SDP answer needed to
+        complete the peer connection.
+
+        Args:
+          sdp: WebRTC Session Description Protocol (SDP) offer generated by the caller.
+
+          session: Realtime session object configuration.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        extra_headers = {"Accept": "application/sdp", **(extra_headers or {})}
+        return await self._post(
+            "/realtime/calls",
+            body=await async_maybe_transform(
+                {
+                    "sdp": sdp,
+                    "session": session,
+                },
+                call_create_params.CallCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
+
+    async def accept(
+        self,
+        call_id: str,
+        *,
+        type: Literal["realtime"],
+        audio: RealtimeAudioConfigParam | Omit = omit,
+        include: List[Literal["item.input_audio_transcription.logprobs"]] | Omit = omit,
+        instructions: str | Omit = omit,
+        max_output_tokens: Union[int, Literal["inf"]] | Omit = omit,
+        model: Union[
+            str,
+            Literal[
+                "gpt-realtime",
+                "gpt-realtime-2025-08-28",
+                "gpt-4o-realtime-preview",
+                "gpt-4o-realtime-preview-2024-10-01",
+                "gpt-4o-realtime-preview-2024-12-17",
+                "gpt-4o-realtime-preview-2025-06-03",
+                "gpt-4o-mini-realtime-preview",
+                "gpt-4o-mini-realtime-preview-2024-12-17",
+                "gpt-realtime-mini",
+                "gpt-realtime-mini-2025-10-06",
+                "gpt-audio-mini",
+                "gpt-audio-mini-2025-10-06",
+            ],
+        ]
+        | Omit = omit,
+        output_modalities: List[Literal["text", "audio"]] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        tool_choice: RealtimeToolChoiceConfigParam | Omit = omit,
+        tools: RealtimeToolsConfigParam | Omit = omit,
+        tracing: Optional[RealtimeTracingConfigParam] | Omit = omit,
+        truncation: RealtimeTruncationParam | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Accept an incoming SIP call and configure the realtime session that will handle
+        it.
+
+        Args:
+          type: The type of session to create. Always `realtime` for the Realtime API.
+
+          audio: Configuration for input and output audio.
+
+          include: Additional fields to include in server outputs.
+
+              `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+              transcription.
+
+          instructions: The default system instructions (i.e. system message) prepended to model calls.
+              This field allows the client to guide the model on desired responses. The model
+              can be instructed on response content and format, (e.g. "be extremely succinct",
+              "act friendly", "here are examples of good responses") and on audio behavior
+              (e.g. "talk quickly", "inject emotion into your voice", "laugh frequently"). The
+              instructions are not guaranteed to be followed by the model, but they provide
+              guidance to the model on the desired behavior.
+
+              Note that the server sets default instructions which will be used if this field
+              is not set and are visible in the `session.created` event at the start of the
+              session.
+
+          max_output_tokens: Maximum number of output tokens for a single assistant response, inclusive of
+              tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+              `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+
+          model: The Realtime model used for this session.
+
+          output_modalities: The set of modalities the model can respond with. It defaults to `["audio"]`,
+              indicating that the model will respond with audio plus a transcript. `["text"]`
+              can be used to make the model respond with text only. It is not possible to
+              request both `text` and `audio` at the same time.
+
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          tool_choice: How the model chooses tools. Provide one of the string modes or force a specific
+              function/MCP tool.
+
+          tools: Tools available to the model.
+
+          tracing: Realtime API can write session traces to the
+              [Traces Dashboard](/logs?api=traces). Set to null to disable tracing. Once
+              tracing is enabled for a session, the configuration cannot be modified.
+
+              `auto` will create a trace for the session with default values for the workflow
+              name, group id, and metadata.
+
+          truncation: When the number of tokens in a conversation exceeds the model's input token
+              limit, the conversation be truncated, meaning messages (starting from the
+              oldest) will not be included in the model's context. A 32k context model with
+              4,096 max output tokens can only include 28,224 tokens in the context before
+              truncation occurs. Clients can configure truncation behavior to truncate with a
+              lower max token limit, which is an effective way to control token usage and
+              cost. Truncation will reduce the number of cached tokens on the next turn
+              (busting the cache), since messages are dropped from the beginning of the
+              context. However, clients can also configure truncation to retain messages up to
+              a fraction of the maximum context size, which will reduce the need for future
+              truncations and thus improve the cache rate. Truncation can be disabled
+              entirely, which means the server will never truncate but would instead return an
+              error if the conversation exceeds the model's input token limit.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._post(
+            f"/realtime/calls/{call_id}/accept",
+            body=await async_maybe_transform(
+                {
+                    "type": type,
+                    "audio": audio,
+                    "include": include,
+                    "instructions": instructions,
+                    "max_output_tokens": max_output_tokens,
+                    "model": model,
+                    "output_modalities": output_modalities,
+                    "prompt": prompt,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "tracing": tracing,
+                    "truncation": truncation,
+                },
+                call_accept_params.CallAcceptParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def hangup(
+        self,
+        call_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        End an active Realtime API call, whether it was initiated over SIP or WebRTC.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._post(
+            f"/realtime/calls/{call_id}/hangup",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def refer(
+        self,
+        call_id: str,
+        *,
+        target_uri: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Transfer an active SIP call to a new destination using the SIP REFER verb.
+
+        Args:
+          target_uri: URI that should appear in the SIP Refer-To header. Supports values like
+              `tel:+14155550123` or `sip:agent@example.com`.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._post(
+            f"/realtime/calls/{call_id}/refer",
+            body=await async_maybe_transform({"target_uri": target_uri}, call_refer_params.CallReferParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def reject(
+        self,
+        call_id: str,
+        *,
+        status_code: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """
+        Decline an incoming SIP call by returning a SIP status code to the caller.
+
+        Args:
+          status_code: SIP response code to send back to the caller. Defaults to `603` (Decline) when
+              omitted.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not call_id:
+            raise ValueError(f"Expected a non-empty value for `call_id` but received {call_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._post(
+            f"/realtime/calls/{call_id}/reject",
+            body=await async_maybe_transform({"status_code": status_code}, call_reject_params.CallRejectParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class CallsWithRawResponse:
+    def __init__(self, calls: Calls) -> None:
+        self._calls = calls
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            calls.create,
+        )
+        self.accept = _legacy_response.to_raw_response_wrapper(
+            calls.accept,
+        )
+        self.hangup = _legacy_response.to_raw_response_wrapper(
+            calls.hangup,
+        )
+        self.refer = _legacy_response.to_raw_response_wrapper(
+            calls.refer,
+        )
+        self.reject = _legacy_response.to_raw_response_wrapper(
+            calls.reject,
+        )
+
+
+class AsyncCallsWithRawResponse:
+    def __init__(self, calls: AsyncCalls) -> None:
+        self._calls = calls
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            calls.create,
+        )
+        self.accept = _legacy_response.async_to_raw_response_wrapper(
+            calls.accept,
+        )
+        self.hangup = _legacy_response.async_to_raw_response_wrapper(
+            calls.hangup,
+        )
+        self.refer = _legacy_response.async_to_raw_response_wrapper(
+            calls.refer,
+        )
+        self.reject = _legacy_response.async_to_raw_response_wrapper(
+            calls.reject,
+        )
+
+
+class CallsWithStreamingResponse:
+    def __init__(self, calls: Calls) -> None:
+        self._calls = calls
+
+        self.create = to_custom_streamed_response_wrapper(
+            calls.create,
+            StreamedBinaryAPIResponse,
+        )
+        self.accept = to_streamed_response_wrapper(
+            calls.accept,
+        )
+        self.hangup = to_streamed_response_wrapper(
+            calls.hangup,
+        )
+        self.refer = to_streamed_response_wrapper(
+            calls.refer,
+        )
+        self.reject = to_streamed_response_wrapper(
+            calls.reject,
+        )
+
+
+class AsyncCallsWithStreamingResponse:
+    def __init__(self, calls: AsyncCalls) -> None:
+        self._calls = calls
+
+        self.create = async_to_custom_streamed_response_wrapper(
+            calls.create,
+            AsyncStreamedBinaryAPIResponse,
+        )
+        self.accept = async_to_streamed_response_wrapper(
+            calls.accept,
+        )
+        self.hangup = async_to_streamed_response_wrapper(
+            calls.hangup,
+        )
+        self.refer = async_to_streamed_response_wrapper(
+            calls.refer,
+        )
+        self.reject = async_to_streamed_response_wrapper(
+            calls.reject,
+        )
diff --git a/src/openai/resources/realtime/client_secrets.py b/src/openai/resources/realtime/client_secrets.py
new file mode 100644
index 0000000000..5ceba7bef1
--- /dev/null
+++ b/src/openai/resources/realtime/client_secrets.py
@@ -0,0 +1,189 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ..._base_client import make_request_options
+from ...types.realtime import client_secret_create_params
+from ...types.realtime.client_secret_create_response import ClientSecretCreateResponse
+
+__all__ = ["ClientSecrets", "AsyncClientSecrets"]
+
+
+class ClientSecrets(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ClientSecretsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return ClientSecretsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ClientSecretsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return ClientSecretsWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        expires_after: client_secret_create_params.ExpiresAfter | Omit = omit,
+        session: client_secret_create_params.Session | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ClientSecretCreateResponse:
+        """
+        Create a Realtime client secret with an associated session configuration.
+
+        Args:
+          expires_after: Configuration for the client secret expiration. Expiration refers to the time
+              after which a client secret will no longer be valid for creating sessions. The
+              session itself may continue after that time once started. A secret can be used
+              to create multiple sessions until it expires.
+
+          session: Session configuration to use for the client secret. Choose either a realtime
+              session or a transcription session.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/realtime/client_secrets",
+            body=maybe_transform(
+                {
+                    "expires_after": expires_after,
+                    "session": session,
+                },
+                client_secret_create_params.ClientSecretCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ClientSecretCreateResponse,
+        )
+
+
+class AsyncClientSecrets(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncClientSecretsWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncClientSecretsWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncClientSecretsWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncClientSecretsWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        expires_after: client_secret_create_params.ExpiresAfter | Omit = omit,
+        session: client_secret_create_params.Session | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ClientSecretCreateResponse:
+        """
+        Create a Realtime client secret with an associated session configuration.
+
+        Args:
+          expires_after: Configuration for the client secret expiration. Expiration refers to the time
+              after which a client secret will no longer be valid for creating sessions. The
+              session itself may continue after that time once started. A secret can be used
+              to create multiple sessions until it expires.
+
+          session: Session configuration to use for the client secret. Choose either a realtime
+              session or a transcription session.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/realtime/client_secrets",
+            body=await async_maybe_transform(
+                {
+                    "expires_after": expires_after,
+                    "session": session,
+                },
+                client_secret_create_params.ClientSecretCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ClientSecretCreateResponse,
+        )
+
+
+class ClientSecretsWithRawResponse:
+    def __init__(self, client_secrets: ClientSecrets) -> None:
+        self._client_secrets = client_secrets
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            client_secrets.create,
+        )
+
+
+class AsyncClientSecretsWithRawResponse:
+    def __init__(self, client_secrets: AsyncClientSecrets) -> None:
+        self._client_secrets = client_secrets
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            client_secrets.create,
+        )
+
+
+class ClientSecretsWithStreamingResponse:
+    def __init__(self, client_secrets: ClientSecrets) -> None:
+        self._client_secrets = client_secrets
+
+        self.create = to_streamed_response_wrapper(
+            client_secrets.create,
+        )
+
+
+class AsyncClientSecretsWithStreamingResponse:
+    def __init__(self, client_secrets: AsyncClientSecrets) -> None:
+        self._client_secrets = client_secrets
+
+        self.create = async_to_streamed_response_wrapper(
+            client_secrets.create,
+        )
diff --git a/src/openai/resources/realtime/realtime.py b/src/openai/resources/realtime/realtime.py
new file mode 100644
index 0000000000..6e69258616
--- /dev/null
+++ b/src/openai/resources/realtime/realtime.py
@@ -0,0 +1,1079 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import json
+import logging
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Iterator, cast
+from typing_extensions import AsyncIterator
+
+import httpx
+from pydantic import BaseModel
+
+from .calls import (
+    Calls,
+    AsyncCalls,
+    CallsWithRawResponse,
+    AsyncCallsWithRawResponse,
+    CallsWithStreamingResponse,
+    AsyncCallsWithStreamingResponse,
+)
+from ..._types import Omit, Query, Headers, omit
+from ..._utils import (
+    is_azure_client,
+    maybe_transform,
+    strip_not_given,
+    async_maybe_transform,
+    is_async_azure_client,
+)
+from ..._compat import cached_property
+from ..._models import construct_type_unchecked
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._exceptions import OpenAIError
+from ..._base_client import _merge_mappings
+from .client_secrets import (
+    ClientSecrets,
+    AsyncClientSecrets,
+    ClientSecretsWithRawResponse,
+    AsyncClientSecretsWithRawResponse,
+    ClientSecretsWithStreamingResponse,
+    AsyncClientSecretsWithStreamingResponse,
+)
+from ...types.realtime import session_update_event_param
+from ...types.websocket_connection_options import WebsocketConnectionOptions
+from ...types.realtime.realtime_client_event import RealtimeClientEvent
+from ...types.realtime.realtime_server_event import RealtimeServerEvent
+from ...types.realtime.conversation_item_param import ConversationItemParam
+from ...types.realtime.realtime_client_event_param import RealtimeClientEventParam
+from ...types.realtime.realtime_response_create_params_param import RealtimeResponseCreateParamsParam
+
+if TYPE_CHECKING:
+    from websockets.sync.client import ClientConnection as WebsocketConnection
+    from websockets.asyncio.client import ClientConnection as AsyncWebsocketConnection
+
+    from ..._client import OpenAI, AsyncOpenAI
+
+__all__ = ["Realtime", "AsyncRealtime"]
+
+log: logging.Logger = logging.getLogger(__name__)
+
+
+class Realtime(SyncAPIResource):
+    @cached_property
+    def client_secrets(self) -> ClientSecrets:
+        return ClientSecrets(self._client)
+
+    @cached_property
+    def calls(self) -> Calls:
+        from ...lib._realtime import _Calls
+
+        return _Calls(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> RealtimeWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return RealtimeWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RealtimeWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return RealtimeWithStreamingResponse(self)
+
+    def connect(
+        self,
+        *,
+        call_id: str | Omit = omit,
+        model: str | Omit = omit,
+        extra_query: Query = {},
+        extra_headers: Headers = {},
+        websocket_connection_options: WebsocketConnectionOptions = {},
+    ) -> RealtimeConnectionManager:
+        """
+        The Realtime API enables you to build low-latency, multi-modal conversational experiences. It currently supports text and audio as both input and output, as well as function calling.
+
+        Some notable benefits of the API include:
+
+        - Native speech-to-speech: Skipping an intermediate text format means low latency and nuanced output.
+        - Natural, steerable voices: The models have natural inflection and can laugh, whisper, and adhere to tone direction.
+        - Simultaneous multimodal output: Text is useful for moderation; faster-than-realtime audio ensures stable playback.
+
+        The Realtime API is a stateful, event-based API that communicates over a WebSocket.
+        """
+        return RealtimeConnectionManager(
+            client=self._client,
+            extra_query=extra_query,
+            extra_headers=extra_headers,
+            websocket_connection_options=websocket_connection_options,
+            call_id=call_id,
+            model=model,
+        )
+
+
+class AsyncRealtime(AsyncAPIResource):
+    @cached_property
+    def client_secrets(self) -> AsyncClientSecrets:
+        return AsyncClientSecrets(self._client)
+
+    @cached_property
+    def calls(self) -> AsyncCalls:
+        from ...lib._realtime import _AsyncCalls
+
+        return _AsyncCalls(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncRealtimeWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncRealtimeWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRealtimeWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncRealtimeWithStreamingResponse(self)
+
+    def connect(
+        self,
+        *,
+        call_id: str | Omit = omit,
+        model: str | Omit = omit,
+        extra_query: Query = {},
+        extra_headers: Headers = {},
+        websocket_connection_options: WebsocketConnectionOptions = {},
+    ) -> AsyncRealtimeConnectionManager:
+        """
+        The Realtime API enables you to build low-latency, multi-modal conversational experiences. It currently supports text and audio as both input and output, as well as function calling.
+
+        Some notable benefits of the API include:
+
+        - Native speech-to-speech: Skipping an intermediate text format means low latency and nuanced output.
+        - Natural, steerable voices: The models have natural inflection and can laugh, whisper, and adhere to tone direction.
+        - Simultaneous multimodal output: Text is useful for moderation; faster-than-realtime audio ensures stable playback.
+
+        The Realtime API is a stateful, event-based API that communicates over a WebSocket.
+        """
+        return AsyncRealtimeConnectionManager(
+            client=self._client,
+            extra_query=extra_query,
+            extra_headers=extra_headers,
+            websocket_connection_options=websocket_connection_options,
+            call_id=call_id,
+            model=model,
+        )
+
+
+class RealtimeWithRawResponse:
+    def __init__(self, realtime: Realtime) -> None:
+        self._realtime = realtime
+
+    @cached_property
+    def client_secrets(self) -> ClientSecretsWithRawResponse:
+        return ClientSecretsWithRawResponse(self._realtime.client_secrets)
+
+    @cached_property
+    def calls(self) -> CallsWithRawResponse:
+        return CallsWithRawResponse(self._realtime.calls)
+
+
+class AsyncRealtimeWithRawResponse:
+    def __init__(self, realtime: AsyncRealtime) -> None:
+        self._realtime = realtime
+
+    @cached_property
+    def client_secrets(self) -> AsyncClientSecretsWithRawResponse:
+        return AsyncClientSecretsWithRawResponse(self._realtime.client_secrets)
+
+    @cached_property
+    def calls(self) -> AsyncCallsWithRawResponse:
+        return AsyncCallsWithRawResponse(self._realtime.calls)
+
+
+class RealtimeWithStreamingResponse:
+    def __init__(self, realtime: Realtime) -> None:
+        self._realtime = realtime
+
+    @cached_property
+    def client_secrets(self) -> ClientSecretsWithStreamingResponse:
+        return ClientSecretsWithStreamingResponse(self._realtime.client_secrets)
+
+    @cached_property
+    def calls(self) -> CallsWithStreamingResponse:
+        return CallsWithStreamingResponse(self._realtime.calls)
+
+
+class AsyncRealtimeWithStreamingResponse:
+    def __init__(self, realtime: AsyncRealtime) -> None:
+        self._realtime = realtime
+
+    @cached_property
+    def client_secrets(self) -> AsyncClientSecretsWithStreamingResponse:
+        return AsyncClientSecretsWithStreamingResponse(self._realtime.client_secrets)
+
+    @cached_property
+    def calls(self) -> AsyncCallsWithStreamingResponse:
+        return AsyncCallsWithStreamingResponse(self._realtime.calls)
+
+
+class AsyncRealtimeConnection:
+    """Represents a live websocket connection to the Realtime API"""
+
+    session: AsyncRealtimeSessionResource
+    response: AsyncRealtimeResponseResource
+    input_audio_buffer: AsyncRealtimeInputAudioBufferResource
+    conversation: AsyncRealtimeConversationResource
+    output_audio_buffer: AsyncRealtimeOutputAudioBufferResource
+
+    _connection: AsyncWebsocketConnection
+
+    def __init__(self, connection: AsyncWebsocketConnection) -> None:
+        self._connection = connection
+
+        self.session = AsyncRealtimeSessionResource(self)
+        self.response = AsyncRealtimeResponseResource(self)
+        self.input_audio_buffer = AsyncRealtimeInputAudioBufferResource(self)
+        self.conversation = AsyncRealtimeConversationResource(self)
+        self.output_audio_buffer = AsyncRealtimeOutputAudioBufferResource(self)
+
+    async def __aiter__(self) -> AsyncIterator[RealtimeServerEvent]:
+        """
+        An infinite-iterator that will continue to yield events until
+        the connection is closed.
+        """
+        from websockets.exceptions import ConnectionClosedOK
+
+        try:
+            while True:
+                yield await self.recv()
+        except ConnectionClosedOK:
+            return
+
+    async def recv(self) -> RealtimeServerEvent:
+        """
+        Receive the next message from the connection and parses it into a `RealtimeServerEvent` object.
+
+        Canceling this method is safe. There's no risk of losing data.
+        """
+        return self.parse_event(await self.recv_bytes())
+
+    async def recv_bytes(self) -> bytes:
+        """Receive the next message from the connection as raw bytes.
+
+        Canceling this method is safe. There's no risk of losing data.
+
+        If you want to parse the message into a `RealtimeServerEvent` object like `.recv()` does,
+        then you can call `.parse_event(data)`.
+        """
+        message = await self._connection.recv(decode=False)
+        log.debug(f"Received websocket message: %s", message)
+        return message
+
+    async def send(self, event: RealtimeClientEvent | RealtimeClientEventParam) -> None:
+        data = (
+            event.to_json(use_api_names=True, exclude_defaults=True, exclude_unset=True)
+            if isinstance(event, BaseModel)
+            else json.dumps(await async_maybe_transform(event, RealtimeClientEventParam))
+        )
+        await self._connection.send(data)
+
+    async def close(self, *, code: int = 1000, reason: str = "") -> None:
+        await self._connection.close(code=code, reason=reason)
+
+    def parse_event(self, data: str | bytes) -> RealtimeServerEvent:
+        """
+        Converts a raw `str` or `bytes` message into a `RealtimeServerEvent` object.
+
+        This is helpful if you're using `.recv_bytes()`.
+        """
+        return cast(
+            RealtimeServerEvent, construct_type_unchecked(value=json.loads(data), type_=cast(Any, RealtimeServerEvent))
+        )
+
+
+class AsyncRealtimeConnectionManager:
+    """
+    Context manager over a `AsyncRealtimeConnection` that is returned by `realtime.connect()`
+
+    This context manager ensures that the connection will be closed when it exits.
+
+    ---
+
+    Note that if your application doesn't work well with the context manager approach then you
+    can call the `.enter()` method directly to initiate a connection.
+
+    **Warning**: You must remember to close the connection with `.close()`.
+
+    ```py
+    connection = await client.realtime.connect(...).enter()
+    # ...
+    await connection.close()
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        client: AsyncOpenAI,
+        call_id: str | Omit = omit,
+        model: str | Omit = omit,
+        extra_query: Query,
+        extra_headers: Headers,
+        websocket_connection_options: WebsocketConnectionOptions,
+    ) -> None:
+        self.__client = client
+        self.__call_id = call_id
+        self.__model = model
+        self.__connection: AsyncRealtimeConnection | None = None
+        self.__extra_query = extra_query
+        self.__extra_headers = extra_headers
+        self.__websocket_connection_options = websocket_connection_options
+
+    async def __aenter__(self) -> AsyncRealtimeConnection:
+        """
+        👋 If your application doesn't work well with the context manager approach then you
+        can call this method directly to initiate a connection.
+
+        **Warning**: You must remember to close the connection with `.close()`.
+
+        ```py
+        connection = await client.realtime.connect(...).enter()
+        # ...
+        await connection.close()
+        ```
+        """
+        try:
+            from websockets.asyncio.client import connect
+        except ImportError as exc:
+            raise OpenAIError("You need to install `openai[realtime]` to use this method") from exc
+
+        extra_query = self.__extra_query
+        await self.__client._refresh_api_key()
+        auth_headers = self.__client.auth_headers
+        extra_query = self.__extra_query
+        if self.__call_id is not omit:
+            extra_query = {**extra_query, "call_id": self.__call_id}
+        if is_async_azure_client(self.__client):
+            model = self.__model
+            if not model:
+                raise OpenAIError("`model` is required for Azure Realtime API")
+            else:
+                url, auth_headers = await self.__client._configure_realtime(model, extra_query)
+        else:
+            url = self._prepare_url().copy_with(
+                params={
+                    **self.__client.base_url.params,
+                    **({"model": self.__model} if self.__model is not omit else {}),
+                    **extra_query,
+                },
+            )
+        log.debug("Connecting to %s", url)
+        if self.__websocket_connection_options:
+            log.debug("Connection options: %s", self.__websocket_connection_options)
+
+        self.__connection = AsyncRealtimeConnection(
+            await connect(
+                str(url),
+                user_agent_header=self.__client.user_agent,
+                additional_headers=_merge_mappings(
+                    {
+                        **auth_headers,
+                    },
+                    self.__extra_headers,
+                ),
+                **self.__websocket_connection_options,
+            )
+        )
+
+        return self.__connection
+
+    enter = __aenter__
+
+    def _prepare_url(self) -> httpx.URL:
+        if self.__client.websocket_base_url is not None:
+            base_url = httpx.URL(self.__client.websocket_base_url)
+        else:
+            base_url = self.__client._base_url.copy_with(scheme="wss")
+
+        merge_raw_path = base_url.raw_path.rstrip(b"/") + b"/realtime"
+        return base_url.copy_with(raw_path=merge_raw_path)
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, exc_tb: TracebackType | None
+    ) -> None:
+        if self.__connection is not None:
+            await self.__connection.close()
+
+
+class RealtimeConnection:
+    """Represents a live websocket connection to the Realtime API"""
+
+    session: RealtimeSessionResource
+    response: RealtimeResponseResource
+    input_audio_buffer: RealtimeInputAudioBufferResource
+    conversation: RealtimeConversationResource
+    output_audio_buffer: RealtimeOutputAudioBufferResource
+
+    _connection: WebsocketConnection
+
+    def __init__(self, connection: WebsocketConnection) -> None:
+        self._connection = connection
+
+        self.session = RealtimeSessionResource(self)
+        self.response = RealtimeResponseResource(self)
+        self.input_audio_buffer = RealtimeInputAudioBufferResource(self)
+        self.conversation = RealtimeConversationResource(self)
+        self.output_audio_buffer = RealtimeOutputAudioBufferResource(self)
+
+    def __iter__(self) -> Iterator[RealtimeServerEvent]:
+        """
+        An infinite-iterator that will continue to yield events until
+        the connection is closed.
+        """
+        from websockets.exceptions import ConnectionClosedOK
+
+        try:
+            while True:
+                yield self.recv()
+        except ConnectionClosedOK:
+            return
+
+    def recv(self) -> RealtimeServerEvent:
+        """
+        Receive the next message from the connection and parses it into a `RealtimeServerEvent` object.
+
+        Canceling this method is safe. There's no risk of losing data.
+        """
+        return self.parse_event(self.recv_bytes())
+
+    def recv_bytes(self) -> bytes:
+        """Receive the next message from the connection as raw bytes.
+
+        Canceling this method is safe. There's no risk of losing data.
+
+        If you want to parse the message into a `RealtimeServerEvent` object like `.recv()` does,
+        then you can call `.parse_event(data)`.
+        """
+        message = self._connection.recv(decode=False)
+        log.debug(f"Received websocket message: %s", message)
+        return message
+
+    def send(self, event: RealtimeClientEvent | RealtimeClientEventParam) -> None:
+        data = (
+            event.to_json(use_api_names=True, exclude_defaults=True, exclude_unset=True)
+            if isinstance(event, BaseModel)
+            else json.dumps(maybe_transform(event, RealtimeClientEventParam))
+        )
+        self._connection.send(data)
+
+    def close(self, *, code: int = 1000, reason: str = "") -> None:
+        self._connection.close(code=code, reason=reason)
+
+    def parse_event(self, data: str | bytes) -> RealtimeServerEvent:
+        """
+        Converts a raw `str` or `bytes` message into a `RealtimeServerEvent` object.
+
+        This is helpful if you're using `.recv_bytes()`.
+        """
+        return cast(
+            RealtimeServerEvent, construct_type_unchecked(value=json.loads(data), type_=cast(Any, RealtimeServerEvent))
+        )
+
+
+class RealtimeConnectionManager:
+    """
+    Context manager over a `RealtimeConnection` that is returned by `realtime.connect()`
+
+    This context manager ensures that the connection will be closed when it exits.
+
+    ---
+
+    Note that if your application doesn't work well with the context manager approach then you
+    can call the `.enter()` method directly to initiate a connection.
+
+    **Warning**: You must remember to close the connection with `.close()`.
+
+    ```py
+    connection = client.realtime.connect(...).enter()
+    # ...
+    connection.close()
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        client: OpenAI,
+        call_id: str | Omit = omit,
+        model: str | Omit = omit,
+        extra_query: Query,
+        extra_headers: Headers,
+        websocket_connection_options: WebsocketConnectionOptions,
+    ) -> None:
+        self.__client = client
+        self.__call_id = call_id
+        self.__model = model
+        self.__connection: RealtimeConnection | None = None
+        self.__extra_query = extra_query
+        self.__extra_headers = extra_headers
+        self.__websocket_connection_options = websocket_connection_options
+
+    def __enter__(self) -> RealtimeConnection:
+        """
+        👋 If your application doesn't work well with the context manager approach then you
+        can call this method directly to initiate a connection.
+
+        **Warning**: You must remember to close the connection with `.close()`.
+
+        ```py
+        connection = client.realtime.connect(...).enter()
+        # ...
+        connection.close()
+        ```
+        """
+        try:
+            from websockets.sync.client import connect
+        except ImportError as exc:
+            raise OpenAIError("You need to install `openai[realtime]` to use this method") from exc
+
+        extra_query = self.__extra_query
+        self.__client._refresh_api_key()
+        auth_headers = self.__client.auth_headers
+        extra_query = self.__extra_query
+        if self.__call_id is not omit:
+            extra_query = {**extra_query, "call_id": self.__call_id}
+        if is_azure_client(self.__client):
+            model = self.__model
+            if not model:
+                raise OpenAIError("`model` is required for Azure Realtime API")
+            else:
+                url, auth_headers = self.__client._configure_realtime(model, extra_query)
+        else:
+            url = self._prepare_url().copy_with(
+                params={
+                    **self.__client.base_url.params,
+                    **({"model": self.__model} if self.__model is not omit else {}),
+                    **extra_query,
+                },
+            )
+        log.debug("Connecting to %s", url)
+        if self.__websocket_connection_options:
+            log.debug("Connection options: %s", self.__websocket_connection_options)
+
+        self.__connection = RealtimeConnection(
+            connect(
+                str(url),
+                user_agent_header=self.__client.user_agent,
+                additional_headers=_merge_mappings(
+                    {
+                        **auth_headers,
+                    },
+                    self.__extra_headers,
+                ),
+                **self.__websocket_connection_options,
+            )
+        )
+
+        return self.__connection
+
+    enter = __enter__
+
+    def _prepare_url(self) -> httpx.URL:
+        if self.__client.websocket_base_url is not None:
+            base_url = httpx.URL(self.__client.websocket_base_url)
+        else:
+            base_url = self.__client._base_url.copy_with(scheme="wss")
+
+        merge_raw_path = base_url.raw_path.rstrip(b"/") + b"/realtime"
+        return base_url.copy_with(raw_path=merge_raw_path)
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, exc_tb: TracebackType | None
+    ) -> None:
+        if self.__connection is not None:
+            self.__connection.close()
+
+
+class BaseRealtimeConnectionResource:
+    def __init__(self, connection: RealtimeConnection) -> None:
+        self._connection = connection
+
+
+class RealtimeSessionResource(BaseRealtimeConnectionResource):
+    def update(self, *, session: session_update_event_param.Session, event_id: str | Omit = omit) -> None:
+        """
+        Send this event to update the session’s configuration.
+        The client may send this event at any time to update any field
+        except for `voice` and `model`. `voice` can be updated only if there have been no other audio outputs yet.
+
+        When the server receives a `session.update`, it will respond
+        with a `session.updated` event showing the full, effective configuration.
+        Only the fields that are present in the `session.update` are updated. To clear a field like
+        `instructions`, pass an empty string. To clear a field like `tools`, pass an empty array.
+        To clear a field like `turn_detection`, pass `null`.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "session.update", "session": session, "event_id": event_id}),
+            )
+        )
+
+
+class RealtimeResponseResource(BaseRealtimeConnectionResource):
+    def create(self, *, event_id: str | Omit = omit, response: RealtimeResponseCreateParamsParam | Omit = omit) -> None:
+        """
+        This event instructs the server to create a Response, which means triggering
+        model inference. When in Server VAD mode, the server will create Responses
+        automatically.
+
+        A Response will include at least one Item, and may have two, in which case
+        the second will be a function call. These Items will be appended to the
+        conversation history by default.
+
+        The server will respond with a `response.created` event, events for Items
+        and content created, and finally a `response.done` event to indicate the
+        Response is complete.
+
+        The `response.create` event includes inference configuration like
+        `instructions` and `tools`. If these are set, they will override the Session's
+        configuration for this Response only.
+
+        Responses can be created out-of-band of the default Conversation, meaning that they can
+        have arbitrary input, and it's possible to disable writing the output to the Conversation.
+        Only one Response can write to the default Conversation at a time, but otherwise multiple
+        Responses can be created in parallel. The `metadata` field is a good way to disambiguate
+        multiple simultaneous Responses.
+
+        Clients can set `conversation` to `none` to create a Response that does not write to the default
+        Conversation. Arbitrary input can be provided with the `input` field, which is an array accepting
+        raw Items and references to existing Items.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "response.create", "event_id": event_id, "response": response}),
+            )
+        )
+
+    def cancel(self, *, event_id: str | Omit = omit, response_id: str | Omit = omit) -> None:
+        """Send this event to cancel an in-progress response.
+
+        The server will respond
+        with a `response.done` event with a status of `response.status=cancelled`. If
+        there is no response to cancel, the server will respond with an error. It's safe
+        to call `response.cancel` even if no response is in progress, an error will be
+        returned the session will remain unaffected.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "response.cancel", "event_id": event_id, "response_id": response_id}),
+            )
+        )
+
+
+class RealtimeInputAudioBufferResource(BaseRealtimeConnectionResource):
+    def clear(self, *, event_id: str | Omit = omit) -> None:
+        """Send this event to clear the audio bytes in the buffer.
+
+        The server will
+        respond with an `input_audio_buffer.cleared` event.
+        """
+        self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.clear", "event_id": event_id}))
+        )
+
+    def commit(self, *, event_id: str | Omit = omit) -> None:
+        """
+        Send this event to commit the user input audio buffer, which will create a  new user message item in the conversation. This event will produce an error  if the input audio buffer is empty. When in Server VAD mode, the client does  not need to send this event, the server will commit the audio buffer  automatically.
+
+        Committing the input audio buffer will trigger input audio transcription  (if enabled in session configuration), but it will not create a response  from the model. The server will respond with an `input_audio_buffer.committed` event.
+        """
+        self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.commit", "event_id": event_id}))
+        )
+
+    def append(self, *, audio: str, event_id: str | Omit = omit) -> None:
+        """Send this event to append audio bytes to the input audio buffer.
+
+        The audio
+        buffer is temporary storage you can write to and later commit. A "commit" will create a new
+        user message item in the conversation history from the buffer content and clear the buffer.
+        Input audio transcription (if enabled) will be generated when the buffer is committed.
+
+        If VAD is enabled the audio buffer is used to detect speech and the server will decide
+        when to commit. When Server VAD is disabled, you must commit the audio buffer
+        manually. Input audio noise reduction operates on writes to the audio buffer.
+
+        The client may choose how much audio to place in each event up to a maximum
+        of 15 MiB, for example streaming smaller chunks from the client may allow the
+        VAD to be more responsive. Unlike most other client events, the server will
+        not send a confirmation response to this event.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "input_audio_buffer.append", "audio": audio, "event_id": event_id}),
+            )
+        )
+
+
+class RealtimeConversationResource(BaseRealtimeConnectionResource):
+    @cached_property
+    def item(self) -> RealtimeConversationItemResource:
+        return RealtimeConversationItemResource(self._connection)
+
+
+class RealtimeConversationItemResource(BaseRealtimeConnectionResource):
+    def delete(self, *, item_id: str, event_id: str | Omit = omit) -> None:
+        """Send this event when you want to remove any item from the conversation
+        history.
+
+        The server will respond with a `conversation.item.deleted` event,
+        unless the item does not exist in the conversation history, in which case the
+        server will respond with an error.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "conversation.item.delete", "item_id": item_id, "event_id": event_id}),
+            )
+        )
+
+    def create(
+        self, *, item: ConversationItemParam, event_id: str | Omit = omit, previous_item_id: str | Omit = omit
+    ) -> None:
+        """
+        Add a new Item to the Conversation's context, including messages, function
+        calls, and function call responses. This event can be used both to populate a
+        "history" of the conversation and to add new items mid-stream, but has the
+        current limitation that it cannot populate assistant audio messages.
+
+        If successful, the server will respond with a `conversation.item.created`
+        event, otherwise an `error` event will be sent.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given(
+                    {
+                        "type": "conversation.item.create",
+                        "item": item,
+                        "event_id": event_id,
+                        "previous_item_id": previous_item_id,
+                    }
+                ),
+            )
+        )
+
+    def truncate(self, *, audio_end_ms: int, content_index: int, item_id: str, event_id: str | Omit = omit) -> None:
+        """Send this event to truncate a previous assistant message’s audio.
+
+        The server
+        will produce audio faster than realtime, so this event is useful when the user
+        interrupts to truncate audio that has already been sent to the client but not
+        yet played. This will synchronize the server's understanding of the audio with
+        the client's playback.
+
+        Truncating audio will delete the server-side text transcript to ensure there
+        is not text in the context that hasn't been heard by the user.
+
+        If successful, the server will respond with a `conversation.item.truncated`
+        event.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given(
+                    {
+                        "type": "conversation.item.truncate",
+                        "audio_end_ms": audio_end_ms,
+                        "content_index": content_index,
+                        "item_id": item_id,
+                        "event_id": event_id,
+                    }
+                ),
+            )
+        )
+
+    def retrieve(self, *, item_id: str, event_id: str | Omit = omit) -> None:
+        """
+        Send this event when you want to retrieve the server's representation of a specific item in the conversation history. This is useful, for example, to inspect user audio after noise cancellation and VAD.
+        The server will respond with a `conversation.item.retrieved` event,
+        unless the item does not exist in the conversation history, in which case the
+        server will respond with an error.
+        """
+        self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "conversation.item.retrieve", "item_id": item_id, "event_id": event_id}),
+            )
+        )
+
+
+class RealtimeOutputAudioBufferResource(BaseRealtimeConnectionResource):
+    def clear(self, *, event_id: str | Omit = omit) -> None:
+        """**WebRTC Only:** Emit to cut off the current audio response.
+
+        This will trigger the server to
+        stop generating audio and emit a `output_audio_buffer.cleared` event. This
+        event should be preceded by a `response.cancel` client event to stop the
+        generation of the current response.
+        [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc).
+        """
+        self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "output_audio_buffer.clear", "event_id": event_id}))
+        )
+
+
+class BaseAsyncRealtimeConnectionResource:
+    def __init__(self, connection: AsyncRealtimeConnection) -> None:
+        self._connection = connection
+
+
+class AsyncRealtimeSessionResource(BaseAsyncRealtimeConnectionResource):
+    async def update(self, *, session: session_update_event_param.Session, event_id: str | Omit = omit) -> None:
+        """
+        Send this event to update the session’s configuration.
+        The client may send this event at any time to update any field
+        except for `voice` and `model`. `voice` can be updated only if there have been no other audio outputs yet.
+
+        When the server receives a `session.update`, it will respond
+        with a `session.updated` event showing the full, effective configuration.
+        Only the fields that are present in the `session.update` are updated. To clear a field like
+        `instructions`, pass an empty string. To clear a field like `tools`, pass an empty array.
+        To clear a field like `turn_detection`, pass `null`.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "session.update", "session": session, "event_id": event_id}),
+            )
+        )
+
+
+class AsyncRealtimeResponseResource(BaseAsyncRealtimeConnectionResource):
+    async def create(
+        self, *, event_id: str | Omit = omit, response: RealtimeResponseCreateParamsParam | Omit = omit
+    ) -> None:
+        """
+        This event instructs the server to create a Response, which means triggering
+        model inference. When in Server VAD mode, the server will create Responses
+        automatically.
+
+        A Response will include at least one Item, and may have two, in which case
+        the second will be a function call. These Items will be appended to the
+        conversation history by default.
+
+        The server will respond with a `response.created` event, events for Items
+        and content created, and finally a `response.done` event to indicate the
+        Response is complete.
+
+        The `response.create` event includes inference configuration like
+        `instructions` and `tools`. If these are set, they will override the Session's
+        configuration for this Response only.
+
+        Responses can be created out-of-band of the default Conversation, meaning that they can
+        have arbitrary input, and it's possible to disable writing the output to the Conversation.
+        Only one Response can write to the default Conversation at a time, but otherwise multiple
+        Responses can be created in parallel. The `metadata` field is a good way to disambiguate
+        multiple simultaneous Responses.
+
+        Clients can set `conversation` to `none` to create a Response that does not write to the default
+        Conversation. Arbitrary input can be provided with the `input` field, which is an array accepting
+        raw Items and references to existing Items.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "response.create", "event_id": event_id, "response": response}),
+            )
+        )
+
+    async def cancel(self, *, event_id: str | Omit = omit, response_id: str | Omit = omit) -> None:
+        """Send this event to cancel an in-progress response.
+
+        The server will respond
+        with a `response.done` event with a status of `response.status=cancelled`. If
+        there is no response to cancel, the server will respond with an error. It's safe
+        to call `response.cancel` even if no response is in progress, an error will be
+        returned the session will remain unaffected.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "response.cancel", "event_id": event_id, "response_id": response_id}),
+            )
+        )
+
+
+class AsyncRealtimeInputAudioBufferResource(BaseAsyncRealtimeConnectionResource):
+    async def clear(self, *, event_id: str | Omit = omit) -> None:
+        """Send this event to clear the audio bytes in the buffer.
+
+        The server will
+        respond with an `input_audio_buffer.cleared` event.
+        """
+        await self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.clear", "event_id": event_id}))
+        )
+
+    async def commit(self, *, event_id: str | Omit = omit) -> None:
+        """
+        Send this event to commit the user input audio buffer, which will create a  new user message item in the conversation. This event will produce an error  if the input audio buffer is empty. When in Server VAD mode, the client does  not need to send this event, the server will commit the audio buffer  automatically.
+
+        Committing the input audio buffer will trigger input audio transcription  (if enabled in session configuration), but it will not create a response  from the model. The server will respond with an `input_audio_buffer.committed` event.
+        """
+        await self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "input_audio_buffer.commit", "event_id": event_id}))
+        )
+
+    async def append(self, *, audio: str, event_id: str | Omit = omit) -> None:
+        """Send this event to append audio bytes to the input audio buffer.
+
+        The audio
+        buffer is temporary storage you can write to and later commit. A "commit" will create a new
+        user message item in the conversation history from the buffer content and clear the buffer.
+        Input audio transcription (if enabled) will be generated when the buffer is committed.
+
+        If VAD is enabled the audio buffer is used to detect speech and the server will decide
+        when to commit. When Server VAD is disabled, you must commit the audio buffer
+        manually. Input audio noise reduction operates on writes to the audio buffer.
+
+        The client may choose how much audio to place in each event up to a maximum
+        of 15 MiB, for example streaming smaller chunks from the client may allow the
+        VAD to be more responsive. Unlike most other client events, the server will
+        not send a confirmation response to this event.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "input_audio_buffer.append", "audio": audio, "event_id": event_id}),
+            )
+        )
+
+
+class AsyncRealtimeConversationResource(BaseAsyncRealtimeConnectionResource):
+    @cached_property
+    def item(self) -> AsyncRealtimeConversationItemResource:
+        return AsyncRealtimeConversationItemResource(self._connection)
+
+
+class AsyncRealtimeConversationItemResource(BaseAsyncRealtimeConnectionResource):
+    async def delete(self, *, item_id: str, event_id: str | Omit = omit) -> None:
+        """Send this event when you want to remove any item from the conversation
+        history.
+
+        The server will respond with a `conversation.item.deleted` event,
+        unless the item does not exist in the conversation history, in which case the
+        server will respond with an error.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "conversation.item.delete", "item_id": item_id, "event_id": event_id}),
+            )
+        )
+
+    async def create(
+        self, *, item: ConversationItemParam, event_id: str | Omit = omit, previous_item_id: str | Omit = omit
+    ) -> None:
+        """
+        Add a new Item to the Conversation's context, including messages, function
+        calls, and function call responses. This event can be used both to populate a
+        "history" of the conversation and to add new items mid-stream, but has the
+        current limitation that it cannot populate assistant audio messages.
+
+        If successful, the server will respond with a `conversation.item.created`
+        event, otherwise an `error` event will be sent.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given(
+                    {
+                        "type": "conversation.item.create",
+                        "item": item,
+                        "event_id": event_id,
+                        "previous_item_id": previous_item_id,
+                    }
+                ),
+            )
+        )
+
+    async def truncate(
+        self, *, audio_end_ms: int, content_index: int, item_id: str, event_id: str | Omit = omit
+    ) -> None:
+        """Send this event to truncate a previous assistant message’s audio.
+
+        The server
+        will produce audio faster than realtime, so this event is useful when the user
+        interrupts to truncate audio that has already been sent to the client but not
+        yet played. This will synchronize the server's understanding of the audio with
+        the client's playback.
+
+        Truncating audio will delete the server-side text transcript to ensure there
+        is not text in the context that hasn't been heard by the user.
+
+        If successful, the server will respond with a `conversation.item.truncated`
+        event.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given(
+                    {
+                        "type": "conversation.item.truncate",
+                        "audio_end_ms": audio_end_ms,
+                        "content_index": content_index,
+                        "item_id": item_id,
+                        "event_id": event_id,
+                    }
+                ),
+            )
+        )
+
+    async def retrieve(self, *, item_id: str, event_id: str | Omit = omit) -> None:
+        """
+        Send this event when you want to retrieve the server's representation of a specific item in the conversation history. This is useful, for example, to inspect user audio after noise cancellation and VAD.
+        The server will respond with a `conversation.item.retrieved` event,
+        unless the item does not exist in the conversation history, in which case the
+        server will respond with an error.
+        """
+        await self._connection.send(
+            cast(
+                RealtimeClientEventParam,
+                strip_not_given({"type": "conversation.item.retrieve", "item_id": item_id, "event_id": event_id}),
+            )
+        )
+
+
+class AsyncRealtimeOutputAudioBufferResource(BaseAsyncRealtimeConnectionResource):
+    async def clear(self, *, event_id: str | Omit = omit) -> None:
+        """**WebRTC Only:** Emit to cut off the current audio response.
+
+        This will trigger the server to
+        stop generating audio and emit a `output_audio_buffer.cleared` event. This
+        event should be preceded by a `response.cancel` client event to stop the
+        generation of the current response.
+        [Learn more](https://platform.openai.com/docs/guides/realtime-conversations#client-and-server-events-for-audio-in-webrtc).
+        """
+        await self._connection.send(
+            cast(RealtimeClientEventParam, strip_not_given({"type": "output_audio_buffer.clear", "event_id": event_id}))
+        )
diff --git a/src/openai/resources/responses/__init__.py b/src/openai/resources/responses/__init__.py
index ad19218b01..51d318ad8d 100644
--- a/src/openai/resources/responses/__init__.py
+++ b/src/openai/resources/responses/__init__.py
@@ -16,6 +16,14 @@
     InputItemsWithStreamingResponse,
     AsyncInputItemsWithStreamingResponse,
 )
+from .input_tokens import (
+    InputTokens,
+    AsyncInputTokens,
+    InputTokensWithRawResponse,
+    AsyncInputTokensWithRawResponse,
+    InputTokensWithStreamingResponse,
+    AsyncInputTokensWithStreamingResponse,
+)
 
 __all__ = [
     "InputItems",
@@ -24,6 +32,12 @@
     "AsyncInputItemsWithRawResponse",
     "InputItemsWithStreamingResponse",
     "AsyncInputItemsWithStreamingResponse",
+    "InputTokens",
+    "AsyncInputTokens",
+    "InputTokensWithRawResponse",
+    "AsyncInputTokensWithRawResponse",
+    "InputTokensWithStreamingResponse",
+    "AsyncInputTokensWithStreamingResponse",
     "Responses",
     "AsyncResponses",
     "ResponsesWithRawResponse",
diff --git a/src/openai/resources/responses/input_items.py b/src/openai/resources/responses/input_items.py
index 10e7d545dc..3311bfe10a 100644
--- a/src/openai/resources/responses/input_items.py
+++ b/src/openai/resources/responses/input_items.py
@@ -2,13 +2,13 @@
 
 from __future__ import annotations
 
-from typing import Any, cast
+from typing import Any, List, cast
 from typing_extensions import Literal
 
 import httpx
 
 from ... import _legacy_response
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from ..._utils import maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
@@ -16,7 +16,8 @@
 from ...pagination import SyncCursorPage, AsyncCursorPage
 from ..._base_client import AsyncPaginator, make_request_options
 from ...types.responses import input_item_list_params
-from ...types.responses.response_item_list import Data
+from ...types.responses.response_item import ResponseItem
+from ...types.responses.response_includable import ResponseIncludable
 
 __all__ = ["InputItems", "AsyncInputItems"]
 
@@ -45,29 +46,30 @@ def list(
         self,
         response_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        include: List[ResponseIncludable] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> SyncCursorPage[Data]:
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncCursorPage[ResponseItem]:
         """
         Returns a list of input items for a given response.
 
         Args:
           after: An item ID to list items after, used in pagination.
 
-          before: An item ID to list items before, used in pagination.
+          include: Additional fields to include in the response. See the `include` parameter for
+              Response creation above for more information.
 
           limit: A limit on the number of objects to be returned. Limit can range between 1 and
               100, and the default is 20.
 
-          order: The order to return the input items in. Default is `asc`.
+          order: The order to return the input items in. Default is `desc`.
 
               - `asc`: Return the input items in ascending order.
               - `desc`: Return the input items in descending order.
@@ -84,7 +86,7 @@ def list(
             raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
         return self._get_api_list(
             f"/responses/{response_id}/input_items",
-            page=SyncCursorPage[Data],
+            page=SyncCursorPage[ResponseItem],
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -93,14 +95,14 @@ def list(
                 query=maybe_transform(
                     {
                         "after": after,
-                        "before": before,
+                        "include": include,
                         "limit": limit,
                         "order": order,
                     },
                     input_item_list_params.InputItemListParams,
                 ),
             ),
-            model=cast(Any, Data),  # Union types cannot be passed in as arguments in the type system
+            model=cast(Any, ResponseItem),  # Union types cannot be passed in as arguments in the type system
         )
 
 
@@ -128,29 +130,30 @@ def list(
         self,
         response_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        include: List[ResponseIncludable] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> AsyncPaginator[Data, AsyncCursorPage[Data]]:
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[ResponseItem, AsyncCursorPage[ResponseItem]]:
         """
         Returns a list of input items for a given response.
 
         Args:
           after: An item ID to list items after, used in pagination.
 
-          before: An item ID to list items before, used in pagination.
+          include: Additional fields to include in the response. See the `include` parameter for
+              Response creation above for more information.
 
           limit: A limit on the number of objects to be returned. Limit can range between 1 and
               100, and the default is 20.
 
-          order: The order to return the input items in. Default is `asc`.
+          order: The order to return the input items in. Default is `desc`.
 
               - `asc`: Return the input items in ascending order.
               - `desc`: Return the input items in descending order.
@@ -167,7 +170,7 @@ def list(
             raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
         return self._get_api_list(
             f"/responses/{response_id}/input_items",
-            page=AsyncCursorPage[Data],
+            page=AsyncCursorPage[ResponseItem],
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -176,14 +179,14 @@ def list(
                 query=maybe_transform(
                     {
                         "after": after,
-                        "before": before,
+                        "include": include,
                         "limit": limit,
                         "order": order,
                     },
                     input_item_list_params.InputItemListParams,
                 ),
             ),
-            model=cast(Any, Data),  # Union types cannot be passed in as arguments in the type system
+            model=cast(Any, ResponseItem),  # Union types cannot be passed in as arguments in the type system
         )
 
 
diff --git a/src/openai/resources/responses/input_tokens.py b/src/openai/resources/responses/input_tokens.py
new file mode 100644
index 0000000000..0f47955fe4
--- /dev/null
+++ b/src/openai/resources/responses/input_tokens.py
@@ -0,0 +1,309 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable, Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ... import _legacy_response
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from ..._base_client import make_request_options
+from ...types.responses import input_token_count_params
+from ...types.responses.tool_param import ToolParam
+from ...types.shared_params.reasoning import Reasoning
+from ...types.responses.response_input_item_param import ResponseInputItemParam
+from ...types.responses.input_token_count_response import InputTokenCountResponse
+
+__all__ = ["InputTokens", "AsyncInputTokens"]
+
+
+class InputTokens(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> InputTokensWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return InputTokensWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> InputTokensWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return InputTokensWithStreamingResponse(self)
+
+    def count(
+        self,
+        *,
+        conversation: Optional[input_token_count_params.Conversation] | Omit = omit,
+        input: Union[str, Iterable[ResponseInputItemParam], None] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        model: Optional[str] | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        text: Optional[input_token_count_params.Text] | Omit = omit,
+        tool_choice: Optional[input_token_count_params.ToolChoice] | Omit = omit,
+        tools: Optional[Iterable[ToolParam]] | Omit = omit,
+        truncation: Literal["auto", "disabled"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> InputTokenCountResponse:
+        """
+        Get input token counts
+
+        Args:
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
+          input: Text, image, or file inputs to the model, used to generate a response
+
+          instructions: A system (or developer) message inserted into the model's context. When used
+              along with `previous_response_id`, the instructions from a previous response
+              will not be carried over to the next response. This makes it simple to swap out
+              system (or developer) messages in new responses.
+
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
+          parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
+
+          previous_response_id: The unique ID of the previous response to the model. Use this to create
+              multi-turn conversations. Learn more about
+              [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
+
+          reasoning: **gpt-5 and o-series models only** Configuration options for
+              [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+
+          text: Configuration options for a text response from the model. Can be plain text or
+              structured JSON data. Learn more:
+
+              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+
+          tool_choice: How the model should select which tool (or tools) to use when generating a
+              response. See the `tools` parameter to see how to specify which tools the model
+              can call.
+
+          tools: An array of tools the model may call while generating a response. You can
+              specify which tool to use by setting the `tool_choice` parameter.
+
+          truncation: The truncation strategy to use for the model response. - `auto`: If the input to
+              this Response exceeds the model's context window size, the model will truncate
+              the response to fit the context window by dropping items from the beginning of
+              the conversation. - `disabled` (default): If the input size will exceed the
+              context window size for a model, the request will fail with a 400 error.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/responses/input_tokens",
+            body=maybe_transform(
+                {
+                    "conversation": conversation,
+                    "input": input,
+                    "instructions": instructions,
+                    "model": model,
+                    "parallel_tool_calls": parallel_tool_calls,
+                    "previous_response_id": previous_response_id,
+                    "reasoning": reasoning,
+                    "text": text,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "truncation": truncation,
+                },
+                input_token_count_params.InputTokenCountParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InputTokenCountResponse,
+        )
+
+
+class AsyncInputTokens(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncInputTokensWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncInputTokensWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncInputTokensWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncInputTokensWithStreamingResponse(self)
+
+    async def count(
+        self,
+        *,
+        conversation: Optional[input_token_count_params.Conversation] | Omit = omit,
+        input: Union[str, Iterable[ResponseInputItemParam], None] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        model: Optional[str] | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        text: Optional[input_token_count_params.Text] | Omit = omit,
+        tool_choice: Optional[input_token_count_params.ToolChoice] | Omit = omit,
+        tools: Optional[Iterable[ToolParam]] | Omit = omit,
+        truncation: Literal["auto", "disabled"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> InputTokenCountResponse:
+        """
+        Get input token counts
+
+        Args:
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
+          input: Text, image, or file inputs to the model, used to generate a response
+
+          instructions: A system (or developer) message inserted into the model's context. When used
+              along with `previous_response_id`, the instructions from a previous response
+              will not be carried over to the next response. This makes it simple to swap out
+              system (or developer) messages in new responses.
+
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
+          parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
+
+          previous_response_id: The unique ID of the previous response to the model. Use this to create
+              multi-turn conversations. Learn more about
+              [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
+
+          reasoning: **gpt-5 and o-series models only** Configuration options for
+              [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+
+          text: Configuration options for a text response from the model. Can be plain text or
+              structured JSON data. Learn more:
+
+              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+
+          tool_choice: How the model should select which tool (or tools) to use when generating a
+              response. See the `tools` parameter to see how to specify which tools the model
+              can call.
+
+          tools: An array of tools the model may call while generating a response. You can
+              specify which tool to use by setting the `tool_choice` parameter.
+
+          truncation: The truncation strategy to use for the model response. - `auto`: If the input to
+              this Response exceeds the model's context window size, the model will truncate
+              the response to fit the context window by dropping items from the beginning of
+              the conversation. - `disabled` (default): If the input size will exceed the
+              context window size for a model, the request will fail with a 400 error.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/responses/input_tokens",
+            body=await async_maybe_transform(
+                {
+                    "conversation": conversation,
+                    "input": input,
+                    "instructions": instructions,
+                    "model": model,
+                    "parallel_tool_calls": parallel_tool_calls,
+                    "previous_response_id": previous_response_id,
+                    "reasoning": reasoning,
+                    "text": text,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "truncation": truncation,
+                },
+                input_token_count_params.InputTokenCountParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=InputTokenCountResponse,
+        )
+
+
+class InputTokensWithRawResponse:
+    def __init__(self, input_tokens: InputTokens) -> None:
+        self._input_tokens = input_tokens
+
+        self.count = _legacy_response.to_raw_response_wrapper(
+            input_tokens.count,
+        )
+
+
+class AsyncInputTokensWithRawResponse:
+    def __init__(self, input_tokens: AsyncInputTokens) -> None:
+        self._input_tokens = input_tokens
+
+        self.count = _legacy_response.async_to_raw_response_wrapper(
+            input_tokens.count,
+        )
+
+
+class InputTokensWithStreamingResponse:
+    def __init__(self, input_tokens: InputTokens) -> None:
+        self._input_tokens = input_tokens
+
+        self.count = to_streamed_response_wrapper(
+            input_tokens.count,
+        )
+
+
+class AsyncInputTokensWithStreamingResponse:
+    def __init__(self, input_tokens: AsyncInputTokens) -> None:
+        self._input_tokens = input_tokens
+
+        self.count = async_to_streamed_response_wrapper(
+            input_tokens.count,
+        )
diff --git a/src/openai/resources/responses/responses.py b/src/openai/resources/responses/responses.py
index 0c70a2ef22..dcf87ba07c 100644
--- a/src/openai/resources/responses/responses.py
+++ b/src/openai/resources/responses/responses.py
@@ -9,13 +9,8 @@
 import httpx
 
 from ... import _legacy_response
-from ..._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
-from ..._utils import (
-    is_given,
-    required_args,
-    maybe_transform,
-    async_maybe_transform,
-)
+from ..._types import NOT_GIVEN, Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
+from ..._utils import is_given, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -29,6 +24,14 @@
 )
 from ..._streaming import Stream, AsyncStream
 from ...lib._tools import PydanticFunctionTool, ResponsesPydanticFunctionTool
+from .input_tokens import (
+    InputTokens,
+    AsyncInputTokens,
+    InputTokensWithRawResponse,
+    AsyncInputTokensWithRawResponse,
+    InputTokensWithStreamingResponse,
+    AsyncInputTokensWithStreamingResponse,
+)
 from ..._base_client import make_request_options
 from ...types.responses import response_create_params, response_retrieve_params
 from ...lib._parsing._responses import (
@@ -36,7 +39,6 @@
     parse_response,
     type_to_text_format_param as _type_to_text_format_param,
 )
-from ...types.shared.chat_model import ChatModel
 from ...types.responses.response import Response
 from ...types.responses.tool_param import ToolParam, ParseableToolParam
 from ...types.shared_params.metadata import Metadata
@@ -44,7 +46,9 @@
 from ...types.responses.parsed_response import ParsedResponse
 from ...lib.streaming.responses._responses import ResponseStreamManager, AsyncResponseStreamManager
 from ...types.responses.response_includable import ResponseIncludable
+from ...types.shared_params.responses_model import ResponsesModel
 from ...types.responses.response_input_param import ResponseInputParam
+from ...types.responses.response_prompt_param import ResponsePromptParam
 from ...types.responses.response_stream_event import ResponseStreamEvent
 from ...types.responses.response_text_config_param import ResponseTextConfigParam
 
@@ -56,6 +60,10 @@ class Responses(SyncAPIResource):
     def input_items(self) -> InputItems:
         return InputItems(self._client)
 
+    @cached_property
+    def input_tokens(self) -> InputTokens:
+        return InputTokens(self._client)
+
     @cached_property
     def with_raw_response(self) -> ResponsesWithRawResponse:
         """
@@ -79,30 +87,40 @@ def with_streaming_response(self) -> ResponsesWithStreamingResponse:
     def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Response:
         """Creates a model response.
 
@@ -119,6 +137,33 @@ def create(
         your own data as input for the model's response.
 
         Args:
+          background: Whether to run the model response in the background.
+              [Learn more](https://platform.openai.com/docs/guides/background).
+
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
+          include: Specify additional output data to include in the model response. Currently
+              supported values are:
+
+              - `web_search_call.action.sources`: Include the sources of the web search tool
+                call.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
+              - `computer_call_output.output.image_url`: Include image urls from the computer
+                call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
+
           input: Text, image, or file inputs to the model, used to generate a response.
 
               Learn more:
@@ -129,32 +174,21 @@ def create(
               - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
               - [Function calling](https://platform.openai.com/docs/guides/function-calling)
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
-              wide range of models with different capabilities, performance characteristics,
-              and price points. Refer to the
-              [model guide](https://platform.openai.com/docs/models) to browse and compare
-              available models.
-
-          include: Specify additional output data to include in the model response. Currently
-              supported values are:
-
-              - `file_search_call.results`: Include the search results of the file search tool
-                call.
-              - `message.input_image.image_url`: Include image urls from the input message.
-              - `computer_call_output.output.image_url`: Include image urls from the computer
-                call output.
-
-          instructions: Inserts a system (or developer) message as the first item in the model's
-              context.
+          instructions: A system (or developer) message inserted into the model's context.
 
               When using along with `previous_response_id`, the instructions from a previous
-              response will be not be carried over to the next response. This makes it simple
-              to swap out system (or developer) messages in new responses.
+              response will not be carried over to the next response. This makes it simple to
+              swap out system (or developer) messages in new responses.
 
           max_output_tokens: An upper bound for the number of tokens that can be generated for a response,
               including visible output tokens and
               [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
 
+          max_tool_calls: The maximum number of total calls to built-in tools that can be processed in a
+              response. This maximum number applies across all built-in tool calls, not per
+              individual tool. Any further attempts to call a tool by the model will be
+              ignored.
+
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard.
@@ -162,17 +196,59 @@ def create(
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
           parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
 
           previous_response_id: The unique ID of the previous response to the model. Use this to create
               multi-turn conversations. Learn more about
               [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
+
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
 
-          reasoning: **o-series models only**
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
+
+          reasoning: **gpt-5 and o-series models only**
 
               Configuration options for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          service_tier: Specifies the processing type used for serving the request.
+
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
+              - When not set, the default behavior is 'auto'.
+
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
           store: Whether to store the generated model response for later retrieval via API.
 
           stream: If set to true, the model response data will be streamed to the client as it is
@@ -182,6 +258,8 @@ def create(
               [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
               for more information.
 
+          stream_options: Options for streaming responses. Only set this when you set `stream: true`.
+
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
               make the output more random, while lower values like 0.2 will make it more
               focused and deterministic. We generally recommend altering this or `top_p` but
@@ -200,7 +278,7 @@ def create(
           tools: An array of tools the model may call while generating a response. You can
               specify which tool to use by setting the `tool_choice` parameter.
 
-              The two categories of tools you can provide the model are:
+              We support the following categories of tools:
 
               - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
                 capabilities, like
@@ -208,9 +286,17 @@ def create(
                 [file search](https://platform.openai.com/docs/guides/tools-file-search).
                 Learn more about
                 [built-in tools](https://platform.openai.com/docs/guides/tools).
+              - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+                predefined connectors such as Google Drive and SharePoint. Learn more about
+                [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
               - **Function calls (custom tools)**: Functions that are defined by you, enabling
-                the model to call your own code. Learn more about
+                the model to call your own code with strongly typed arguments and outputs.
+                Learn more about
                 [function calling](https://platform.openai.com/docs/guides/function-calling).
+                You can also use custom tools to call your own code.
+
+          top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
+              return at each token position, each with an associated log probability.
 
           top_p: An alternative to sampling with temperature, called nucleus sampling, where the
               model considers the results of the tokens with top_p probability mass. So 0.1
@@ -220,15 +306,17 @@ def create(
 
           truncation: The truncation strategy to use for the model response.
 
-              - `auto`: If the context of this response and previous ones exceeds the model's
-                context window size, the model will truncate the response to fit the context
-                window by dropping input items in the middle of the conversation.
-              - `disabled` (default): If a model response will exceed the context window size
+              - `auto`: If the input to this Response exceeds the model's context window size,
+                the model will truncate the response to fit the context window by dropping
+                items from the beginning of the conversation.
+              - `disabled` (default): If the input size will exceed the context window size
                 for a model, the request will fail with a 400 error.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
 
           extra_headers: Send extra headers
 
@@ -244,30 +332,40 @@ def create(
     def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
         stream: Literal[True],
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Stream[ResponseStreamEvent]:
         """Creates a model response.
 
@@ -284,22 +382,6 @@ def create(
         your own data as input for the model's response.
 
         Args:
-          input: Text, image, or file inputs to the model, used to generate a response.
-
-              Learn more:
-
-              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-              - [Image inputs](https://platform.openai.com/docs/guides/images)
-              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
-              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
-              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
-
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
-              wide range of models with different capabilities, performance characteristics,
-              and price points. Refer to the
-              [model guide](https://platform.openai.com/docs/models) to browse and compare
-              available models.
-
           stream: If set to true, the model response data will be streamed to the client as it is
               generated using
               [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
@@ -307,26 +389,58 @@ def create(
               [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
               for more information.
 
+          background: Whether to run the model response in the background.
+              [Learn more](https://platform.openai.com/docs/guides/background).
+
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
           include: Specify additional output data to include in the model response. Currently
               supported values are:
 
-              - `file_search_call.results`: Include the search results of the file search tool
+              - `web_search_call.action.sources`: Include the sources of the web search tool
                 call.
-              - `message.input_image.image_url`: Include image urls from the input message.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
               - `computer_call_output.output.image_url`: Include image urls from the computer
                 call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
+
+          input: Text, image, or file inputs to the model, used to generate a response.
+
+              Learn more:
+
+              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              - [Image inputs](https://platform.openai.com/docs/guides/images)
+              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
+              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
+              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
 
-          instructions: Inserts a system (or developer) message as the first item in the model's
-              context.
+          instructions: A system (or developer) message inserted into the model's context.
 
               When using along with `previous_response_id`, the instructions from a previous
-              response will be not be carried over to the next response. This makes it simple
-              to swap out system (or developer) messages in new responses.
+              response will not be carried over to the next response. This makes it simple to
+              swap out system (or developer) messages in new responses.
 
           max_output_tokens: An upper bound for the number of tokens that can be generated for a response,
               including visible output tokens and
               [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
 
+          max_tool_calls: The maximum number of total calls to built-in tools that can be processed in a
+              response. This maximum number applies across all built-in tool calls, not per
+              individual tool. Any further attempts to call a tool by the model will be
+              ignored.
+
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard.
@@ -334,19 +448,63 @@ def create(
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
           parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
 
           previous_response_id: The unique ID of the previous response to the model. Use this to create
               multi-turn conversations. Learn more about
               [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
+
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
 
-          reasoning: **o-series models only**
+          reasoning: **gpt-5 and o-series models only**
 
               Configuration options for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          service_tier: Specifies the processing type used for serving the request.
+
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
+              - When not set, the default behavior is 'auto'.
+
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
           store: Whether to store the generated model response for later retrieval via API.
 
+          stream_options: Options for streaming responses. Only set this when you set `stream: true`.
+
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
               make the output more random, while lower values like 0.2 will make it more
               focused and deterministic. We generally recommend altering this or `top_p` but
@@ -365,7 +523,7 @@ def create(
           tools: An array of tools the model may call while generating a response. You can
               specify which tool to use by setting the `tool_choice` parameter.
 
-              The two categories of tools you can provide the model are:
+              We support the following categories of tools:
 
               - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
                 capabilities, like
@@ -373,9 +531,17 @@ def create(
                 [file search](https://platform.openai.com/docs/guides/tools-file-search).
                 Learn more about
                 [built-in tools](https://platform.openai.com/docs/guides/tools).
+              - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+                predefined connectors such as Google Drive and SharePoint. Learn more about
+                [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
               - **Function calls (custom tools)**: Functions that are defined by you, enabling
-                the model to call your own code. Learn more about
+                the model to call your own code with strongly typed arguments and outputs.
+                Learn more about
                 [function calling](https://platform.openai.com/docs/guides/function-calling).
+                You can also use custom tools to call your own code.
+
+          top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
+              return at each token position, each with an associated log probability.
 
           top_p: An alternative to sampling with temperature, called nucleus sampling, where the
               model considers the results of the tokens with top_p probability mass. So 0.1
@@ -385,15 +551,17 @@ def create(
 
           truncation: The truncation strategy to use for the model response.
 
-              - `auto`: If the context of this response and previous ones exceeds the model's
-                context window size, the model will truncate the response to fit the context
-                window by dropping input items in the middle of the conversation.
-              - `disabled` (default): If a model response will exceed the context window size
+              - `auto`: If the input to this Response exceeds the model's context window size,
+                the model will truncate the response to fit the context window by dropping
+                items from the beginning of the conversation.
+              - `disabled` (default): If the input size will exceed the context window size
                 for a model, the request will fail with a 400 error.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
 
           extra_headers: Send extra headers
 
@@ -409,30 +577,40 @@ def create(
     def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
         stream: bool,
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Response | Stream[ResponseStreamEvent]:
         """Creates a model response.
 
@@ -449,22 +627,6 @@ def create(
         your own data as input for the model's response.
 
         Args:
-          input: Text, image, or file inputs to the model, used to generate a response.
-
-              Learn more:
-
-              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-              - [Image inputs](https://platform.openai.com/docs/guides/images)
-              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
-              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
-              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
-
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
-              wide range of models with different capabilities, performance characteristics,
-              and price points. Refer to the
-              [model guide](https://platform.openai.com/docs/models) to browse and compare
-              available models.
-
           stream: If set to true, the model response data will be streamed to the client as it is
               generated using
               [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
@@ -472,26 +634,58 @@ def create(
               [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
               for more information.
 
+          background: Whether to run the model response in the background.
+              [Learn more](https://platform.openai.com/docs/guides/background).
+
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
           include: Specify additional output data to include in the model response. Currently
               supported values are:
 
-              - `file_search_call.results`: Include the search results of the file search tool
+              - `web_search_call.action.sources`: Include the sources of the web search tool
                 call.
-              - `message.input_image.image_url`: Include image urls from the input message.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
               - `computer_call_output.output.image_url`: Include image urls from the computer
                 call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
+
+          input: Text, image, or file inputs to the model, used to generate a response.
+
+              Learn more:
 
-          instructions: Inserts a system (or developer) message as the first item in the model's
-              context.
+              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              - [Image inputs](https://platform.openai.com/docs/guides/images)
+              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
+              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
+              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
+
+          instructions: A system (or developer) message inserted into the model's context.
 
               When using along with `previous_response_id`, the instructions from a previous
-              response will be not be carried over to the next response. This makes it simple
-              to swap out system (or developer) messages in new responses.
+              response will not be carried over to the next response. This makes it simple to
+              swap out system (or developer) messages in new responses.
 
           max_output_tokens: An upper bound for the number of tokens that can be generated for a response,
               including visible output tokens and
               [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
 
+          max_tool_calls: The maximum number of total calls to built-in tools that can be processed in a
+              response. This maximum number applies across all built-in tool calls, not per
+              individual tool. Any further attempts to call a tool by the model will be
+              ignored.
+
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard.
@@ -499,19 +693,63 @@ def create(
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
           parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
 
           previous_response_id: The unique ID of the previous response to the model. Use this to create
               multi-turn conversations. Learn more about
               [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
 
-          reasoning: **o-series models only**
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
+
+          reasoning: **gpt-5 and o-series models only**
 
               Configuration options for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          service_tier: Specifies the processing type used for serving the request.
+
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
+              - When not set, the default behavior is 'auto'.
+
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
           store: Whether to store the generated model response for later retrieval via API.
 
+          stream_options: Options for streaming responses. Only set this when you set `stream: true`.
+
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
               make the output more random, while lower values like 0.2 will make it more
               focused and deterministic. We generally recommend altering this or `top_p` but
@@ -530,7 +768,7 @@ def create(
           tools: An array of tools the model may call while generating a response. You can
               specify which tool to use by setting the `tool_choice` parameter.
 
-              The two categories of tools you can provide the model are:
+              We support the following categories of tools:
 
               - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
                 capabilities, like
@@ -538,9 +776,17 @@ def create(
                 [file search](https://platform.openai.com/docs/guides/tools-file-search).
                 Learn more about
                 [built-in tools](https://platform.openai.com/docs/guides/tools).
+              - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+                predefined connectors such as Google Drive and SharePoint. Learn more about
+                [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
               - **Function calls (custom tools)**: Functions that are defined by you, enabling
-                the model to call your own code. Learn more about
+                the model to call your own code with strongly typed arguments and outputs.
+                Learn more about
                 [function calling](https://platform.openai.com/docs/guides/function-calling).
+                You can also use custom tools to call your own code.
+
+          top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
+              return at each token position, each with an associated log probability.
 
           top_p: An alternative to sampling with temperature, called nucleus sampling, where the
               model considers the results of the tokens with top_p probability mass. So 0.1
@@ -550,15 +796,17 @@ def create(
 
           truncation: The truncation strategy to use for the model response.
 
-              - `auto`: If the context of this response and previous ones exceeds the model's
-                context window size, the model will truncate the response to fit the context
-                window by dropping input items in the middle of the conversation.
-              - `disabled` (default): If a model response will exceed the context window size
+              - `auto`: If the input to this Response exceeds the model's context window size,
+                the model will truncate the response to fit the context window by dropping
+                items from the beginning of the conversation.
+              - `disabled` (default): If the input size will exceed the context window size
                 for a model, the request will fail with a 400 error.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
 
           extra_headers: Send extra headers
 
@@ -570,59 +818,80 @@ def create(
         """
         ...
 
-    @required_args(["input", "model"], ["input", "model", "stream"])
     def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Response | Stream[ResponseStreamEvent]:
         return self._post(
             "/responses",
             body=maybe_transform(
                 {
-                    "input": input,
-                    "model": model,
+                    "background": background,
+                    "conversation": conversation,
                     "include": include,
+                    "input": input,
                     "instructions": instructions,
                     "max_output_tokens": max_output_tokens,
+                    "max_tool_calls": max_tool_calls,
                     "metadata": metadata,
+                    "model": model,
                     "parallel_tool_calls": parallel_tool_calls,
                     "previous_response_id": previous_response_id,
+                    "prompt": prompt,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
                     "reasoning": reasoning,
+                    "safety_identifier": safety_identifier,
+                    "service_tier": service_tier,
                     "store": store,
                     "stream": stream,
+                    "stream_options": stream_options,
                     "temperature": temperature,
                     "text": text,
                     "tool_choice": tool_choice,
                     "tools": tools,
+                    "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "truncation": truncation,
                     "user": user,
                 },
-                response_create_params.ResponseCreateParams,
+                response_create_params.ResponseCreateParamsStreaming
+                if stream
+                else response_create_params.ResponseCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -632,99 +901,243 @@ def create(
             stream_cls=Stream[ResponseStreamEvent],
         )
 
+    @overload
+    def stream(
+        self,
+        *,
+        response_id: str,
+        text_format: type[TextFormatT] | Omit = omit,
+        starting_after: int | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ResponseStreamManager[TextFormatT]: ...
+
+    @overload
     def stream(
         self,
         *,
         input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        text_format: type[TextFormatT] | NotGiven = NOT_GIVEN,
-        tools: Iterable[ParseableToolParam] | NotGiven = NOT_GIVEN,
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        model: ResponsesModel,
+        background: Optional[bool] | Omit = omit,
+        text_format: type[TextFormatT] | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ResponseStreamManager[TextFormatT]:
-        if is_given(text_format):
-            if not text:
-                text = {}
-
-            if "format" in text:
-                raise TypeError("Cannot mix and match text.format with text_format")
-
-            text["format"] = _type_to_text_format_param(text_format)
+    ) -> ResponseStreamManager[TextFormatT]: ...
 
+    def stream(
+        self,
+        *,
+        response_id: str | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        background: Optional[bool] | Omit = omit,
+        text_format: type[TextFormatT] | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ResponseStreamManager[TextFormatT]:
+        new_response_args = {
+            "input": input,
+            "model": model,
+            "conversation": conversation,
+            "include": include,
+            "instructions": instructions,
+            "max_output_tokens": max_output_tokens,
+            "max_tool_calls": max_tool_calls,
+            "metadata": metadata,
+            "parallel_tool_calls": parallel_tool_calls,
+            "previous_response_id": previous_response_id,
+            "prompt": prompt,
+            "prompt_cache_key": prompt_cache_key,
+            "prompt_cache_retention": prompt_cache_retention,
+            "reasoning": reasoning,
+            "safety_identifier": safety_identifier,
+            "service_tier": service_tier,
+            "store": store,
+            "stream_options": stream_options,
+            "temperature": temperature,
+            "text": text,
+            "tool_choice": tool_choice,
+            "top_logprobs": top_logprobs,
+            "top_p": top_p,
+            "truncation": truncation,
+            "user": user,
+            "background": background,
+        }
+        new_response_args_names = [k for k, v in new_response_args.items() if is_given(v)]
+
+        if (is_given(response_id) or is_given(starting_after)) and len(new_response_args_names) > 0:
+            raise ValueError(
+                "Cannot provide both response_id/starting_after can't be provided together with "
+                + ", ".join(new_response_args_names)
+            )
         tools = _make_tools(tools)
+        if len(new_response_args_names) > 0:
+            if not is_given(input):
+                raise ValueError("input must be provided when creating a new response")
+
+            if not is_given(model):
+                raise ValueError("model must be provided when creating a new response")
+
+            if is_given(text_format):
+                if not text:
+                    text = {}
+
+                if "format" in text:
+                    raise TypeError("Cannot mix and match text.format with text_format")
+
+                text["format"] = _type_to_text_format_param(text_format)
+
+            api_request: partial[Stream[ResponseStreamEvent]] = partial(
+                self.create,
+                input=input,
+                model=model,
+                tools=tools,
+                conversation=conversation,
+                include=include,
+                instructions=instructions,
+                max_output_tokens=max_output_tokens,
+                max_tool_calls=max_tool_calls,
+                metadata=metadata,
+                parallel_tool_calls=parallel_tool_calls,
+                previous_response_id=previous_response_id,
+                prompt=prompt,
+                prompt_cache_key=prompt_cache_key,
+                prompt_cache_retention=prompt_cache_retention,
+                store=store,
+                stream_options=stream_options,
+                stream=True,
+                temperature=temperature,
+                text=text,
+                tool_choice=tool_choice,
+                reasoning=reasoning,
+                safety_identifier=safety_identifier,
+                service_tier=service_tier,
+                top_logprobs=top_logprobs,
+                top_p=top_p,
+                truncation=truncation,
+                user=user,
+                background=background,
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            )
 
-        api_request: partial[Stream[ResponseStreamEvent]] = partial(
-            self.create,
-            input=input,
-            model=model,
-            tools=tools,
-            include=include,
-            instructions=instructions,
-            max_output_tokens=max_output_tokens,
-            metadata=metadata,
-            parallel_tool_calls=parallel_tool_calls,
-            previous_response_id=previous_response_id,
-            store=store,
-            stream=True,
-            temperature=temperature,
-            text=text,
-            tool_choice=tool_choice,
-            reasoning=reasoning,
-            top_p=top_p,
-            truncation=truncation,
-            user=user,
-            extra_headers=extra_headers,
-            extra_query=extra_query,
-            extra_body=extra_body,
-            timeout=timeout,
-        )
-
-        return ResponseStreamManager(
-            api_request,
-            text_format=text_format,
-            input_tools=tools,
-        )
+            return ResponseStreamManager(api_request, text_format=text_format, input_tools=tools, starting_after=None)
+        else:
+            if not is_given(response_id):
+                raise ValueError("id must be provided when streaming an existing response")
+
+            return ResponseStreamManager(
+                lambda: self.retrieve(
+                    response_id=response_id,
+                    stream=True,
+                    include=include or [],
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    starting_after=omit,
+                    timeout=timeout,
+                ),
+                text_format=text_format,
+                input_tools=tools,
+                starting_after=starting_after if is_given(starting_after) else None,
+            )
 
     def parse(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        text_format: type[TextFormatT] | NotGiven = NOT_GIVEN,
-        tools: Iterable[ParseableToolParam] | NotGiven = NOT_GIVEN,
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        text_format: type[TextFormatT] | Omit = omit,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -754,24 +1167,35 @@ def parser(raw_response: Response) -> ParsedResponse[TextFormatT]:
             "/responses",
             body=maybe_transform(
                 {
-                    "input": input,
-                    "model": model,
+                    "background": background,
+                    "conversation": conversation,
                     "include": include,
+                    "input": input,
                     "instructions": instructions,
                     "max_output_tokens": max_output_tokens,
+                    "max_tool_calls": max_tool_calls,
                     "metadata": metadata,
+                    "model": model,
                     "parallel_tool_calls": parallel_tool_calls,
                     "previous_response_id": previous_response_id,
+                    "prompt": prompt,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
                     "reasoning": reasoning,
+                    "safety_identifier": safety_identifier,
+                    "service_tier": service_tier,
                     "store": store,
                     "stream": stream,
+                    "stream_options": stream_options,
                     "temperature": temperature,
                     "text": text,
                     "tool_choice": tool_choice,
                     "tools": tools,
+                    "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "truncation": truncation,
                     "user": user,
+                    "verbosity": verbosity,
                 },
                 response_create_params.ResponseCreateParams,
             ),
@@ -787,18 +1211,70 @@ def parser(raw_response: Response) -> ParsedResponse[TextFormatT]:
             cast_to=cast(Type[ParsedResponse[TextFormatT]], Response),
         )
 
+    @overload
+    def retrieve(
+        self,
+        response_id: str,
+        *,
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        stream: Literal[False] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response: ...
+
+    @overload
+    def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: Literal[True],
+        include: List[ResponseIncludable] | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Stream[ResponseStreamEvent]: ...
+
+    @overload
     def retrieve(
         self,
         response_id: str,
         *,
-        include: List[ResponseIncludable] | NotGiven = NOT_GIVEN,
+        stream: bool,
+        include: List[ResponseIncludable] | Omit = omit,
+        starting_after: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Response:
+    ) -> Response | Stream[ResponseStreamEvent]: ...
+
+    @overload
+    def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: bool = False,
+        include: List[ResponseIncludable] | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Response | Stream[ResponseStreamEvent]:
         """
         Retrieves a model response with the given ID.
 
@@ -806,6 +1282,22 @@ def retrieve(
           include: Additional fields to include in the response. See the `include` parameter for
               Response creation above for more information.
 
+          include_obfuscation: When true, stream obfuscation will be enabled. Stream obfuscation adds random
+              characters to an `obfuscation` field on streaming delta events to normalize
+              payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+              fields are included by default, but add a small amount of overhead to the data
+              stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+              you trust the network links between your application and the OpenAI API.
+
+          starting_after: The sequence number of the event after which to start streaming.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+              for more information.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -814,19 +1306,144 @@ def retrieve(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not response_id:
-            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
-        return self._get(
-            f"/responses/{response_id}",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform({"include": include}, response_retrieve_params.ResponseRetrieveParams),
-            ),
-            cast_to=Response,
-        )
+        ...
+
+    @overload
+    def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: Literal[True],
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Stream[ResponseStreamEvent]:
+        """
+        Retrieves a model response with the given ID.
+
+        Args:
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+              for more information.
+
+          include: Additional fields to include in the response. See the `include` parameter for
+              Response creation above for more information.
+
+          include_obfuscation: When true, stream obfuscation will be enabled. Stream obfuscation adds random
+              characters to an `obfuscation` field on streaming delta events to normalize
+              payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+              fields are included by default, but add a small amount of overhead to the data
+              stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+              you trust the network links between your application and the OpenAI API.
+
+          starting_after: The sequence number of the event after which to start streaming.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: bool,
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response | Stream[ResponseStreamEvent]:
+        """
+        Retrieves a model response with the given ID.
+
+        Args:
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+              for more information.
+
+          include: Additional fields to include in the response. See the `include` parameter for
+              Response creation above for more information.
+
+          include_obfuscation: When true, stream obfuscation will be enabled. Stream obfuscation adds random
+              characters to an `obfuscation` field on streaming delta events to normalize
+              payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+              fields are included by default, but add a small amount of overhead to the data
+              stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+              you trust the network links between your application and the OpenAI API.
+
+          starting_after: The sequence number of the event after which to start streaming.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    def retrieve(
+        self,
+        response_id: str,
+        *,
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        stream: Literal[False] | Literal[True] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response | Stream[ResponseStreamEvent]:
+        if not response_id:
+            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
+        return self._get(
+            f"/responses/{response_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "include": include,
+                        "include_obfuscation": include_obfuscation,
+                        "starting_after": starting_after,
+                        "stream": stream,
+                    },
+                    response_retrieve_params.ResponseRetrieveParams,
+                ),
+            ),
+            cast_to=Response,
+            stream=stream or False,
+            stream_cls=Stream[ResponseStreamEvent],
+        )
 
     def delete(
         self,
@@ -837,7 +1454,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> None:
         """
         Deletes a model response with the given ID.
@@ -862,12 +1479,52 @@ def delete(
             cast_to=NoneType,
         )
 
+    def cancel(
+        self,
+        response_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response:
+        """Cancels a model response with the given ID.
+
+        Only responses created with the
+        `background` parameter set to `true` can be cancelled.
+        [Learn more](https://platform.openai.com/docs/guides/background).
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not response_id:
+            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
+        return self._post(
+            f"/responses/{response_id}/cancel",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Response,
+        )
+
 
 class AsyncResponses(AsyncAPIResource):
     @cached_property
     def input_items(self) -> AsyncInputItems:
         return AsyncInputItems(self._client)
 
+    @cached_property
+    def input_tokens(self) -> AsyncInputTokens:
+        return AsyncInputTokens(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncResponsesWithRawResponse:
         """
@@ -891,30 +1548,40 @@ def with_streaming_response(self) -> AsyncResponsesWithStreamingResponse:
     async def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Response:
         """Creates a model response.
 
@@ -931,6 +1598,33 @@ async def create(
         your own data as input for the model's response.
 
         Args:
+          background: Whether to run the model response in the background.
+              [Learn more](https://platform.openai.com/docs/guides/background).
+
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
+          include: Specify additional output data to include in the model response. Currently
+              supported values are:
+
+              - `web_search_call.action.sources`: Include the sources of the web search tool
+                call.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
+              - `computer_call_output.output.image_url`: Include image urls from the computer
+                call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
+
           input: Text, image, or file inputs to the model, used to generate a response.
 
               Learn more:
@@ -941,32 +1635,21 @@ async def create(
               - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
               - [Function calling](https://platform.openai.com/docs/guides/function-calling)
 
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
-              wide range of models with different capabilities, performance characteristics,
-              and price points. Refer to the
-              [model guide](https://platform.openai.com/docs/models) to browse and compare
-              available models.
-
-          include: Specify additional output data to include in the model response. Currently
-              supported values are:
-
-              - `file_search_call.results`: Include the search results of the file search tool
-                call.
-              - `message.input_image.image_url`: Include image urls from the input message.
-              - `computer_call_output.output.image_url`: Include image urls from the computer
-                call output.
-
-          instructions: Inserts a system (or developer) message as the first item in the model's
-              context.
+          instructions: A system (or developer) message inserted into the model's context.
 
               When using along with `previous_response_id`, the instructions from a previous
-              response will be not be carried over to the next response. This makes it simple
-              to swap out system (or developer) messages in new responses.
+              response will not be carried over to the next response. This makes it simple to
+              swap out system (or developer) messages in new responses.
 
           max_output_tokens: An upper bound for the number of tokens that can be generated for a response,
               including visible output tokens and
               [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
 
+          max_tool_calls: The maximum number of total calls to built-in tools that can be processed in a
+              response. This maximum number applies across all built-in tool calls, not per
+              individual tool. Any further attempts to call a tool by the model will be
+              ignored.
+
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard.
@@ -974,17 +1657,59 @@ async def create(
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
           parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
 
           previous_response_id: The unique ID of the previous response to the model. Use this to create
               multi-turn conversations. Learn more about
               [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
+
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
 
-          reasoning: **o-series models only**
+          reasoning: **gpt-5 and o-series models only**
 
               Configuration options for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          service_tier: Specifies the processing type used for serving the request.
+
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
+              - When not set, the default behavior is 'auto'.
+
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
           store: Whether to store the generated model response for later retrieval via API.
 
           stream: If set to true, the model response data will be streamed to the client as it is
@@ -994,6 +1719,8 @@ async def create(
               [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
               for more information.
 
+          stream_options: Options for streaming responses. Only set this when you set `stream: true`.
+
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
               make the output more random, while lower values like 0.2 will make it more
               focused and deterministic. We generally recommend altering this or `top_p` but
@@ -1012,7 +1739,7 @@ async def create(
           tools: An array of tools the model may call while generating a response. You can
               specify which tool to use by setting the `tool_choice` parameter.
 
-              The two categories of tools you can provide the model are:
+              We support the following categories of tools:
 
               - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
                 capabilities, like
@@ -1020,9 +1747,17 @@ async def create(
                 [file search](https://platform.openai.com/docs/guides/tools-file-search).
                 Learn more about
                 [built-in tools](https://platform.openai.com/docs/guides/tools).
+              - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+                predefined connectors such as Google Drive and SharePoint. Learn more about
+                [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
               - **Function calls (custom tools)**: Functions that are defined by you, enabling
-                the model to call your own code. Learn more about
+                the model to call your own code with strongly typed arguments and outputs.
+                Learn more about
                 [function calling](https://platform.openai.com/docs/guides/function-calling).
+                You can also use custom tools to call your own code.
+
+          top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
+              return at each token position, each with an associated log probability.
 
           top_p: An alternative to sampling with temperature, called nucleus sampling, where the
               model considers the results of the tokens with top_p probability mass. So 0.1
@@ -1032,15 +1767,17 @@ async def create(
 
           truncation: The truncation strategy to use for the model response.
 
-              - `auto`: If the context of this response and previous ones exceeds the model's
-                context window size, the model will truncate the response to fit the context
-                window by dropping input items in the middle of the conversation.
-              - `disabled` (default): If a model response will exceed the context window size
+              - `auto`: If the input to this Response exceeds the model's context window size,
+                the model will truncate the response to fit the context window by dropping
+                items from the beginning of the conversation.
+              - `disabled` (default): If the input size will exceed the context window size
                 for a model, the request will fail with a 400 error.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
 
           extra_headers: Send extra headers
 
@@ -1056,30 +1793,40 @@ async def create(
     async def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
         stream: Literal[True],
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncStream[ResponseStreamEvent]:
         """Creates a model response.
 
@@ -1096,22 +1843,6 @@ async def create(
         your own data as input for the model's response.
 
         Args:
-          input: Text, image, or file inputs to the model, used to generate a response.
-
-              Learn more:
-
-              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-              - [Image inputs](https://platform.openai.com/docs/guides/images)
-              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
-              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
-              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
-
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
-              wide range of models with different capabilities, performance characteristics,
-              and price points. Refer to the
-              [model guide](https://platform.openai.com/docs/models) to browse and compare
-              available models.
-
           stream: If set to true, the model response data will be streamed to the client as it is
               generated using
               [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
@@ -1119,26 +1850,58 @@ async def create(
               [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
               for more information.
 
+          background: Whether to run the model response in the background.
+              [Learn more](https://platform.openai.com/docs/guides/background).
+
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
           include: Specify additional output data to include in the model response. Currently
               supported values are:
 
-              - `file_search_call.results`: Include the search results of the file search tool
+              - `web_search_call.action.sources`: Include the sources of the web search tool
                 call.
-              - `message.input_image.image_url`: Include image urls from the input message.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
               - `computer_call_output.output.image_url`: Include image urls from the computer
                 call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
+
+          input: Text, image, or file inputs to the model, used to generate a response.
+
+              Learn more:
+
+              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              - [Image inputs](https://platform.openai.com/docs/guides/images)
+              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
+              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
+              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
 
-          instructions: Inserts a system (or developer) message as the first item in the model's
-              context.
+          instructions: A system (or developer) message inserted into the model's context.
 
               When using along with `previous_response_id`, the instructions from a previous
-              response will be not be carried over to the next response. This makes it simple
-              to swap out system (or developer) messages in new responses.
+              response will not be carried over to the next response. This makes it simple to
+              swap out system (or developer) messages in new responses.
 
           max_output_tokens: An upper bound for the number of tokens that can be generated for a response,
               including visible output tokens and
               [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
 
+          max_tool_calls: The maximum number of total calls to built-in tools that can be processed in a
+              response. This maximum number applies across all built-in tool calls, not per
+              individual tool. Any further attempts to call a tool by the model will be
+              ignored.
+
           metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard.
@@ -1146,19 +1909,63 @@ async def create(
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
           parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
 
           previous_response_id: The unique ID of the previous response to the model. Use this to create
               multi-turn conversations. Learn more about
               [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
 
-          reasoning: **o-series models only**
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
+
+          reasoning: **gpt-5 and o-series models only**
 
               Configuration options for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          service_tier: Specifies the processing type used for serving the request.
+
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
+              - When not set, the default behavior is 'auto'.
+
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
           store: Whether to store the generated model response for later retrieval via API.
 
+          stream_options: Options for streaming responses. Only set this when you set `stream: true`.
+
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
               make the output more random, while lower values like 0.2 will make it more
               focused and deterministic. We generally recommend altering this or `top_p` but
@@ -1177,7 +1984,7 @@ async def create(
           tools: An array of tools the model may call while generating a response. You can
               specify which tool to use by setting the `tool_choice` parameter.
 
-              The two categories of tools you can provide the model are:
+              We support the following categories of tools:
 
               - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
                 capabilities, like
@@ -1185,9 +1992,17 @@ async def create(
                 [file search](https://platform.openai.com/docs/guides/tools-file-search).
                 Learn more about
                 [built-in tools](https://platform.openai.com/docs/guides/tools).
+              - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+                predefined connectors such as Google Drive and SharePoint. Learn more about
+                [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
               - **Function calls (custom tools)**: Functions that are defined by you, enabling
-                the model to call your own code. Learn more about
+                the model to call your own code with strongly typed arguments and outputs.
+                Learn more about
                 [function calling](https://platform.openai.com/docs/guides/function-calling).
+                You can also use custom tools to call your own code.
+
+          top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
+              return at each token position, each with an associated log probability.
 
           top_p: An alternative to sampling with temperature, called nucleus sampling, where the
               model considers the results of the tokens with top_p probability mass. So 0.1
@@ -1197,15 +2012,17 @@ async def create(
 
           truncation: The truncation strategy to use for the model response.
 
-              - `auto`: If the context of this response and previous ones exceeds the model's
-                context window size, the model will truncate the response to fit the context
-                window by dropping input items in the middle of the conversation.
-              - `disabled` (default): If a model response will exceed the context window size
+              - `auto`: If the input to this Response exceeds the model's context window size,
+                the model will truncate the response to fit the context window by dropping
+                items from the beginning of the conversation.
+              - `disabled` (default): If the input size will exceed the context window size
                 for a model, the request will fail with a 400 error.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
 
           extra_headers: Send extra headers
 
@@ -1221,30 +2038,40 @@ async def create(
     async def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
         stream: bool,
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Response | AsyncStream[ResponseStreamEvent]:
         """Creates a model response.
 
@@ -1261,22 +2088,6 @@ async def create(
         your own data as input for the model's response.
 
         Args:
-          input: Text, image, or file inputs to the model, used to generate a response.
-
-              Learn more:
-
-              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-              - [Image inputs](https://platform.openai.com/docs/guides/images)
-              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
-              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
-              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
-
-          model: Model ID used to generate the response, like `gpt-4o` or `o1`. OpenAI offers a
-              wide range of models with different capabilities, performance characteristics,
-              and price points. Refer to the
-              [model guide](https://platform.openai.com/docs/models) to browse and compare
-              available models.
-
           stream: If set to true, the model response data will be streamed to the client as it is
               generated using
               [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
@@ -1284,46 +2095,122 @@ async def create(
               [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
               for more information.
 
+          background: Whether to run the model response in the background.
+              [Learn more](https://platform.openai.com/docs/guides/background).
+
+          conversation: The conversation that this response belongs to. Items from this conversation are
+              prepended to `input_items` for this response request. Input items and output
+              items from this response are automatically added to this conversation after this
+              response completes.
+
           include: Specify additional output data to include in the model response. Currently
               supported values are:
 
-              - `file_search_call.results`: Include the search results of the file search tool
+              - `web_search_call.action.sources`: Include the sources of the web search tool
                 call.
-              - `message.input_image.image_url`: Include image urls from the input message.
+              - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+                in code interpreter tool call items.
               - `computer_call_output.output.image_url`: Include image urls from the computer
                 call output.
+              - `file_search_call.results`: Include the search results of the file search tool
+                call.
+              - `message.input_image.image_url`: Include image urls from the input message.
+              - `message.output_text.logprobs`: Include logprobs with assistant messages.
+              - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+                tokens in reasoning item outputs. This enables reasoning items to be used in
+                multi-turn conversations when using the Responses API statelessly (like when
+                the `store` parameter is set to `false`, or when an organization is enrolled
+                in the zero data retention program).
 
-          instructions: Inserts a system (or developer) message as the first item in the model's
-              context.
-
-              When using along with `previous_response_id`, the instructions from a previous
-              response will be not be carried over to the next response. This makes it simple
-              to swap out system (or developer) messages in new responses.
+          input: Text, image, or file inputs to the model, used to generate a response.
 
-          max_output_tokens: An upper bound for the number of tokens that can be generated for a response,
-              including visible output tokens and
-              [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
+              Learn more:
 
-          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
-              for storing additional information about the object in a structured format, and
+              - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              - [Image inputs](https://platform.openai.com/docs/guides/images)
+              - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
+              - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
+              - [Function calling](https://platform.openai.com/docs/guides/function-calling)
+
+          instructions: A system (or developer) message inserted into the model's context.
+
+              When using along with `previous_response_id`, the instructions from a previous
+              response will not be carried over to the next response. This makes it simple to
+              swap out system (or developer) messages in new responses.
+
+          max_output_tokens: An upper bound for the number of tokens that can be generated for a response,
+              including visible output tokens and
+              [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
+
+          max_tool_calls: The maximum number of total calls to built-in tools that can be processed in a
+              response. This maximum number applies across all built-in tool calls, not per
+              individual tool. Any further attempts to call a tool by the model will be
+              ignored.
+
+          metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
+              for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard.
 
               Keys are strings with a maximum length of 64 characters. Values are strings with
               a maximum length of 512 characters.
 
+          model: Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+              wide range of models with different capabilities, performance characteristics,
+              and price points. Refer to the
+              [model guide](https://platform.openai.com/docs/models) to browse and compare
+              available models.
+
           parallel_tool_calls: Whether to allow the model to run tool calls in parallel.
 
           previous_response_id: The unique ID of the previous response to the model. Use this to create
               multi-turn conversations. Learn more about
               [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+              Cannot be used in conjunction with `conversation`.
+
+          prompt: Reference to a prompt template and its variables.
+              [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+
+          prompt_cache_key: Used by OpenAI to cache responses for similar requests to optimize your cache
+              hit rates. Replaces the `user` field.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
 
-          reasoning: **o-series models only**
+          prompt_cache_retention: The retention policy for the prompt cache. Set to `24h` to enable extended
+              prompt caching, which keeps cached prefixes active for longer, up to a maximum
+              of 24 hours.
+              [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
+
+          reasoning: **gpt-5 and o-series models only**
 
               Configuration options for
               [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 
+          safety_identifier: A stable identifier used to help detect users of your application that may be
+              violating OpenAI's usage policies. The IDs should be a string that uniquely
+              identifies each user. We recommend hashing their username or email address, in
+              order to avoid sending us any identifying information.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+
+          service_tier: Specifies the processing type used for serving the request.
+
+              - If set to 'auto', then the request will be processed with the service tier
+                configured in the Project settings. Unless otherwise configured, the Project
+                will use 'default'.
+              - If set to 'default', then the request will be processed with the standard
+                pricing and performance for the selected model.
+              - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+                '[priority](https://openai.com/api-priority-processing/)', then the request
+                will be processed with the corresponding service tier.
+              - When not set, the default behavior is 'auto'.
+
+              When the `service_tier` parameter is set, the response body will include the
+              `service_tier` value based on the processing mode actually used to serve the
+              request. This response value may be different from the value set in the
+              parameter.
+
           store: Whether to store the generated model response for later retrieval via API.
 
+          stream_options: Options for streaming responses. Only set this when you set `stream: true`.
+
           temperature: What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
               make the output more random, while lower values like 0.2 will make it more
               focused and deterministic. We generally recommend altering this or `top_p` but
@@ -1342,7 +2229,7 @@ async def create(
           tools: An array of tools the model may call while generating a response. You can
               specify which tool to use by setting the `tool_choice` parameter.
 
-              The two categories of tools you can provide the model are:
+              We support the following categories of tools:
 
               - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
                 capabilities, like
@@ -1350,9 +2237,17 @@ async def create(
                 [file search](https://platform.openai.com/docs/guides/tools-file-search).
                 Learn more about
                 [built-in tools](https://platform.openai.com/docs/guides/tools).
+              - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+                predefined connectors such as Google Drive and SharePoint. Learn more about
+                [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
               - **Function calls (custom tools)**: Functions that are defined by you, enabling
-                the model to call your own code. Learn more about
+                the model to call your own code with strongly typed arguments and outputs.
+                Learn more about
                 [function calling](https://platform.openai.com/docs/guides/function-calling).
+                You can also use custom tools to call your own code.
+
+          top_logprobs: An integer between 0 and 20 specifying the number of most likely tokens to
+              return at each token position, each with an associated log probability.
 
           top_p: An alternative to sampling with temperature, called nucleus sampling, where the
               model considers the results of the tokens with top_p probability mass. So 0.1
@@ -1362,15 +2257,17 @@ async def create(
 
           truncation: The truncation strategy to use for the model response.
 
-              - `auto`: If the context of this response and previous ones exceeds the model's
-                context window size, the model will truncate the response to fit the context
-                window by dropping input items in the middle of the conversation.
-              - `disabled` (default): If a model response will exceed the context window size
+              - `auto`: If the input to this Response exceeds the model's context window size,
+                the model will truncate the response to fit the context window by dropping
+                items from the beginning of the conversation.
+              - `disabled` (default): If the input size will exceed the context window size
                 for a model, the request will fail with a 400 error.
 
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+          user: This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
+              `prompt_cache_key` instead to maintain caching optimizations. A stable
+              identifier for your end-users. Used to boost cache hit rates by better bucketing
+              similar requests and to help OpenAI detect and prevent abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
 
           extra_headers: Send extra headers
 
@@ -1382,59 +2279,80 @@ async def create(
         """
         ...
 
-    @required_args(["input", "model"], ["input", "model", "stream"])
     async def create(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Response | AsyncStream[ResponseStreamEvent]:
         return await self._post(
             "/responses",
             body=await async_maybe_transform(
                 {
-                    "input": input,
-                    "model": model,
+                    "background": background,
+                    "conversation": conversation,
                     "include": include,
+                    "input": input,
                     "instructions": instructions,
                     "max_output_tokens": max_output_tokens,
+                    "max_tool_calls": max_tool_calls,
                     "metadata": metadata,
+                    "model": model,
                     "parallel_tool_calls": parallel_tool_calls,
                     "previous_response_id": previous_response_id,
+                    "prompt": prompt,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
                     "reasoning": reasoning,
+                    "safety_identifier": safety_identifier,
+                    "service_tier": service_tier,
                     "store": store,
                     "stream": stream,
+                    "stream_options": stream_options,
                     "temperature": temperature,
                     "text": text,
                     "tool_choice": tool_choice,
                     "tools": tools,
+                    "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "truncation": truncation,
                     "user": user,
                 },
-                response_create_params.ResponseCreateParams,
+                response_create_params.ResponseCreateParamsStreaming
+                if stream
+                else response_create_params.ResponseCreateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -1444,98 +2362,248 @@ async def create(
             stream_cls=AsyncStream[ResponseStreamEvent],
         )
 
+    @overload
+    def stream(
+        self,
+        *,
+        response_id: str,
+        text_format: type[TextFormatT] | Omit = omit,
+        starting_after: int | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncResponseStreamManager[TextFormatT]: ...
+
+    @overload
     def stream(
         self,
         *,
         input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        text_format: type[TextFormatT] | NotGiven = NOT_GIVEN,
-        tools: Iterable[ParseableToolParam] | NotGiven = NOT_GIVEN,
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        model: ResponsesModel,
+        background: Optional[bool] | Omit = omit,
+        text_format: type[TextFormatT] | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> AsyncResponseStreamManager[TextFormatT]:
-        if is_given(text_format):
-            if not text:
-                text = {}
-
-            if "format" in text:
-                raise TypeError("Cannot mix and match text.format with text_format")
+    ) -> AsyncResponseStreamManager[TextFormatT]: ...
 
-            text["format"] = _type_to_text_format_param(text_format)
+    def stream(
+        self,
+        *,
+        response_id: str | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        background: Optional[bool] | Omit = omit,
+        text_format: type[TextFormatT] | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncResponseStreamManager[TextFormatT]:
+        new_response_args = {
+            "input": input,
+            "model": model,
+            "conversation": conversation,
+            "include": include,
+            "instructions": instructions,
+            "max_output_tokens": max_output_tokens,
+            "max_tool_calls": max_tool_calls,
+            "metadata": metadata,
+            "parallel_tool_calls": parallel_tool_calls,
+            "previous_response_id": previous_response_id,
+            "prompt": prompt,
+            "prompt_cache_key": prompt_cache_key,
+            "prompt_cache_retention": prompt_cache_retention,
+            "reasoning": reasoning,
+            "safety_identifier": safety_identifier,
+            "service_tier": service_tier,
+            "store": store,
+            "stream_options": stream_options,
+            "temperature": temperature,
+            "text": text,
+            "tool_choice": tool_choice,
+            "top_logprobs": top_logprobs,
+            "top_p": top_p,
+            "truncation": truncation,
+            "user": user,
+            "background": background,
+        }
+        new_response_args_names = [k for k, v in new_response_args.items() if is_given(v)]
+
+        if (is_given(response_id) or is_given(starting_after)) and len(new_response_args_names) > 0:
+            raise ValueError(
+                "Cannot provide both response_id/starting_after can't be provided together with "
+                + ", ".join(new_response_args_names)
+            )
 
         tools = _make_tools(tools)
+        if len(new_response_args_names) > 0:
+            if isinstance(input, NotGiven):
+                raise ValueError("input must be provided when creating a new response")
+
+            if not is_given(model):
+                raise ValueError("model must be provided when creating a new response")
+
+            if is_given(text_format):
+                if not text:
+                    text = {}
+
+                if "format" in text:
+                    raise TypeError("Cannot mix and match text.format with text_format")
+
+                text["format"] = _type_to_text_format_param(text_format)
+
+            api_request = self.create(
+                input=input,
+                model=model,
+                stream=True,
+                tools=tools,
+                conversation=conversation,
+                include=include,
+                instructions=instructions,
+                max_output_tokens=max_output_tokens,
+                max_tool_calls=max_tool_calls,
+                metadata=metadata,
+                parallel_tool_calls=parallel_tool_calls,
+                previous_response_id=previous_response_id,
+                prompt=prompt,
+                prompt_cache_key=prompt_cache_key,
+                prompt_cache_retention=prompt_cache_retention,
+                store=store,
+                stream_options=stream_options,
+                temperature=temperature,
+                text=text,
+                tool_choice=tool_choice,
+                reasoning=reasoning,
+                safety_identifier=safety_identifier,
+                service_tier=service_tier,
+                top_logprobs=top_logprobs,
+                top_p=top_p,
+                truncation=truncation,
+                user=user,
+                background=background,
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            )
 
-        api_request = self.create(
-            input=input,
-            model=model,
-            tools=tools,
-            include=include,
-            instructions=instructions,
-            max_output_tokens=max_output_tokens,
-            metadata=metadata,
-            parallel_tool_calls=parallel_tool_calls,
-            previous_response_id=previous_response_id,
-            store=store,
-            stream=True,
-            temperature=temperature,
-            text=text,
-            tool_choice=tool_choice,
-            reasoning=reasoning,
-            top_p=top_p,
-            truncation=truncation,
-            user=user,
-            extra_headers=extra_headers,
-            extra_query=extra_query,
-            extra_body=extra_body,
-            timeout=timeout,
-        )
-
-        return AsyncResponseStreamManager(
-            api_request,
-            text_format=text_format,
-            input_tools=tools,
-        )
+            return AsyncResponseStreamManager(
+                api_request,
+                text_format=text_format,
+                input_tools=tools,
+                starting_after=None,
+            )
+        else:
+            if isinstance(response_id, Omit):
+                raise ValueError("response_id must be provided when streaming an existing response")
+
+            api_request = self.retrieve(
+                response_id,
+                stream=True,
+                include=include or [],
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            )
+            return AsyncResponseStreamManager(
+                api_request,
+                text_format=text_format,
+                input_tools=tools,
+                starting_after=starting_after if is_given(starting_after) else None,
+            )
 
     async def parse(
         self,
         *,
-        input: Union[str, ResponseInputParam],
-        model: Union[str, ChatModel],
-        text_format: type[TextFormatT] | NotGiven = NOT_GIVEN,
-        tools: Iterable[ParseableToolParam] | NotGiven = NOT_GIVEN,
-        include: Optional[List[ResponseIncludable]] | NotGiven = NOT_GIVEN,
-        instructions: Optional[str] | NotGiven = NOT_GIVEN,
-        max_output_tokens: Optional[int] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        parallel_tool_calls: Optional[bool] | NotGiven = NOT_GIVEN,
-        previous_response_id: Optional[str] | NotGiven = NOT_GIVEN,
-        reasoning: Optional[Reasoning] | NotGiven = NOT_GIVEN,
-        store: Optional[bool] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
-        temperature: Optional[float] | NotGiven = NOT_GIVEN,
-        text: ResponseTextConfigParam | NotGiven = NOT_GIVEN,
-        tool_choice: response_create_params.ToolChoice | NotGiven = NOT_GIVEN,
-        top_p: Optional[float] | NotGiven = NOT_GIVEN,
-        truncation: Optional[Literal["auto", "disabled"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
+        text_format: type[TextFormatT] | Omit = omit,
+        background: Optional[bool] | Omit = omit,
+        conversation: Optional[response_create_params.Conversation] | Omit = omit,
+        include: Optional[List[ResponseIncludable]] | Omit = omit,
+        input: Union[str, ResponseInputParam] | Omit = omit,
+        instructions: Optional[str] | Omit = omit,
+        max_output_tokens: Optional[int] | Omit = omit,
+        max_tool_calls: Optional[int] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        model: ResponsesModel | Omit = omit,
+        parallel_tool_calls: Optional[bool] | Omit = omit,
+        previous_response_id: Optional[str] | Omit = omit,
+        prompt: Optional[ResponsePromptParam] | Omit = omit,
+        prompt_cache_key: str | Omit = omit,
+        prompt_cache_retention: Optional[Literal["in-memory", "24h"]] | Omit = omit,
+        reasoning: Optional[Reasoning] | Omit = omit,
+        safety_identifier: str | Omit = omit,
+        service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] | Omit = omit,
+        store: Optional[bool] | Omit = omit,
+        stream: Optional[Literal[False]] | Literal[True] | Omit = omit,
+        stream_options: Optional[response_create_params.StreamOptions] | Omit = omit,
+        temperature: Optional[float] | Omit = omit,
+        text: ResponseTextConfigParam | Omit = omit,
+        tool_choice: response_create_params.ToolChoice | Omit = omit,
+        tools: Iterable[ParseableToolParam] | Omit = omit,
+        top_logprobs: Optional[int] | Omit = omit,
+        top_p: Optional[float] | Omit = omit,
+        truncation: Optional[Literal["auto", "disabled"]] | Omit = omit,
+        user: str | Omit = omit,
+        verbosity: Optional[Literal["low", "medium", "high"]] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -1565,24 +2633,35 @@ def parser(raw_response: Response) -> ParsedResponse[TextFormatT]:
             "/responses",
             body=maybe_transform(
                 {
-                    "input": input,
-                    "model": model,
+                    "background": background,
+                    "conversation": conversation,
                     "include": include,
+                    "input": input,
                     "instructions": instructions,
                     "max_output_tokens": max_output_tokens,
+                    "max_tool_calls": max_tool_calls,
                     "metadata": metadata,
+                    "model": model,
                     "parallel_tool_calls": parallel_tool_calls,
                     "previous_response_id": previous_response_id,
+                    "prompt": prompt,
+                    "prompt_cache_key": prompt_cache_key,
+                    "prompt_cache_retention": prompt_cache_retention,
                     "reasoning": reasoning,
+                    "safety_identifier": safety_identifier,
+                    "service_tier": service_tier,
                     "store": store,
                     "stream": stream,
+                    "stream_options": stream_options,
                     "temperature": temperature,
                     "text": text,
                     "tool_choice": tool_choice,
                     "tools": tools,
+                    "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "truncation": truncation,
                     "user": user,
+                    "verbosity": verbosity,
                 },
                 response_create_params.ResponseCreateParams,
             ),
@@ -1598,18 +2677,70 @@ def parser(raw_response: Response) -> ParsedResponse[TextFormatT]:
             cast_to=cast(Type[ParsedResponse[TextFormatT]], Response),
         )
 
+    @overload
+    async def retrieve(
+        self,
+        response_id: str,
+        *,
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        stream: Literal[False] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response: ...
+
+    @overload
+    async def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: Literal[True],
+        include: List[ResponseIncludable] | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncStream[ResponseStreamEvent]: ...
+
+    @overload
     async def retrieve(
         self,
         response_id: str,
         *,
-        include: List[ResponseIncludable] | NotGiven = NOT_GIVEN,
+        stream: bool,
+        include: List[ResponseIncludable] | Omit = omit,
+        starting_after: int | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Response:
+    ) -> Response | AsyncStream[ResponseStreamEvent]: ...
+
+    @overload
+    async def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: bool = False,
+        include: List[ResponseIncludable] | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Response | AsyncStream[ResponseStreamEvent]:
         """
         Retrieves a model response with the given ID.
 
@@ -1617,6 +2748,120 @@ async def retrieve(
           include: Additional fields to include in the response. See the `include` parameter for
               Response creation above for more information.
 
+          include_obfuscation: When true, stream obfuscation will be enabled. Stream obfuscation adds random
+              characters to an `obfuscation` field on streaming delta events to normalize
+              payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+              fields are included by default, but add a small amount of overhead to the data
+              stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+              you trust the network links between your application and the OpenAI API.
+
+          starting_after: The sequence number of the event after which to start streaming.
+
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+              for more information.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    async def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: Literal[True],
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncStream[ResponseStreamEvent]:
+        """
+        Retrieves a model response with the given ID.
+
+        Args:
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+              for more information.
+
+          include: Additional fields to include in the response. See the `include` parameter for
+              Response creation above for more information.
+
+          include_obfuscation: When true, stream obfuscation will be enabled. Stream obfuscation adds random
+              characters to an `obfuscation` field on streaming delta events to normalize
+              payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+              fields are included by default, but add a small amount of overhead to the data
+              stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+              you trust the network links between your application and the OpenAI API.
+
+          starting_after: The sequence number of the event after which to start streaming.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    async def retrieve(
+        self,
+        response_id: str,
+        *,
+        stream: bool,
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response | AsyncStream[ResponseStreamEvent]:
+        """
+        Retrieves a model response with the given ID.
+
+        Args:
+          stream: If set to true, the model response data will be streamed to the client as it is
+              generated using
+              [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+              See the
+              [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+              for more information.
+
+          include: Additional fields to include in the response. See the `include` parameter for
+              Response creation above for more information.
+
+          include_obfuscation: When true, stream obfuscation will be enabled. Stream obfuscation adds random
+              characters to an `obfuscation` field on streaming delta events to normalize
+              payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+              fields are included by default, but add a small amount of overhead to the data
+              stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+              you trust the network links between your application and the OpenAI API.
+
+          starting_after: The sequence number of the event after which to start streaming.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -1625,6 +2870,23 @@ async def retrieve(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    async def retrieve(
+        self,
+        response_id: str,
+        *,
+        include: List[ResponseIncludable] | Omit = omit,
+        include_obfuscation: bool | Omit = omit,
+        starting_after: int | Omit = omit,
+        stream: Literal[False] | Literal[True] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response | AsyncStream[ResponseStreamEvent]:
         if not response_id:
             raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
         return await self._get(
@@ -1635,10 +2897,18 @@ async def retrieve(
                 extra_body=extra_body,
                 timeout=timeout,
                 query=await async_maybe_transform(
-                    {"include": include}, response_retrieve_params.ResponseRetrieveParams
+                    {
+                        "include": include,
+                        "include_obfuscation": include_obfuscation,
+                        "starting_after": starting_after,
+                        "stream": stream,
+                    },
+                    response_retrieve_params.ResponseRetrieveParams,
                 ),
             ),
             cast_to=Response,
+            stream=stream or False,
+            stream_cls=AsyncStream[ResponseStreamEvent],
         )
 
     async def delete(
@@ -1650,7 +2920,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> None:
         """
         Deletes a model response with the given ID.
@@ -1675,6 +2945,42 @@ async def delete(
             cast_to=NoneType,
         )
 
+    async def cancel(
+        self,
+        response_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Response:
+        """Cancels a model response with the given ID.
+
+        Only responses created with the
+        `background` parameter set to `true` can be cancelled.
+        [Learn more](https://platform.openai.com/docs/guides/background).
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not response_id:
+            raise ValueError(f"Expected a non-empty value for `response_id` but received {response_id!r}")
+        return await self._post(
+            f"/responses/{response_id}/cancel",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Response,
+        )
+
 
 class ResponsesWithRawResponse:
     def __init__(self, responses: Responses) -> None:
@@ -1689,11 +2995,21 @@ def __init__(self, responses: Responses) -> None:
         self.delete = _legacy_response.to_raw_response_wrapper(
             responses.delete,
         )
+        self.cancel = _legacy_response.to_raw_response_wrapper(
+            responses.cancel,
+        )
+        self.parse = _legacy_response.to_raw_response_wrapper(
+            responses.parse,
+        )
 
     @cached_property
     def input_items(self) -> InputItemsWithRawResponse:
         return InputItemsWithRawResponse(self._responses.input_items)
 
+    @cached_property
+    def input_tokens(self) -> InputTokensWithRawResponse:
+        return InputTokensWithRawResponse(self._responses.input_tokens)
+
 
 class AsyncResponsesWithRawResponse:
     def __init__(self, responses: AsyncResponses) -> None:
@@ -1708,11 +3024,21 @@ def __init__(self, responses: AsyncResponses) -> None:
         self.delete = _legacy_response.async_to_raw_response_wrapper(
             responses.delete,
         )
+        self.cancel = _legacy_response.async_to_raw_response_wrapper(
+            responses.cancel,
+        )
+        self.parse = _legacy_response.async_to_raw_response_wrapper(
+            responses.parse,
+        )
 
     @cached_property
     def input_items(self) -> AsyncInputItemsWithRawResponse:
         return AsyncInputItemsWithRawResponse(self._responses.input_items)
 
+    @cached_property
+    def input_tokens(self) -> AsyncInputTokensWithRawResponse:
+        return AsyncInputTokensWithRawResponse(self._responses.input_tokens)
+
 
 class ResponsesWithStreamingResponse:
     def __init__(self, responses: Responses) -> None:
@@ -1727,11 +3053,18 @@ def __init__(self, responses: Responses) -> None:
         self.delete = to_streamed_response_wrapper(
             responses.delete,
         )
+        self.cancel = to_streamed_response_wrapper(
+            responses.cancel,
+        )
 
     @cached_property
     def input_items(self) -> InputItemsWithStreamingResponse:
         return InputItemsWithStreamingResponse(self._responses.input_items)
 
+    @cached_property
+    def input_tokens(self) -> InputTokensWithStreamingResponse:
+        return InputTokensWithStreamingResponse(self._responses.input_tokens)
+
 
 class AsyncResponsesWithStreamingResponse:
     def __init__(self, responses: AsyncResponses) -> None:
@@ -1746,15 +3079,22 @@ def __init__(self, responses: AsyncResponses) -> None:
         self.delete = async_to_streamed_response_wrapper(
             responses.delete,
         )
+        self.cancel = async_to_streamed_response_wrapper(
+            responses.cancel,
+        )
 
     @cached_property
     def input_items(self) -> AsyncInputItemsWithStreamingResponse:
         return AsyncInputItemsWithStreamingResponse(self._responses.input_items)
 
+    @cached_property
+    def input_tokens(self) -> AsyncInputTokensWithStreamingResponse:
+        return AsyncInputTokensWithStreamingResponse(self._responses.input_tokens)
+
 
-def _make_tools(tools: Iterable[ParseableToolParam] | NotGiven) -> List[ToolParam] | NotGiven:
+def _make_tools(tools: Iterable[ParseableToolParam] | Omit) -> List[ToolParam] | Omit:
     if not is_given(tools):
-        return NOT_GIVEN
+        return omit
 
     converted_tools: List[ToolParam] = []
     for tool in tools:
diff --git a/src/openai/resources/uploads/parts.py b/src/openai/resources/uploads/parts.py
index 777469ac8e..73eabd4083 100644
--- a/src/openai/resources/uploads/parts.py
+++ b/src/openai/resources/uploads/parts.py
@@ -7,13 +7,8 @@
 import httpx
 
 from ... import _legacy_response
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from ..._utils import (
-    extract_files,
-    maybe_transform,
-    deepcopy_minimal,
-    async_maybe_transform,
-)
+from ..._types import Body, Query, Headers, NotGiven, FileTypes, not_given
+from ..._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -54,7 +49,7 @@ def create(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> UploadPart:
         """
         Adds a
@@ -129,7 +124,7 @@ async def create(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> UploadPart:
         """
         Adds a
diff --git a/src/openai/resources/uploads/uploads.py b/src/openai/resources/uploads/uploads.py
index 9297dbc2c3..e8c047bd4f 100644
--- a/src/openai/resources/uploads/uploads.py
+++ b/src/openai/resources/uploads/uploads.py
@@ -6,7 +6,7 @@
 import os
 import logging
 import builtins
-from typing import List, overload
+from typing import overload
 from pathlib import Path
 
 import anyio
@@ -22,11 +22,8 @@
     AsyncPartsWithStreamingResponse,
 )
 from ...types import FilePurpose, upload_create_params, upload_complete_params
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ..._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ..._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -76,7 +73,7 @@ def upload_file_chunked(
         purpose: FilePurpose,
         bytes: int | None = None,
         part_size: int | None = None,
-        md5: str | NotGiven = NOT_GIVEN,
+        md5: str | Omit = omit,
     ) -> Upload:
         """Splits a file into multiple 64MB parts and uploads them sequentially."""
 
@@ -90,7 +87,7 @@ def upload_file_chunked(
         mime_type: str,
         purpose: FilePurpose,
         part_size: int | None = None,
-        md5: str | NotGiven = NOT_GIVEN,
+        md5: str | Omit = omit,
     ) -> Upload:
         """Splits an in-memory file into multiple 64MB parts and uploads them sequentially."""
 
@@ -103,7 +100,7 @@ def upload_file_chunked(
         filename: str | None = None,
         bytes: int | None = None,
         part_size: int | None = None,
-        md5: str | NotGiven = NOT_GIVEN,
+        md5: str | Omit = omit,
     ) -> Upload:
         """Splits the given file into multiple parts and uploads them sequentially.
 
@@ -160,9 +157,8 @@ def upload_file_chunked(
                 part = self.parts.create(upload_id=upload.id, data=data)
                 log.info("Uploaded part %s for upload %s", part.id, upload.id)
                 part_ids.append(part.id)
-        except Exception:
+        finally:
             buf.close()
-            raise
 
         return self.complete(upload_id=upload.id, part_ids=part_ids, md5=md5)
 
@@ -173,12 +169,13 @@ def create(
         filename: str,
         mime_type: str,
         purpose: FilePurpose,
+        expires_after: upload_create_params.ExpiresAfter | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Upload:
         """
         Creates an intermediate
@@ -216,6 +213,9 @@ def create(
               See the
               [documentation on File purposes](https://platform.openai.com/docs/api-reference/files/create#files-create-purpose).
 
+          expires_after: The expiration policy for a file. By default, files with `purpose=batch` expire
+              after 30 days and all other files are persisted until they are manually deleted.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -232,6 +232,7 @@ def create(
                     "filename": filename,
                     "mime_type": mime_type,
                     "purpose": purpose,
+                    "expires_after": expires_after,
                 },
                 upload_create_params.UploadCreateParams,
             ),
@@ -250,7 +251,7 @@ def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Upload:
         """Cancels the Upload.
 
@@ -279,14 +280,14 @@ def complete(
         self,
         upload_id: str,
         *,
-        part_ids: List[str],
-        md5: str | NotGiven = NOT_GIVEN,
+        part_ids: SequenceNotStr[str],
+        md5: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Upload:
         """
         Completes the
@@ -368,7 +369,7 @@ async def upload_file_chunked(
         purpose: FilePurpose,
         bytes: int | None = None,
         part_size: int | None = None,
-        md5: str | NotGiven = NOT_GIVEN,
+        md5: str | Omit = omit,
     ) -> Upload:
         """Splits a file into multiple 64MB parts and uploads them sequentially."""
 
@@ -382,7 +383,7 @@ async def upload_file_chunked(
         mime_type: str,
         purpose: FilePurpose,
         part_size: int | None = None,
-        md5: str | NotGiven = NOT_GIVEN,
+        md5: str | Omit = omit,
     ) -> Upload:
         """Splits an in-memory file into multiple 64MB parts and uploads them sequentially."""
 
@@ -395,7 +396,7 @@ async def upload_file_chunked(
         filename: str | None = None,
         bytes: int | None = None,
         part_size: int | None = None,
-        md5: str | NotGiven = NOT_GIVEN,
+        md5: str | Omit = omit,
     ) -> Upload:
         """Splits the given file into multiple parts and uploads them sequentially.
 
@@ -463,9 +464,8 @@ async def upload_file_chunked(
                     part = await self.parts.create(upload_id=upload.id, data=data)
                     log.info("Uploaded part %s for upload %s", part.id, upload.id)
                     part_ids.append(part.id)
-            except Exception:
+            finally:
                 buf.close()
-                raise
 
         return await self.complete(upload_id=upload.id, part_ids=part_ids, md5=md5)
 
@@ -476,12 +476,13 @@ async def create(
         filename: str,
         mime_type: str,
         purpose: FilePurpose,
+        expires_after: upload_create_params.ExpiresAfter | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Upload:
         """
         Creates an intermediate
@@ -519,6 +520,9 @@ async def create(
               See the
               [documentation on File purposes](https://platform.openai.com/docs/api-reference/files/create#files-create-purpose).
 
+          expires_after: The expiration policy for a file. By default, files with `purpose=batch` expire
+              after 30 days and all other files are persisted until they are manually deleted.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -535,6 +539,7 @@ async def create(
                     "filename": filename,
                     "mime_type": mime_type,
                     "purpose": purpose,
+                    "expires_after": expires_after,
                 },
                 upload_create_params.UploadCreateParams,
             ),
@@ -553,7 +558,7 @@ async def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Upload:
         """Cancels the Upload.
 
@@ -582,14 +587,14 @@ async def complete(
         self,
         upload_id: str,
         *,
-        part_ids: List[str],
-        md5: str | NotGiven = NOT_GIVEN,
+        part_ids: SequenceNotStr[str],
+        md5: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> Upload:
         """
         Completes the
diff --git a/src/openai/resources/vector_stores/file_batches.py b/src/openai/resources/vector_stores/file_batches.py
index 9b4b64d35e..d31fb59bec 100644
--- a/src/openai/resources/vector_stores/file_batches.py
+++ b/src/openai/resources/vector_stores/file_batches.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Dict, List, Iterable, Optional
+from typing import Dict, Iterable, Optional
 from typing_extensions import Union, Literal
 from concurrent.futures import Future, ThreadPoolExecutor, as_completed
 
@@ -12,12 +12,8 @@
 
 from ... import _legacy_response
 from ...types import FileChunkingStrategyParam
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from ..._utils import (
-    is_given,
-    maybe_transform,
-    async_maybe_transform,
-)
+from ..._types import Body, Omit, Query, Headers, NotGiven, FileTypes, SequenceNotStr, omit, not_given
+from ..._utils import is_given, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -56,24 +52,21 @@ def create(
         self,
         vector_store_id: str,
         *,
-        file_ids: List[str],
-        attributes: Optional[Dict[str, Union[str, float, bool]]] | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
+        file_ids: SequenceNotStr[str] | Omit = omit,
+        files: Iterable[file_batch_create_params.File] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileBatch:
         """
         Create a vector store file batch.
 
         Args:
-          file_ids: A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
-              the vector store should use. Useful for tools like `file_search` that can access
-              files.
-
           attributes: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard. Keys are strings with a maximum
@@ -83,6 +76,16 @@ def create(
           chunking_strategy: The chunking strategy used to chunk the file(s). If not set, will use the `auto`
               strategy. Only applicable if `file_ids` is non-empty.
 
+          file_ids: A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+              the vector store should use. Useful for tools like `file_search` that can access
+              files. If `attributes` or `chunking_strategy` are provided, they will be applied
+              to all files in the batch. Mutually exclusive with `files`.
+
+          files: A list of objects that each include a `file_id` plus optional `attributes` or
+              `chunking_strategy`. Use this when you need to override metadata for specific
+              files. The global `attributes` or `chunking_strategy` will be ignored and must
+              be specified for each file. Mutually exclusive with `file_ids`.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -98,9 +101,10 @@ def create(
             f"/vector_stores/{vector_store_id}/file_batches",
             body=maybe_transform(
                 {
-                    "file_ids": file_ids,
                     "attributes": attributes,
                     "chunking_strategy": chunking_strategy,
+                    "file_ids": file_ids,
+                    "files": files,
                 },
                 file_batch_create_params.FileBatchCreateParams,
             ),
@@ -120,7 +124,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileBatch:
         """
         Retrieves a vector store file batch.
@@ -157,7 +161,7 @@ def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileBatch:
         """Cancel a vector store file batch.
 
@@ -190,9 +194,9 @@ def create_and_poll(
         self,
         vector_store_id: str,
         *,
-        file_ids: List[str],
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        file_ids: SequenceNotStr[str],
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFileBatch:
         """Create a vector store batch and poll until all files have been processed."""
         batch = self.create(
@@ -212,17 +216,17 @@ def list_files(
         batch_id: str,
         *,
         vector_store_id: str,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        filter: Literal["in_progress", "completed", "failed", "cancelled"] | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        filter: Literal["in_progress", "completed", "failed", "cancelled"] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[VectorStoreFile]:
         """
         Returns a list of vector store files in a batch.
@@ -286,7 +290,7 @@ def poll(
         batch_id: str,
         *,
         vector_store_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        poll_interval_ms: int | Omit = omit,
     ) -> VectorStoreFileBatch:
         """Wait for the given file batch to be processed.
 
@@ -324,9 +328,9 @@ def upload_and_poll(
         *,
         files: Iterable[FileTypes],
         max_concurrency: int = 5,
-        file_ids: List[str] = [],
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        file_ids: SequenceNotStr[str] = [],
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFileBatch:
         """Uploads the given files concurrently and then creates a vector store file batch.
 
@@ -393,24 +397,21 @@ async def create(
         self,
         vector_store_id: str,
         *,
-        file_ids: List[str],
-        attributes: Optional[Dict[str, Union[str, float, bool]]] | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
+        file_ids: SequenceNotStr[str] | Omit = omit,
+        files: Iterable[file_batch_create_params.File] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileBatch:
         """
         Create a vector store file batch.
 
         Args:
-          file_ids: A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
-              the vector store should use. Useful for tools like `file_search` that can access
-              files.
-
           attributes: Set of 16 key-value pairs that can be attached to an object. This can be useful
               for storing additional information about the object in a structured format, and
               querying for objects via API or the dashboard. Keys are strings with a maximum
@@ -420,6 +421,16 @@ async def create(
           chunking_strategy: The chunking strategy used to chunk the file(s). If not set, will use the `auto`
               strategy. Only applicable if `file_ids` is non-empty.
 
+          file_ids: A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+              the vector store should use. Useful for tools like `file_search` that can access
+              files. If `attributes` or `chunking_strategy` are provided, they will be applied
+              to all files in the batch. Mutually exclusive with `files`.
+
+          files: A list of objects that each include a `file_id` plus optional `attributes` or
+              `chunking_strategy`. Use this when you need to override metadata for specific
+              files. The global `attributes` or `chunking_strategy` will be ignored and must
+              be specified for each file. Mutually exclusive with `file_ids`.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -435,9 +446,10 @@ async def create(
             f"/vector_stores/{vector_store_id}/file_batches",
             body=await async_maybe_transform(
                 {
-                    "file_ids": file_ids,
                     "attributes": attributes,
                     "chunking_strategy": chunking_strategy,
+                    "file_ids": file_ids,
+                    "files": files,
                 },
                 file_batch_create_params.FileBatchCreateParams,
             ),
@@ -457,7 +469,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileBatch:
         """
         Retrieves a vector store file batch.
@@ -494,7 +506,7 @@ async def cancel(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileBatch:
         """Cancel a vector store file batch.
 
@@ -527,9 +539,9 @@ async def create_and_poll(
         self,
         vector_store_id: str,
         *,
-        file_ids: List[str],
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        file_ids: SequenceNotStr[str],
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFileBatch:
         """Create a vector store batch and poll until all files have been processed."""
         batch = await self.create(
@@ -549,17 +561,17 @@ def list_files(
         batch_id: str,
         *,
         vector_store_id: str,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        filter: Literal["in_progress", "completed", "failed", "cancelled"] | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        filter: Literal["in_progress", "completed", "failed", "cancelled"] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[VectorStoreFile, AsyncCursorPage[VectorStoreFile]]:
         """
         Returns a list of vector store files in a batch.
@@ -623,7 +635,7 @@ async def poll(
         batch_id: str,
         *,
         vector_store_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        poll_interval_ms: int | Omit = omit,
     ) -> VectorStoreFileBatch:
         """Wait for the given file batch to be processed.
 
@@ -661,9 +673,9 @@ async def upload_and_poll(
         *,
         files: Iterable[FileTypes],
         max_concurrency: int = 5,
-        file_ids: List[str] = [],
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        file_ids: SequenceNotStr[str] = [],
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFileBatch:
         """Uploads the given files concurrently and then creates a vector store file batch.
 
diff --git a/src/openai/resources/vector_stores/files.py b/src/openai/resources/vector_stores/files.py
index 7d93798adf..d2eb4e16ed 100644
--- a/src/openai/resources/vector_stores/files.py
+++ b/src/openai/resources/vector_stores/files.py
@@ -9,12 +9,8 @@
 
 from ... import _legacy_response
 from ...types import FileChunkingStrategyParam
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from ..._utils import (
-    is_given,
-    maybe_transform,
-    async_maybe_transform,
-)
+from ..._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
+from ..._utils import is_given, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -54,14 +50,14 @@ def create(
         vector_store_id: str,
         *,
         file_id: str,
-        attributes: Optional[Dict[str, Union[str, float, bool]]] | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFile:
         """
         Create a vector store file by attaching a
@@ -119,7 +115,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFile:
         """
         Retrieves a vector store file.
@@ -157,7 +153,7 @@ def update(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFile:
         """
         Update attributes on a vector store file.
@@ -195,17 +191,17 @@ def list(
         self,
         vector_store_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        filter: Literal["in_progress", "completed", "failed", "cancelled"] | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        filter: Literal["in_progress", "completed", "failed", "cancelled"] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[VectorStoreFile]:
         """
         Returns a list of vector store files.
@@ -272,7 +268,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileDeleted:
         """Delete a vector store file.
 
@@ -308,11 +304,14 @@ def create_and_poll(
         file_id: str,
         *,
         vector_store_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFile:
         """Attach a file to the given vector store and wait for it to be processed."""
-        self.create(vector_store_id=vector_store_id, file_id=file_id, chunking_strategy=chunking_strategy)
+        self.create(
+            vector_store_id=vector_store_id, file_id=file_id, chunking_strategy=chunking_strategy, attributes=attributes
+        )
 
         return self.poll(
             file_id,
@@ -325,7 +324,7 @@ def poll(
         file_id: str,
         *,
         vector_store_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        poll_interval_ms: int | Omit = omit,
     ) -> VectorStoreFile:
         """Wait for the vector store file to finish processing.
 
@@ -366,7 +365,7 @@ def upload(
         *,
         vector_store_id: str,
         file: FileTypes,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFile:
         """Upload a file to the `files` API and then attach it to the given vector store.
 
@@ -381,8 +380,9 @@ def upload_and_poll(
         *,
         vector_store_id: str,
         file: FileTypes,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFile:
         """Add a file to a vector store and poll until processing is complete."""
         file_obj = self._client.files.create(file=file, purpose="assistants")
@@ -391,6 +391,7 @@ def upload_and_poll(
             file_id=file_obj.id,
             chunking_strategy=chunking_strategy,
             poll_interval_ms=poll_interval_ms,
+            attributes=attributes,
         )
 
     def content(
@@ -403,7 +404,7 @@ def content(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncPage[FileContentResponse]:
         """
         Retrieve the parsed contents of a vector store file.
@@ -457,14 +458,14 @@ async def create(
         vector_store_id: str,
         *,
         file_id: str,
-        attributes: Optional[Dict[str, Union[str, float, bool]]] | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFile:
         """
         Create a vector store file by attaching a
@@ -522,7 +523,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFile:
         """
         Retrieves a vector store file.
@@ -560,7 +561,7 @@ async def update(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFile:
         """
         Update attributes on a vector store file.
@@ -598,17 +599,17 @@ def list(
         self,
         vector_store_id: str,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        filter: Literal["in_progress", "completed", "failed", "cancelled"] | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        filter: Literal["in_progress", "completed", "failed", "cancelled"] | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[VectorStoreFile, AsyncCursorPage[VectorStoreFile]]:
         """
         Returns a list of vector store files.
@@ -675,7 +676,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreFileDeleted:
         """Delete a vector store file.
 
@@ -711,11 +712,14 @@ async def create_and_poll(
         file_id: str,
         *,
         vector_store_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFile:
         """Attach a file to the given vector store and wait for it to be processed."""
-        await self.create(vector_store_id=vector_store_id, file_id=file_id, chunking_strategy=chunking_strategy)
+        await self.create(
+            vector_store_id=vector_store_id, file_id=file_id, chunking_strategy=chunking_strategy, attributes=attributes
+        )
 
         return await self.poll(
             file_id,
@@ -728,7 +732,7 @@ async def poll(
         file_id: str,
         *,
         vector_store_id: str,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
+        poll_interval_ms: int | Omit = omit,
     ) -> VectorStoreFile:
         """Wait for the vector store file to finish processing.
 
@@ -769,7 +773,7 @@ async def upload(
         *,
         vector_store_id: str,
         file: FileTypes,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFile:
         """Upload a file to the `files` API and then attach it to the given vector store.
 
@@ -786,8 +790,9 @@ async def upload_and_poll(
         *,
         vector_store_id: str,
         file: FileTypes,
-        poll_interval_ms: int | NotGiven = NOT_GIVEN,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
+        attributes: Optional[Dict[str, Union[str, float, bool]]] | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
     ) -> VectorStoreFile:
         """Add a file to a vector store and poll until processing is complete."""
         file_obj = await self._client.files.create(file=file, purpose="assistants")
@@ -796,6 +801,7 @@ async def upload_and_poll(
             file_id=file_obj.id,
             poll_interval_ms=poll_interval_ms,
             chunking_strategy=chunking_strategy,
+            attributes=attributes,
         )
 
     def content(
@@ -808,7 +814,7 @@ def content(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[FileContentResponse, AsyncPage[FileContentResponse]]:
         """
         Retrieve the parsed contents of a vector store file.
diff --git a/src/openai/resources/vector_stores/vector_stores.py b/src/openai/resources/vector_stores/vector_stores.py
index aaa6ed2757..490e3e7fdb 100644
--- a/src/openai/resources/vector_stores/vector_stores.py
+++ b/src/openai/resources/vector_stores/vector_stores.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Optional
+from typing import Union, Optional
 from typing_extensions import Literal
 
 import httpx
@@ -23,11 +23,8 @@
     vector_store_search_params,
     vector_store_update_params,
 )
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ..._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from ..._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
@@ -81,17 +78,18 @@ def with_streaming_response(self) -> VectorStoresWithStreamingResponse:
     def create(
         self,
         *,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
-        expires_after: vector_store_create_params.ExpiresAfter | NotGiven = NOT_GIVEN,
-        file_ids: List[str] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        name: str | NotGiven = NOT_GIVEN,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
+        description: str | Omit = omit,
+        expires_after: vector_store_create_params.ExpiresAfter | Omit = omit,
+        file_ids: SequenceNotStr[str] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStore:
         """
         Create a vector store.
@@ -100,6 +98,9 @@ def create(
           chunking_strategy: The chunking strategy used to chunk the file(s). If not set, will use the `auto`
               strategy. Only applicable if `file_ids` is non-empty.
 
+          description: A description for the vector store. Can be used to describe the vector store's
+              purpose.
+
           expires_after: The expiration policy for a vector store.
 
           file_ids: A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
@@ -129,6 +130,7 @@ def create(
             body=maybe_transform(
                 {
                     "chunking_strategy": chunking_strategy,
+                    "description": description,
                     "expires_after": expires_after,
                     "file_ids": file_ids,
                     "metadata": metadata,
@@ -151,7 +153,7 @@ def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStore:
         """
         Retrieves a vector store.
@@ -180,15 +182,15 @@ def update(
         self,
         vector_store_id: str,
         *,
-        expires_after: Optional[vector_store_update_params.ExpiresAfter] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        name: Optional[str] | NotGiven = NOT_GIVEN,
+        expires_after: Optional[vector_store_update_params.ExpiresAfter] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: Optional[str] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStore:
         """
         Modifies a vector store.
@@ -235,16 +237,16 @@ def update(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncCursorPage[VectorStore]:
         """Returns a list of vector stores.
 
@@ -306,7 +308,7 @@ def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreDeleted:
         """
         Delete a vector store.
@@ -335,17 +337,17 @@ def search(
         self,
         vector_store_id: str,
         *,
-        query: Union[str, List[str]],
-        filters: vector_store_search_params.Filters | NotGiven = NOT_GIVEN,
-        max_num_results: int | NotGiven = NOT_GIVEN,
-        ranking_options: vector_store_search_params.RankingOptions | NotGiven = NOT_GIVEN,
-        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        query: Union[str, SequenceNotStr[str]],
+        filters: vector_store_search_params.Filters | Omit = omit,
+        max_num_results: int | Omit = omit,
+        ranking_options: vector_store_search_params.RankingOptions | Omit = omit,
+        rewrite_query: bool | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> SyncPage[VectorStoreSearchResponse]:
         """
         Search a vector store for relevant chunks based on a query and file attributes
@@ -426,17 +428,18 @@ def with_streaming_response(self) -> AsyncVectorStoresWithStreamingResponse:
     async def create(
         self,
         *,
-        chunking_strategy: FileChunkingStrategyParam | NotGiven = NOT_GIVEN,
-        expires_after: vector_store_create_params.ExpiresAfter | NotGiven = NOT_GIVEN,
-        file_ids: List[str] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        name: str | NotGiven = NOT_GIVEN,
+        chunking_strategy: FileChunkingStrategyParam | Omit = omit,
+        description: str | Omit = omit,
+        expires_after: vector_store_create_params.ExpiresAfter | Omit = omit,
+        file_ids: SequenceNotStr[str] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: str | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStore:
         """
         Create a vector store.
@@ -445,6 +448,9 @@ async def create(
           chunking_strategy: The chunking strategy used to chunk the file(s). If not set, will use the `auto`
               strategy. Only applicable if `file_ids` is non-empty.
 
+          description: A description for the vector store. Can be used to describe the vector store's
+              purpose.
+
           expires_after: The expiration policy for a vector store.
 
           file_ids: A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
@@ -474,6 +480,7 @@ async def create(
             body=await async_maybe_transform(
                 {
                     "chunking_strategy": chunking_strategy,
+                    "description": description,
                     "expires_after": expires_after,
                     "file_ids": file_ids,
                     "metadata": metadata,
@@ -496,7 +503,7 @@ async def retrieve(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStore:
         """
         Retrieves a vector store.
@@ -525,15 +532,15 @@ async def update(
         self,
         vector_store_id: str,
         *,
-        expires_after: Optional[vector_store_update_params.ExpiresAfter] | NotGiven = NOT_GIVEN,
-        metadata: Optional[Metadata] | NotGiven = NOT_GIVEN,
-        name: Optional[str] | NotGiven = NOT_GIVEN,
+        expires_after: Optional[vector_store_update_params.ExpiresAfter] | Omit = omit,
+        metadata: Optional[Metadata] | Omit = omit,
+        name: Optional[str] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStore:
         """
         Modifies a vector store.
@@ -580,16 +587,16 @@ async def update(
     def list(
         self,
         *,
-        after: str | NotGiven = NOT_GIVEN,
-        before: str | NotGiven = NOT_GIVEN,
-        limit: int | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[VectorStore, AsyncCursorPage[VectorStore]]:
         """Returns a list of vector stores.
 
@@ -651,7 +658,7 @@ async def delete(
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> VectorStoreDeleted:
         """
         Delete a vector store.
@@ -680,17 +687,17 @@ def search(
         self,
         vector_store_id: str,
         *,
-        query: Union[str, List[str]],
-        filters: vector_store_search_params.Filters | NotGiven = NOT_GIVEN,
-        max_num_results: int | NotGiven = NOT_GIVEN,
-        ranking_options: vector_store_search_params.RankingOptions | NotGiven = NOT_GIVEN,
-        rewrite_query: bool | NotGiven = NOT_GIVEN,
+        query: Union[str, SequenceNotStr[str]],
+        filters: vector_store_search_params.Filters | Omit = omit,
+        max_num_results: int | Omit = omit,
+        ranking_options: vector_store_search_params.RankingOptions | Omit = omit,
+        rewrite_query: bool | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> AsyncPaginator[VectorStoreSearchResponse, AsyncPage[VectorStoreSearchResponse]]:
         """
         Search a vector store for relevant chunks based on a query and file attributes
diff --git a/src/openai/resources/videos.py b/src/openai/resources/videos.py
new file mode 100644
index 0000000000..4df5f02004
--- /dev/null
+++ b/src/openai/resources/videos.py
@@ -0,0 +1,847 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping, cast
+from typing_extensions import Literal, assert_never
+
+import httpx
+
+from .. import _legacy_response
+from ..types import (
+    VideoSize,
+    VideoModel,
+    VideoSeconds,
+    video_list_params,
+    video_remix_params,
+    video_create_params,
+    video_download_content_params,
+)
+from .._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
+from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+    to_streamed_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_custom_streamed_response_wrapper,
+    async_to_custom_streamed_response_wrapper,
+)
+from ..pagination import SyncConversationCursorPage, AsyncConversationCursorPage
+from ..types.video import Video
+from .._base_client import AsyncPaginator, make_request_options
+from .._utils._utils import is_given
+from ..types.video_size import VideoSize
+from ..types.video_model import VideoModel
+from ..types.video_seconds import VideoSeconds
+from ..types.video_delete_response import VideoDeleteResponse
+
+__all__ = ["Videos", "AsyncVideos"]
+
+
+class Videos(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> VideosWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return VideosWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VideosWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return VideosWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        prompt: str,
+        input_reference: FileTypes | Omit = omit,
+        model: VideoModel | Omit = omit,
+        seconds: VideoSeconds | Omit = omit,
+        size: VideoSize | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """
+        Create a video
+
+        Args:
+          prompt: Text prompt that describes the video to generate.
+
+          input_reference: Optional image reference that guides generation.
+
+          model: The video generation model to use. Defaults to `sora-2`.
+
+          seconds: Clip duration in seconds. Defaults to 4 seconds.
+
+          size: Output resolution formatted as width x height. Defaults to 720x1280.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
+            {
+                "prompt": prompt,
+                "input_reference": input_reference,
+                "model": model,
+                "seconds": seconds,
+                "size": size,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["input_reference"]])
+        if files:
+            # It should be noted that the actual Content-Type header that will be
+            # sent to the server will contain a `boundary` parameter, e.g.
+            # multipart/form-data; boundary=---abc--
+            extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return self._post(
+            "/videos",
+            body=maybe_transform(body, video_create_params.VideoCreateParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Video,
+        )
+
+    def create_and_poll(
+        self,
+        *,
+        prompt: str,
+        input_reference: FileTypes | Omit = omit,
+        model: VideoModel | Omit = omit,
+        seconds: VideoSeconds | Omit = omit,
+        size: VideoSize | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """Create a video and wait for it to be processed."""
+        video = self.create(
+            model=model,
+            prompt=prompt,
+            input_reference=input_reference,
+            seconds=seconds,
+            size=size,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+        return self.poll(
+            video.id,
+            poll_interval_ms=poll_interval_ms,
+        )
+
+    def poll(
+        self,
+        video_id: str,
+        *,
+        poll_interval_ms: int | Omit = omit,
+    ) -> Video:
+        """Wait for the vector store file to finish processing.
+
+        Note: this will return even if the file failed to process, you need to check
+        file.last_error and file.status to handle these cases
+        """
+        headers: dict[str, str] = {"X-Stainless-Poll-Helper": "true"}
+        if is_given(poll_interval_ms):
+            headers["X-Stainless-Custom-Poll-Interval"] = str(poll_interval_ms)
+
+        while True:
+            response = self.with_raw_response.retrieve(
+                video_id,
+                extra_headers=headers,
+            )
+
+            video = response.parse()
+            if video.status == "in_progress" or video.status == "queued":
+                if not is_given(poll_interval_ms):
+                    from_header = response.headers.get("openai-poll-after-ms")
+                    if from_header is not None:
+                        poll_interval_ms = int(from_header)
+                    else:
+                        poll_interval_ms = 1000
+
+                self._sleep(poll_interval_ms / 1000)
+            elif video.status == "completed" or video.status == "failed":
+                return video
+            else:
+                if TYPE_CHECKING:  # type: ignore[unreachable]
+                    assert_never(video.status)
+                else:
+                    return video
+
+    def retrieve(
+        self,
+        video_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """
+        Retrieve a video
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        return self._get(
+            f"/videos/{video_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Video,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncConversationCursorPage[Video]:
+        """
+        List videos
+
+        Args:
+          after: Identifier for the last item from the previous pagination request
+
+          limit: Number of items to retrieve
+
+          order: Sort order of results by timestamp. Use `asc` for ascending order or `desc` for
+              descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/videos",
+            page=SyncConversationCursorPage[Video],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    video_list_params.VideoListParams,
+                ),
+            ),
+            model=Video,
+        )
+
+    def delete(
+        self,
+        video_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VideoDeleteResponse:
+        """
+        Delete a video
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        return self._delete(
+            f"/videos/{video_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VideoDeleteResponse,
+        )
+
+    def download_content(
+        self,
+        video_id: str,
+        *,
+        variant: Literal["video", "thumbnail", "spritesheet"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        """Download video content
+
+        Args:
+          variant: Which downloadable asset to return.
+
+        Defaults to the MP4 video.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        return self._get(
+            f"/videos/{video_id}/content",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"variant": variant}, video_download_content_params.VideoDownloadContentParams),
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
+
+    def remix(
+        self,
+        video_id: str,
+        *,
+        prompt: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """
+        Create a video remix
+
+        Args:
+          prompt: Updated text prompt that directs the remix generation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        return self._post(
+            f"/videos/{video_id}/remix",
+            body=maybe_transform({"prompt": prompt}, video_remix_params.VideoRemixParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Video,
+        )
+
+
+class AsyncVideos(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncVideosWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncVideosWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVideosWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncVideosWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        prompt: str,
+        input_reference: FileTypes | Omit = omit,
+        model: VideoModel | Omit = omit,
+        seconds: VideoSeconds | Omit = omit,
+        size: VideoSize | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """
+        Create a video
+
+        Args:
+          prompt: Text prompt that describes the video to generate.
+
+          input_reference: Optional image reference that guides generation.
+
+          model: The video generation model to use. Defaults to `sora-2`.
+
+          seconds: Clip duration in seconds. Defaults to 4 seconds.
+
+          size: Output resolution formatted as width x height. Defaults to 720x1280.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
+            {
+                "prompt": prompt,
+                "input_reference": input_reference,
+                "model": model,
+                "seconds": seconds,
+                "size": size,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["input_reference"]])
+        if files:
+            # It should be noted that the actual Content-Type header that will be
+            # sent to the server will contain a `boundary` parameter, e.g.
+            # multipart/form-data; boundary=---abc--
+            extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            "/videos",
+            body=await async_maybe_transform(body, video_create_params.VideoCreateParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Video,
+        )
+
+    async def create_and_poll(
+        self,
+        *,
+        prompt: str,
+        input_reference: FileTypes | Omit = omit,
+        model: VideoModel | Omit = omit,
+        seconds: VideoSeconds | Omit = omit,
+        size: VideoSize | Omit = omit,
+        poll_interval_ms: int | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """Create a video and wait for it to be processed."""
+        video = await self.create(
+            model=model,
+            prompt=prompt,
+            input_reference=input_reference,
+            seconds=seconds,
+            size=size,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
+        return await self.poll(
+            video.id,
+            poll_interval_ms=poll_interval_ms,
+        )
+
+    async def poll(
+        self,
+        video_id: str,
+        *,
+        poll_interval_ms: int | Omit = omit,
+    ) -> Video:
+        """Wait for the vector store file to finish processing.
+
+        Note: this will return even if the file failed to process, you need to check
+        file.last_error and file.status to handle these cases
+        """
+        headers: dict[str, str] = {"X-Stainless-Poll-Helper": "true"}
+        if is_given(poll_interval_ms):
+            headers["X-Stainless-Custom-Poll-Interval"] = str(poll_interval_ms)
+
+        while True:
+            response = await self.with_raw_response.retrieve(
+                video_id,
+                extra_headers=headers,
+            )
+
+            video = response.parse()
+            if video.status == "in_progress" or video.status == "queued":
+                if not is_given(poll_interval_ms):
+                    from_header = response.headers.get("openai-poll-after-ms")
+                    if from_header is not None:
+                        poll_interval_ms = int(from_header)
+                    else:
+                        poll_interval_ms = 1000
+
+                await self._sleep(poll_interval_ms / 1000)
+            elif video.status == "completed" or video.status == "failed":
+                return video
+            else:
+                if TYPE_CHECKING:  # type: ignore[unreachable]
+                    assert_never(video.status)
+                else:
+                    return video
+
+    async def retrieve(
+        self,
+        video_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """
+        Retrieve a video
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        return await self._get(
+            f"/videos/{video_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Video,
+        )
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        limit: int | Omit = omit,
+        order: Literal["asc", "desc"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[Video, AsyncConversationCursorPage[Video]]:
+        """
+        List videos
+
+        Args:
+          after: Identifier for the last item from the previous pagination request
+
+          limit: Number of items to retrieve
+
+          order: Sort order of results by timestamp. Use `asc` for ascending order or `desc` for
+              descending order.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/videos",
+            page=AsyncConversationCursorPage[Video],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "limit": limit,
+                        "order": order,
+                    },
+                    video_list_params.VideoListParams,
+                ),
+            ),
+            model=Video,
+        )
+
+    async def delete(
+        self,
+        video_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> VideoDeleteResponse:
+        """
+        Delete a video
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        return await self._delete(
+            f"/videos/{video_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=VideoDeleteResponse,
+        )
+
+    async def download_content(
+        self,
+        video_id: str,
+        *,
+        variant: Literal["video", "thumbnail", "spritesheet"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> _legacy_response.HttpxBinaryResponseContent:
+        """Download video content
+
+        Args:
+          variant: Which downloadable asset to return.
+
+        Defaults to the MP4 video.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        return await self._get(
+            f"/videos/{video_id}/content",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"variant": variant}, video_download_content_params.VideoDownloadContentParams
+                ),
+            ),
+            cast_to=_legacy_response.HttpxBinaryResponseContent,
+        )
+
+    async def remix(
+        self,
+        video_id: str,
+        *,
+        prompt: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Video:
+        """
+        Create a video remix
+
+        Args:
+          prompt: Updated text prompt that directs the remix generation.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not video_id:
+            raise ValueError(f"Expected a non-empty value for `video_id` but received {video_id!r}")
+        return await self._post(
+            f"/videos/{video_id}/remix",
+            body=await async_maybe_transform({"prompt": prompt}, video_remix_params.VideoRemixParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Video,
+        )
+
+
+class VideosWithRawResponse:
+    def __init__(self, videos: Videos) -> None:
+        self._videos = videos
+
+        self.create = _legacy_response.to_raw_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = _legacy_response.to_raw_response_wrapper(
+            videos.retrieve,
+        )
+        self.list = _legacy_response.to_raw_response_wrapper(
+            videos.list,
+        )
+        self.delete = _legacy_response.to_raw_response_wrapper(
+            videos.delete,
+        )
+        self.download_content = _legacy_response.to_raw_response_wrapper(
+            videos.download_content,
+        )
+        self.remix = _legacy_response.to_raw_response_wrapper(
+            videos.remix,
+        )
+
+
+class AsyncVideosWithRawResponse:
+    def __init__(self, videos: AsyncVideos) -> None:
+        self._videos = videos
+
+        self.create = _legacy_response.async_to_raw_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = _legacy_response.async_to_raw_response_wrapper(
+            videos.retrieve,
+        )
+        self.list = _legacy_response.async_to_raw_response_wrapper(
+            videos.list,
+        )
+        self.delete = _legacy_response.async_to_raw_response_wrapper(
+            videos.delete,
+        )
+        self.download_content = _legacy_response.async_to_raw_response_wrapper(
+            videos.download_content,
+        )
+        self.remix = _legacy_response.async_to_raw_response_wrapper(
+            videos.remix,
+        )
+
+
+class VideosWithStreamingResponse:
+    def __init__(self, videos: Videos) -> None:
+        self._videos = videos
+
+        self.create = to_streamed_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            videos.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            videos.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            videos.delete,
+        )
+        self.download_content = to_custom_streamed_response_wrapper(
+            videos.download_content,
+            StreamedBinaryAPIResponse,
+        )
+        self.remix = to_streamed_response_wrapper(
+            videos.remix,
+        )
+
+
+class AsyncVideosWithStreamingResponse:
+    def __init__(self, videos: AsyncVideos) -> None:
+        self._videos = videos
+
+        self.create = async_to_streamed_response_wrapper(
+            videos.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            videos.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            videos.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            videos.delete,
+        )
+        self.download_content = async_to_custom_streamed_response_wrapper(
+            videos.download_content,
+            AsyncStreamedBinaryAPIResponse,
+        )
+        self.remix = async_to_streamed_response_wrapper(
+            videos.remix,
+        )
diff --git a/src/openai/resources/webhooks.py b/src/openai/resources/webhooks.py
new file mode 100644
index 0000000000..3e13d3faae
--- /dev/null
+++ b/src/openai/resources/webhooks.py
@@ -0,0 +1,210 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import hmac
+import json
+import time
+import base64
+import hashlib
+from typing import cast
+
+from .._types import HeadersLike
+from .._utils import get_required_header
+from .._models import construct_type
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._exceptions import InvalidWebhookSignatureError
+from ..types.webhooks.unwrap_webhook_event import UnwrapWebhookEvent
+
+__all__ = ["Webhooks", "AsyncWebhooks"]
+
+
+class Webhooks(SyncAPIResource):
+    def unwrap(
+        self,
+        payload: str | bytes,
+        headers: HeadersLike,
+        *,
+        secret: str | None = None,
+    ) -> UnwrapWebhookEvent:
+        """Validates that the given payload was sent by OpenAI and parses the payload."""
+        if secret is None:
+            secret = self._client.webhook_secret
+
+        self.verify_signature(payload=payload, headers=headers, secret=secret)
+
+        return cast(
+            UnwrapWebhookEvent,
+            construct_type(
+                type_=UnwrapWebhookEvent,
+                value=json.loads(payload),
+            ),
+        )
+
+    def verify_signature(
+        self,
+        payload: str | bytes,
+        headers: HeadersLike,
+        *,
+        secret: str | None = None,
+        tolerance: int = 300,
+    ) -> None:
+        """Validates whether or not the webhook payload was sent by OpenAI.
+
+        Args:
+            payload: The webhook payload
+            headers: The webhook headers
+            secret: The webhook secret (optional, will use client secret if not provided)
+            tolerance: Maximum age of the webhook in seconds (default: 300 = 5 minutes)
+        """
+        if secret is None:
+            secret = self._client.webhook_secret
+
+        if secret is None:
+            raise ValueError(
+                "The webhook secret must either be set using the env var, OPENAI_WEBHOOK_SECRET, "
+                "on the client class, OpenAI(webhook_secret='123'), or passed to this function"
+            )
+
+        signature_header = get_required_header(headers, "webhook-signature")
+        timestamp = get_required_header(headers, "webhook-timestamp")
+        webhook_id = get_required_header(headers, "webhook-id")
+
+        # Validate timestamp to prevent replay attacks
+        try:
+            timestamp_seconds = int(timestamp)
+        except ValueError:
+            raise InvalidWebhookSignatureError("Invalid webhook timestamp format") from None
+
+        now = int(time.time())
+
+        if now - timestamp_seconds > tolerance:
+            raise InvalidWebhookSignatureError("Webhook timestamp is too old") from None
+
+        if timestamp_seconds > now + tolerance:
+            raise InvalidWebhookSignatureError("Webhook timestamp is too new") from None
+
+        # Extract signatures from v1,<base64> format
+        # The signature header can have multiple values, separated by spaces.
+        # Each value is in the format v1,<base64>. We should accept if any match.
+        signatures: list[str] = []
+        for part in signature_header.split():
+            if part.startswith("v1,"):
+                signatures.append(part[3:])
+            else:
+                signatures.append(part)
+
+        # Decode the secret if it starts with whsec_
+        if secret.startswith("whsec_"):
+            decoded_secret = base64.b64decode(secret[6:])
+        else:
+            decoded_secret = secret.encode()
+
+        body = payload.decode("utf-8") if isinstance(payload, bytes) else payload
+
+        # Prepare the signed payload (OpenAI uses webhookId.timestamp.payload format)
+        signed_payload = f"{webhook_id}.{timestamp}.{body}"
+        expected_signature = base64.b64encode(
+            hmac.new(decoded_secret, signed_payload.encode(), hashlib.sha256).digest()
+        ).decode()
+
+        # Accept if any signature matches
+        if not any(hmac.compare_digest(expected_signature, sig) for sig in signatures):
+            raise InvalidWebhookSignatureError(
+                "The given webhook signature does not match the expected signature"
+            ) from None
+
+
+class AsyncWebhooks(AsyncAPIResource):
+    def unwrap(
+        self,
+        payload: str | bytes,
+        headers: HeadersLike,
+        *,
+        secret: str | None = None,
+    ) -> UnwrapWebhookEvent:
+        """Validates that the given payload was sent by OpenAI and parses the payload."""
+        if secret is None:
+            secret = self._client.webhook_secret
+
+        self.verify_signature(payload=payload, headers=headers, secret=secret)
+
+        body = payload.decode("utf-8") if isinstance(payload, bytes) else payload
+        return cast(
+            UnwrapWebhookEvent,
+            construct_type(
+                type_=UnwrapWebhookEvent,
+                value=json.loads(body),
+            ),
+        )
+
+    def verify_signature(
+        self,
+        payload: str | bytes,
+        headers: HeadersLike,
+        *,
+        secret: str | None = None,
+        tolerance: int = 300,
+    ) -> None:
+        """Validates whether or not the webhook payload was sent by OpenAI.
+
+        Args:
+            payload: The webhook payload
+            headers: The webhook headers
+            secret: The webhook secret (optional, will use client secret if not provided)
+            tolerance: Maximum age of the webhook in seconds (default: 300 = 5 minutes)
+        """
+        if secret is None:
+            secret = self._client.webhook_secret
+
+        if secret is None:
+            raise ValueError(
+                "The webhook secret must either be set using the env var, OPENAI_WEBHOOK_SECRET, "
+                "on the client class, OpenAI(webhook_secret='123'), or passed to this function"
+            ) from None
+
+        signature_header = get_required_header(headers, "webhook-signature")
+        timestamp = get_required_header(headers, "webhook-timestamp")
+        webhook_id = get_required_header(headers, "webhook-id")
+
+        # Validate timestamp to prevent replay attacks
+        try:
+            timestamp_seconds = int(timestamp)
+        except ValueError:
+            raise InvalidWebhookSignatureError("Invalid webhook timestamp format") from None
+
+        now = int(time.time())
+
+        if now - timestamp_seconds > tolerance:
+            raise InvalidWebhookSignatureError("Webhook timestamp is too old") from None
+
+        if timestamp_seconds > now + tolerance:
+            raise InvalidWebhookSignatureError("Webhook timestamp is too new") from None
+
+        # Extract signatures from v1,<base64> format
+        # The signature header can have multiple values, separated by spaces.
+        # Each value is in the format v1,<base64>. We should accept if any match.
+        signatures: list[str] = []
+        for part in signature_header.split():
+            if part.startswith("v1,"):
+                signatures.append(part[3:])
+            else:
+                signatures.append(part)
+
+        # Decode the secret if it starts with whsec_
+        if secret.startswith("whsec_"):
+            decoded_secret = base64.b64decode(secret[6:])
+        else:
+            decoded_secret = secret.encode()
+
+        body = payload.decode("utf-8") if isinstance(payload, bytes) else payload
+
+        # Prepare the signed payload (OpenAI uses webhookId.timestamp.payload format)
+        signed_payload = f"{webhook_id}.{timestamp}.{body}"
+        expected_signature = base64.b64encode(
+            hmac.new(decoded_secret, signed_payload.encode(), hashlib.sha256).digest()
+        ).decode()
+
+        # Accept if any signature matches
+        if not any(hmac.compare_digest(expected_signature, sig) for sig in signatures):
+            raise InvalidWebhookSignatureError("The given webhook signature does not match the expected signature")
diff --git a/src/openai/types/__init__.py b/src/openai/types/__init__.py
index 4c337d41c7..a98ca16ee9 100644
--- a/src/openai/types/__init__.py
+++ b/src/openai/types/__init__.py
@@ -5,72 +5,111 @@
 from .batch import Batch as Batch
 from .image import Image as Image
 from .model import Model as Model
+from .video import Video as Video
 from .shared import (
     Metadata as Metadata,
+    AllModels as AllModels,
     ChatModel as ChatModel,
     Reasoning as Reasoning,
     ErrorObject as ErrorObject,
     CompoundFilter as CompoundFilter,
+    ResponsesModel as ResponsesModel,
     ReasoningEffort as ReasoningEffort,
     ComparisonFilter as ComparisonFilter,
     FunctionDefinition as FunctionDefinition,
     FunctionParameters as FunctionParameters,
     ResponseFormatText as ResponseFormatText,
+    CustomToolInputFormat as CustomToolInputFormat,
     ResponseFormatJSONObject as ResponseFormatJSONObject,
     ResponseFormatJSONSchema as ResponseFormatJSONSchema,
+    ResponseFormatTextPython as ResponseFormatTextPython,
+    ResponseFormatTextGrammar as ResponseFormatTextGrammar,
 )
 from .upload import Upload as Upload
 from .embedding import Embedding as Embedding
 from .chat_model import ChatModel as ChatModel
 from .completion import Completion as Completion
 from .moderation import Moderation as Moderation
+from .video_size import VideoSize as VideoSize
 from .audio_model import AudioModel as AudioModel
 from .batch_error import BatchError as BatchError
+from .batch_usage import BatchUsage as BatchUsage
 from .file_object import FileObject as FileObject
 from .image_model import ImageModel as ImageModel
+from .video_model import VideoModel as VideoModel
 from .file_content import FileContent as FileContent
 from .file_deleted import FileDeleted as FileDeleted
 from .file_purpose import FilePurpose as FilePurpose
 from .vector_store import VectorStore as VectorStore
 from .model_deleted import ModelDeleted as ModelDeleted
+from .video_seconds import VideoSeconds as VideoSeconds
 from .embedding_model import EmbeddingModel as EmbeddingModel
 from .images_response import ImagesResponse as ImagesResponse
 from .completion_usage import CompletionUsage as CompletionUsage
+from .eval_list_params import EvalListParams as EvalListParams
 from .file_list_params import FileListParams as FileListParams
 from .moderation_model import ModerationModel as ModerationModel
 from .batch_list_params import BatchListParams as BatchListParams
 from .completion_choice import CompletionChoice as CompletionChoice
 from .image_edit_params import ImageEditParams as ImageEditParams
+from .video_list_params import VideoListParams as VideoListParams
+from .eval_create_params import EvalCreateParams as EvalCreateParams
+from .eval_list_response import EvalListResponse as EvalListResponse
+from .eval_update_params import EvalUpdateParams as EvalUpdateParams
 from .file_create_params import FileCreateParams as FileCreateParams
+from .video_create_error import VideoCreateError as VideoCreateError
+from .video_remix_params import VideoRemixParams as VideoRemixParams
 from .batch_create_params import BatchCreateParams as BatchCreateParams
+from .video_create_params import VideoCreateParams as VideoCreateParams
 from .batch_request_counts import BatchRequestCounts as BatchRequestCounts
+from .eval_create_response import EvalCreateResponse as EvalCreateResponse
+from .eval_delete_response import EvalDeleteResponse as EvalDeleteResponse
+from .eval_update_response import EvalUpdateResponse as EvalUpdateResponse
 from .upload_create_params import UploadCreateParams as UploadCreateParams
 from .vector_store_deleted import VectorStoreDeleted as VectorStoreDeleted
 from .audio_response_format import AudioResponseFormat as AudioResponseFormat
+from .container_list_params import ContainerListParams as ContainerListParams
 from .image_generate_params import ImageGenerateParams as ImageGenerateParams
+from .video_delete_response import VideoDeleteResponse as VideoDeleteResponse
+from .eval_retrieve_response import EvalRetrieveResponse as EvalRetrieveResponse
 from .file_chunking_strategy import FileChunkingStrategy as FileChunkingStrategy
+from .image_gen_stream_event import ImageGenStreamEvent as ImageGenStreamEvent
 from .upload_complete_params import UploadCompleteParams as UploadCompleteParams
+from .container_create_params import ContainerCreateParams as ContainerCreateParams
+from .container_list_response import ContainerListResponse as ContainerListResponse
 from .embedding_create_params import EmbeddingCreateParams as EmbeddingCreateParams
+from .image_edit_stream_event import ImageEditStreamEvent as ImageEditStreamEvent
 from .completion_create_params import CompletionCreateParams as CompletionCreateParams
 from .moderation_create_params import ModerationCreateParams as ModerationCreateParams
 from .vector_store_list_params import VectorStoreListParams as VectorStoreListParams
+from .container_create_response import ContainerCreateResponse as ContainerCreateResponse
 from .create_embedding_response import CreateEmbeddingResponse as CreateEmbeddingResponse
+from .image_gen_completed_event import ImageGenCompletedEvent as ImageGenCompletedEvent
+from .image_edit_completed_event import ImageEditCompletedEvent as ImageEditCompletedEvent
 from .moderation_create_response import ModerationCreateResponse as ModerationCreateResponse
 from .vector_store_create_params import VectorStoreCreateParams as VectorStoreCreateParams
 from .vector_store_search_params import VectorStoreSearchParams as VectorStoreSearchParams
 from .vector_store_update_params import VectorStoreUpdateParams as VectorStoreUpdateParams
+from .container_retrieve_response import ContainerRetrieveResponse as ContainerRetrieveResponse
 from .moderation_text_input_param import ModerationTextInputParam as ModerationTextInputParam
 from .file_chunking_strategy_param import FileChunkingStrategyParam as FileChunkingStrategyParam
 from .vector_store_search_response import VectorStoreSearchResponse as VectorStoreSearchResponse
 from .websocket_connection_options import WebsocketConnectionOptions as WebsocketConnectionOptions
 from .image_create_variation_params import ImageCreateVariationParams as ImageCreateVariationParams
+from .image_gen_partial_image_event import ImageGenPartialImageEvent as ImageGenPartialImageEvent
 from .static_file_chunking_strategy import StaticFileChunkingStrategy as StaticFileChunkingStrategy
+from .video_download_content_params import VideoDownloadContentParams as VideoDownloadContentParams
+from .eval_custom_data_source_config import EvalCustomDataSourceConfig as EvalCustomDataSourceConfig
+from .image_edit_partial_image_event import ImageEditPartialImageEvent as ImageEditPartialImageEvent
 from .moderation_image_url_input_param import ModerationImageURLInputParam as ModerationImageURLInputParam
 from .auto_file_chunking_strategy_param import AutoFileChunkingStrategyParam as AutoFileChunkingStrategyParam
 from .moderation_multi_modal_input_param import ModerationMultiModalInputParam as ModerationMultiModalInputParam
 from .other_file_chunking_strategy_object import OtherFileChunkingStrategyObject as OtherFileChunkingStrategyObject
 from .static_file_chunking_strategy_param import StaticFileChunkingStrategyParam as StaticFileChunkingStrategyParam
 from .static_file_chunking_strategy_object import StaticFileChunkingStrategyObject as StaticFileChunkingStrategyObject
+from .eval_stored_completions_data_source_config import (
+    EvalStoredCompletionsDataSourceConfig as EvalStoredCompletionsDataSourceConfig,
+)
 from .static_file_chunking_strategy_object_param import (
     StaticFileChunkingStrategyObjectParam as StaticFileChunkingStrategyObjectParam,
 )
diff --git a/src/openai/types/audio/__init__.py b/src/openai/types/audio/__init__.py
index 822e0f3a8d..2ff2b8185d 100644
--- a/src/openai/types/audio/__init__.py
+++ b/src/openai/types/audio/__init__.py
@@ -8,9 +8,16 @@
 from .transcription_word import TranscriptionWord as TranscriptionWord
 from .translation_verbose import TranslationVerbose as TranslationVerbose
 from .speech_create_params import SpeechCreateParams as SpeechCreateParams
+from .transcription_include import TranscriptionInclude as TranscriptionInclude
 from .transcription_segment import TranscriptionSegment as TranscriptionSegment
 from .transcription_verbose import TranscriptionVerbose as TranscriptionVerbose
+from .transcription_diarized import TranscriptionDiarized as TranscriptionDiarized
 from .translation_create_params import TranslationCreateParams as TranslationCreateParams
+from .transcription_stream_event import TranscriptionStreamEvent as TranscriptionStreamEvent
 from .transcription_create_params import TranscriptionCreateParams as TranscriptionCreateParams
 from .translation_create_response import TranslationCreateResponse as TranslationCreateResponse
 from .transcription_create_response import TranscriptionCreateResponse as TranscriptionCreateResponse
+from .transcription_text_done_event import TranscriptionTextDoneEvent as TranscriptionTextDoneEvent
+from .transcription_diarized_segment import TranscriptionDiarizedSegment as TranscriptionDiarizedSegment
+from .transcription_text_delta_event import TranscriptionTextDeltaEvent as TranscriptionTextDeltaEvent
+from .transcription_text_segment_event import TranscriptionTextSegmentEvent as TranscriptionTextSegmentEvent
diff --git a/src/openai/types/audio/speech_create_params.py b/src/openai/types/audio/speech_create_params.py
index ed1a1ce748..634d788191 100644
--- a/src/openai/types/audio/speech_create_params.py
+++ b/src/openai/types/audio/speech_create_params.py
@@ -17,17 +17,26 @@ class SpeechCreateParams(TypedDict, total=False):
     model: Required[Union[str, SpeechModel]]
     """
     One of the available [TTS models](https://platform.openai.com/docs/models#tts):
-    `tts-1` or `tts-1-hd`
+    `tts-1`, `tts-1-hd` or `gpt-4o-mini-tts`.
     """
 
-    voice: Required[Literal["alloy", "ash", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer"]]
+    voice: Required[
+        Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"]]
+    ]
     """The voice to use when generating the audio.
 
-    Supported voices are `alloy`, `ash`, `coral`, `echo`, `fable`, `onyx`, `nova`,
-    `sage` and `shimmer`. Previews of the voices are available in the
+    Supported voices are `alloy`, `ash`, `ballad`, `coral`, `echo`, `fable`, `onyx`,
+    `nova`, `sage`, `shimmer`, and `verse`. Previews of the voices are available in
+    the
     [Text to speech guide](https://platform.openai.com/docs/guides/text-to-speech#voice-options).
     """
 
+    instructions: str
+    """Control the voice of your generated audio with additional instructions.
+
+    Does not work with `tts-1` or `tts-1-hd`.
+    """
+
     response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"]
     """The format to audio in.
 
@@ -39,3 +48,10 @@ class SpeechCreateParams(TypedDict, total=False):
 
     Select a value from `0.25` to `4.0`. `1.0` is the default.
     """
+
+    stream_format: Literal["sse", "audio"]
+    """The format to stream the audio in.
+
+    Supported formats are `sse` and `audio`. `sse` is not supported for `tts-1` or
+    `tts-1-hd`.
+    """
diff --git a/src/openai/types/audio/speech_model.py b/src/openai/types/audio/speech_model.py
index bd685ab34d..f004f805da 100644
--- a/src/openai/types/audio/speech_model.py
+++ b/src/openai/types/audio/speech_model.py
@@ -4,4 +4,4 @@
 
 __all__ = ["SpeechModel"]
 
-SpeechModel: TypeAlias = Literal["tts-1", "tts-1-hd"]
+SpeechModel: TypeAlias = Literal["tts-1", "tts-1-hd", "gpt-4o-mini-tts"]
diff --git a/src/openai/types/audio/transcription.py b/src/openai/types/audio/transcription.py
index edb5f227fc..4c5882152d 100644
--- a/src/openai/types/audio/transcription.py
+++ b/src/openai/types/audio/transcription.py
@@ -1,11 +1,71 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
 
+from ..._utils import PropertyInfo
 from ..._models import BaseModel
 
-__all__ = ["Transcription"]
+__all__ = ["Transcription", "Logprob", "Usage", "UsageTokens", "UsageTokensInputTokenDetails", "UsageDuration"]
+
+
+class Logprob(BaseModel):
+    token: Optional[str] = None
+    """The token in the transcription."""
+
+    bytes: Optional[List[float]] = None
+    """The bytes of the token."""
+
+    logprob: Optional[float] = None
+    """The log probability of the token."""
+
+
+class UsageTokensInputTokenDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """Number of audio tokens billed for this request."""
+
+    text_tokens: Optional[int] = None
+    """Number of text tokens billed for this request."""
+
+
+class UsageTokens(BaseModel):
+    input_tokens: int
+    """Number of input tokens billed for this request."""
+
+    output_tokens: int
+    """Number of output tokens generated."""
+
+    total_tokens: int
+    """Total number of tokens used (input + output)."""
+
+    type: Literal["tokens"]
+    """The type of the usage object. Always `tokens` for this variant."""
+
+    input_token_details: Optional[UsageTokensInputTokenDetails] = None
+    """Details about the input tokens billed for this request."""
+
+
+class UsageDuration(BaseModel):
+    seconds: float
+    """Duration of the input audio in seconds."""
+
+    type: Literal["duration"]
+    """The type of the usage object. Always `duration` for this variant."""
+
+
+Usage: TypeAlias = Annotated[Union[UsageTokens, UsageDuration], PropertyInfo(discriminator="type")]
 
 
 class Transcription(BaseModel):
     text: str
     """The transcribed text."""
+
+    logprobs: Optional[List[Logprob]] = None
+    """The log probabilities of the tokens in the transcription.
+
+    Only returned with the models `gpt-4o-transcribe` and `gpt-4o-mini-transcribe`
+    if `logprobs` is added to the `include` array.
+    """
+
+    usage: Optional[Usage] = None
+    """Token usage statistics for the request."""
diff --git a/src/openai/types/audio/transcription_create_params.py b/src/openai/types/audio/transcription_create_params.py
index f1779c35e6..adaef9f5fe 100644
--- a/src/openai/types/audio/transcription_create_params.py
+++ b/src/openai/types/audio/transcription_create_params.py
@@ -2,17 +2,24 @@
 
 from __future__ import annotations
 
-from typing import List, Union
-from typing_extensions import Literal, Required, TypedDict
+from typing import List, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
-from ..._types import FileTypes
+from ..._types import FileTypes, SequenceNotStr
 from ..audio_model import AudioModel
+from .transcription_include import TranscriptionInclude
 from ..audio_response_format import AudioResponseFormat
 
-__all__ = ["TranscriptionCreateParams"]
+__all__ = [
+    "TranscriptionCreateParamsBase",
+    "ChunkingStrategy",
+    "ChunkingStrategyVadConfig",
+    "TranscriptionCreateParamsNonStreaming",
+    "TranscriptionCreateParamsStreaming",
+]
 
 
-class TranscriptionCreateParams(TypedDict, total=False):
+class TranscriptionCreateParamsBase(TypedDict, total=False):
     file: Required[FileTypes]
     """
     The audio file object (not file name) to transcribe, in one of these formats:
@@ -22,8 +29,45 @@ class TranscriptionCreateParams(TypedDict, total=False):
     model: Required[Union[str, AudioModel]]
     """ID of the model to use.
 
-    Only `whisper-1` (which is powered by our open source Whisper V2 model) is
-    currently available.
+    The options are `gpt-4o-transcribe`, `gpt-4o-mini-transcribe`, `whisper-1`
+    (which is powered by our open source Whisper V2 model), and
+    `gpt-4o-transcribe-diarize`.
+    """
+
+    chunking_strategy: Optional[ChunkingStrategy]
+    """Controls how the audio is cut into chunks.
+
+    When set to `"auto"`, the server first normalizes loudness and then uses voice
+    activity detection (VAD) to choose boundaries. `server_vad` object can be
+    provided to tweak VAD detection parameters manually. If unset, the audio is
+    transcribed as a single block. Required when using `gpt-4o-transcribe-diarize`
+    for inputs longer than 30 seconds.
+    """
+
+    include: List[TranscriptionInclude]
+    """
+    Additional information to include in the transcription response. `logprobs` will
+    return the log probabilities of the tokens in the response to understand the
+    model's confidence in the transcription. `logprobs` only works with
+    response_format set to `json` and only with the models `gpt-4o-transcribe` and
+    `gpt-4o-mini-transcribe`. This field is not supported when using
+    `gpt-4o-transcribe-diarize`.
+    """
+
+    known_speaker_names: SequenceNotStr[str]
+    """
+    Optional list of speaker names that correspond to the audio samples provided in
+    `known_speaker_references[]`. Each entry should be a short identifier (for
+    example `customer` or `agent`). Up to 4 speakers are supported.
+    """
+
+    known_speaker_references: SequenceNotStr[str]
+    """
+    Optional list of audio samples (as
+    [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs))
+    that contain known speaker references matching `known_speaker_names[]`. Each
+    sample must be between 2 and 10 seconds, and can use any of the same input audio
+    formats supported by `file`.
     """
 
     language: str
@@ -39,13 +83,17 @@ class TranscriptionCreateParams(TypedDict, total=False):
     segment.
 
     The [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-    should match the audio language.
+    should match the audio language. This field is not supported when using
+    `gpt-4o-transcribe-diarize`.
     """
 
     response_format: AudioResponseFormat
     """
     The format of the output, in one of these options: `json`, `text`, `srt`,
-    `verbose_json`, or `vtt`.
+    `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+    `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+    `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+    `diarized_json`, with `diarized_json` required to receive speaker annotations.
     """
 
     temperature: float
@@ -63,5 +111,62 @@ class TranscriptionCreateParams(TypedDict, total=False):
     `response_format` must be set `verbose_json` to use timestamp granularities.
     Either or both of these options are supported: `word`, or `segment`. Note: There
     is no additional latency for segment timestamps, but generating word timestamps
-    incurs additional latency.
+    incurs additional latency. This option is not available for
+    `gpt-4o-transcribe-diarize`.
+    """
+
+
+class ChunkingStrategyVadConfig(TypedDict, total=False):
+    type: Required[Literal["server_vad"]]
+    """Must be set to `server_vad` to enable manual chunking using server side VAD."""
+
+    prefix_padding_ms: int
+    """Amount of audio to include before the VAD detected speech (in milliseconds)."""
+
+    silence_duration_ms: int
     """
+    Duration of silence to detect speech stop (in milliseconds). With shorter values
+    the model will respond more quickly, but may jump in on short pauses from the
+    user.
+    """
+
+    threshold: float
+    """Sensitivity threshold (0.0 to 1.0) for voice activity detection.
+
+    A higher threshold will require louder audio to activate the model, and thus
+    might perform better in noisy environments.
+    """
+
+
+ChunkingStrategy: TypeAlias = Union[Literal["auto"], ChunkingStrategyVadConfig]
+
+
+class TranscriptionCreateParamsNonStreaming(TranscriptionCreateParamsBase, total=False):
+    stream: Optional[Literal[False]]
+    """
+    If set to true, the model response data will be streamed to the client as it is
+    generated using
+    [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+    See the
+    [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+    for more information.
+
+    Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+    """
+
+
+class TranscriptionCreateParamsStreaming(TranscriptionCreateParamsBase):
+    stream: Required[Literal[True]]
+    """
+    If set to true, the model response data will be streamed to the client as it is
+    generated using
+    [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+    See the
+    [Streaming section of the Speech-to-Text guide](https://platform.openai.com/docs/guides/speech-to-text?lang=curl#streaming-transcriptions)
+    for more information.
+
+    Note: Streaming is not supported for the `whisper-1` model and will be ignored.
+    """
+
+
+TranscriptionCreateParams = Union[TranscriptionCreateParamsNonStreaming, TranscriptionCreateParamsStreaming]
diff --git a/src/openai/types/audio/transcription_create_response.py b/src/openai/types/audio/transcription_create_response.py
index 2f7bed8114..5717a3e701 100644
--- a/src/openai/types/audio/transcription_create_response.py
+++ b/src/openai/types/audio/transcription_create_response.py
@@ -5,7 +5,8 @@
 
 from .transcription import Transcription
 from .transcription_verbose import TranscriptionVerbose
+from .transcription_diarized import TranscriptionDiarized
 
 __all__ = ["TranscriptionCreateResponse"]
 
-TranscriptionCreateResponse: TypeAlias = Union[Transcription, TranscriptionVerbose]
+TranscriptionCreateResponse: TypeAlias = Union[Transcription, TranscriptionDiarized, TranscriptionVerbose]
diff --git a/src/openai/types/audio/transcription_diarized.py b/src/openai/types/audio/transcription_diarized.py
new file mode 100644
index 0000000000..b7dd2b8ebb
--- /dev/null
+++ b/src/openai/types/audio/transcription_diarized.py
@@ -0,0 +1,63 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .transcription_diarized_segment import TranscriptionDiarizedSegment
+
+__all__ = ["TranscriptionDiarized", "Usage", "UsageTokens", "UsageTokensInputTokenDetails", "UsageDuration"]
+
+
+class UsageTokensInputTokenDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """Number of audio tokens billed for this request."""
+
+    text_tokens: Optional[int] = None
+    """Number of text tokens billed for this request."""
+
+
+class UsageTokens(BaseModel):
+    input_tokens: int
+    """Number of input tokens billed for this request."""
+
+    output_tokens: int
+    """Number of output tokens generated."""
+
+    total_tokens: int
+    """Total number of tokens used (input + output)."""
+
+    type: Literal["tokens"]
+    """The type of the usage object. Always `tokens` for this variant."""
+
+    input_token_details: Optional[UsageTokensInputTokenDetails] = None
+    """Details about the input tokens billed for this request."""
+
+
+class UsageDuration(BaseModel):
+    seconds: float
+    """Duration of the input audio in seconds."""
+
+    type: Literal["duration"]
+    """The type of the usage object. Always `duration` for this variant."""
+
+
+Usage: TypeAlias = Annotated[Union[UsageTokens, UsageDuration], PropertyInfo(discriminator="type")]
+
+
+class TranscriptionDiarized(BaseModel):
+    duration: float
+    """Duration of the input audio in seconds."""
+
+    segments: List[TranscriptionDiarizedSegment]
+    """Segments of the transcript annotated with timestamps and speaker labels."""
+
+    task: Literal["transcribe"]
+    """The type of task that was run. Always `transcribe`."""
+
+    text: str
+    """The concatenated transcript text for the entire audio input."""
+
+    usage: Optional[Usage] = None
+    """Token or duration usage statistics for the request."""
diff --git a/src/openai/types/audio/transcription_diarized_segment.py b/src/openai/types/audio/transcription_diarized_segment.py
new file mode 100644
index 0000000000..fe87bb4fb8
--- /dev/null
+++ b/src/openai/types/audio/transcription_diarized_segment.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TranscriptionDiarizedSegment"]
+
+
+class TranscriptionDiarizedSegment(BaseModel):
+    id: str
+    """Unique identifier for the segment."""
+
+    end: float
+    """End timestamp of the segment in seconds."""
+
+    speaker: str
+    """Speaker label for this segment.
+
+    When known speakers are provided, the label matches `known_speaker_names[]`.
+    Otherwise speakers are labeled sequentially using capital letters (`A`, `B`,
+    ...).
+    """
+
+    start: float
+    """Start timestamp of the segment in seconds."""
+
+    text: str
+    """Transcript text for this segment."""
+
+    type: Literal["transcript.text.segment"]
+    """The type of the segment. Always `transcript.text.segment`."""
diff --git a/src/openai/types/audio/transcription_include.py b/src/openai/types/audio/transcription_include.py
new file mode 100644
index 0000000000..0e464ac934
--- /dev/null
+++ b/src/openai/types/audio/transcription_include.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["TranscriptionInclude"]
+
+TranscriptionInclude: TypeAlias = Literal["logprobs"]
diff --git a/src/openai/types/audio/transcription_stream_event.py b/src/openai/types/audio/transcription_stream_event.py
new file mode 100644
index 0000000000..77d3a3aeec
--- /dev/null
+++ b/src/openai/types/audio/transcription_stream_event.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .transcription_text_done_event import TranscriptionTextDoneEvent
+from .transcription_text_delta_event import TranscriptionTextDeltaEvent
+from .transcription_text_segment_event import TranscriptionTextSegmentEvent
+
+__all__ = ["TranscriptionStreamEvent"]
+
+TranscriptionStreamEvent: TypeAlias = Annotated[
+    Union[TranscriptionTextSegmentEvent, TranscriptionTextDeltaEvent, TranscriptionTextDoneEvent],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/audio/transcription_text_delta_event.py b/src/openai/types/audio/transcription_text_delta_event.py
new file mode 100644
index 0000000000..363b6a6335
--- /dev/null
+++ b/src/openai/types/audio/transcription_text_delta_event.py
@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TranscriptionTextDeltaEvent", "Logprob"]
+
+
+class Logprob(BaseModel):
+    token: Optional[str] = None
+    """The token that was used to generate the log probability."""
+
+    bytes: Optional[List[int]] = None
+    """The bytes that were used to generate the log probability."""
+
+    logprob: Optional[float] = None
+    """The log probability of the token."""
+
+
+class TranscriptionTextDeltaEvent(BaseModel):
+    delta: str
+    """The text delta that was additionally transcribed."""
+
+    type: Literal["transcript.text.delta"]
+    """The type of the event. Always `transcript.text.delta`."""
+
+    logprobs: Optional[List[Logprob]] = None
+    """The log probabilities of the delta.
+
+    Only included if you
+    [create a transcription](https://platform.openai.com/docs/api-reference/audio/create-transcription)
+    with the `include[]` parameter set to `logprobs`.
+    """
+
+    segment_id: Optional[str] = None
+    """Identifier of the diarized segment that this delta belongs to.
+
+    Only present when using `gpt-4o-transcribe-diarize`.
+    """
diff --git a/src/openai/types/audio/transcription_text_done_event.py b/src/openai/types/audio/transcription_text_done_event.py
new file mode 100644
index 0000000000..9665edc565
--- /dev/null
+++ b/src/openai/types/audio/transcription_text_done_event.py
@@ -0,0 +1,63 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TranscriptionTextDoneEvent", "Logprob", "Usage", "UsageInputTokenDetails"]
+
+
+class Logprob(BaseModel):
+    token: Optional[str] = None
+    """The token that was used to generate the log probability."""
+
+    bytes: Optional[List[int]] = None
+    """The bytes that were used to generate the log probability."""
+
+    logprob: Optional[float] = None
+    """The log probability of the token."""
+
+
+class UsageInputTokenDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """Number of audio tokens billed for this request."""
+
+    text_tokens: Optional[int] = None
+    """Number of text tokens billed for this request."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """Number of input tokens billed for this request."""
+
+    output_tokens: int
+    """Number of output tokens generated."""
+
+    total_tokens: int
+    """Total number of tokens used (input + output)."""
+
+    type: Literal["tokens"]
+    """The type of the usage object. Always `tokens` for this variant."""
+
+    input_token_details: Optional[UsageInputTokenDetails] = None
+    """Details about the input tokens billed for this request."""
+
+
+class TranscriptionTextDoneEvent(BaseModel):
+    text: str
+    """The text that was transcribed."""
+
+    type: Literal["transcript.text.done"]
+    """The type of the event. Always `transcript.text.done`."""
+
+    logprobs: Optional[List[Logprob]] = None
+    """The log probabilities of the individual tokens in the transcription.
+
+    Only included if you
+    [create a transcription](https://platform.openai.com/docs/api-reference/audio/create-transcription)
+    with the `include[]` parameter set to `logprobs`.
+    """
+
+    usage: Optional[Usage] = None
+    """Usage statistics for models billed by token usage."""
diff --git a/src/openai/types/audio/transcription_text_segment_event.py b/src/openai/types/audio/transcription_text_segment_event.py
new file mode 100644
index 0000000000..d4f7664578
--- /dev/null
+++ b/src/openai/types/audio/transcription_text_segment_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TranscriptionTextSegmentEvent"]
+
+
+class TranscriptionTextSegmentEvent(BaseModel):
+    id: str
+    """Unique identifier for the segment."""
+
+    end: float
+    """End timestamp of the segment in seconds."""
+
+    speaker: str
+    """Speaker label for this segment."""
+
+    start: float
+    """Start timestamp of the segment in seconds."""
+
+    text: str
+    """Transcript text for this segment."""
+
+    type: Literal["transcript.text.segment"]
+    """The type of the event. Always `transcript.text.segment`."""
diff --git a/src/openai/types/audio/transcription_verbose.py b/src/openai/types/audio/transcription_verbose.py
index 2a670189e0..addda71ec6 100644
--- a/src/openai/types/audio/transcription_verbose.py
+++ b/src/openai/types/audio/transcription_verbose.py
@@ -1,12 +1,21 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import List, Optional
+from typing_extensions import Literal
 
 from ..._models import BaseModel
 from .transcription_word import TranscriptionWord
 from .transcription_segment import TranscriptionSegment
 
-__all__ = ["TranscriptionVerbose"]
+__all__ = ["TranscriptionVerbose", "Usage"]
+
+
+class Usage(BaseModel):
+    seconds: float
+    """Duration of the input audio in seconds."""
+
+    type: Literal["duration"]
+    """The type of the usage object. Always `duration` for this variant."""
 
 
 class TranscriptionVerbose(BaseModel):
@@ -22,5 +31,8 @@ class TranscriptionVerbose(BaseModel):
     segments: Optional[List[TranscriptionSegment]] = None
     """Segments of the transcribed text and their corresponding details."""
 
+    usage: Optional[Usage] = None
+    """Usage statistics for models billed by audio input duration."""
+
     words: Optional[List[TranscriptionWord]] = None
     """Extracted words and their corresponding timestamps."""
diff --git a/src/openai/types/audio/transcription_word.py b/src/openai/types/audio/transcription_word.py
index 969da32509..2ce682f957 100644
--- a/src/openai/types/audio/transcription_word.py
+++ b/src/openai/types/audio/transcription_word.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from ..._models import BaseModel
 
 __all__ = ["TranscriptionWord"]
diff --git a/src/openai/types/audio/translation.py b/src/openai/types/audio/translation.py
index 7c0e905189..efc56f7f9b 100644
--- a/src/openai/types/audio/translation.py
+++ b/src/openai/types/audio/translation.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from ..._models import BaseModel
 
 __all__ = ["Translation"]
diff --git a/src/openai/types/audio/translation_create_params.py b/src/openai/types/audio/translation_create_params.py
index 62f85b8757..b23a185375 100644
--- a/src/openai/types/audio/translation_create_params.py
+++ b/src/openai/types/audio/translation_create_params.py
@@ -3,11 +3,10 @@
 from __future__ import annotations
 
 from typing import Union
-from typing_extensions import Required, TypedDict
+from typing_extensions import Literal, Required, TypedDict
 
 from ..._types import FileTypes
 from ..audio_model import AudioModel
-from ..audio_response_format import AudioResponseFormat
 
 __all__ = ["TranslationCreateParams"]
 
@@ -34,7 +33,7 @@ class TranslationCreateParams(TypedDict, total=False):
     should be in English.
     """
 
-    response_format: AudioResponseFormat
+    response_format: Literal["json", "text", "srt", "verbose_json", "vtt"]
     """
     The format of the output, in one of these options: `json`, `text`, `srt`,
     `verbose_json`, or `vtt`.
diff --git a/src/openai/types/audio_model.py b/src/openai/types/audio_model.py
index 94ae84c015..68031a2198 100644
--- a/src/openai/types/audio_model.py
+++ b/src/openai/types/audio_model.py
@@ -4,4 +4,4 @@
 
 __all__ = ["AudioModel"]
 
-AudioModel: TypeAlias = Literal["whisper-1"]
+AudioModel: TypeAlias = Literal["whisper-1", "gpt-4o-transcribe", "gpt-4o-mini-transcribe", "gpt-4o-transcribe-diarize"]
diff --git a/src/openai/types/audio_response_format.py b/src/openai/types/audio_response_format.py
index f8c8d45945..1897aaf6ed 100644
--- a/src/openai/types/audio_response_format.py
+++ b/src/openai/types/audio_response_format.py
@@ -4,4 +4,4 @@
 
 __all__ = ["AudioResponseFormat"]
 
-AudioResponseFormat: TypeAlias = Literal["json", "text", "srt", "verbose_json", "vtt"]
+AudioResponseFormat: TypeAlias = Literal["json", "text", "srt", "verbose_json", "vtt", "diarized_json"]
diff --git a/src/openai/types/batch.py b/src/openai/types/batch.py
index 35de90ac85..ece0513b35 100644
--- a/src/openai/types/batch.py
+++ b/src/openai/types/batch.py
@@ -5,6 +5,7 @@
 
 from .._models import BaseModel
 from .batch_error import BatchError
+from .batch_usage import BatchUsage
 from .shared.metadata import Metadata
 from .batch_request_counts import BatchRequestCounts
 
@@ -80,8 +81,24 @@ class Batch(BaseModel):
     a maximum length of 512 characters.
     """
 
+    model: Optional[str] = None
+    """Model ID used to process the batch, like `gpt-5-2025-08-07`.
+
+    OpenAI offers a wide range of models with different capabilities, performance
+    characteristics, and price points. Refer to the
+    [model guide](https://platform.openai.com/docs/models) to browse and compare
+    available models.
+    """
+
     output_file_id: Optional[str] = None
     """The ID of the file containing the outputs of successfully executed requests."""
 
     request_counts: Optional[BatchRequestCounts] = None
     """The request counts for different statuses within the batch."""
+
+    usage: Optional[BatchUsage] = None
+    """
+    Represents token usage details including input tokens, output tokens, a
+    breakdown of output tokens, and the total tokens used. Only populated on batches
+    created after September 7, 2025.
+    """
diff --git a/src/openai/types/batch_create_params.py b/src/openai/types/batch_create_params.py
index e5be1d2bac..c182a87e7f 100644
--- a/src/openai/types/batch_create_params.py
+++ b/src/openai/types/batch_create_params.py
@@ -7,7 +7,7 @@
 
 from .shared_params.metadata import Metadata
 
-__all__ = ["BatchCreateParams"]
+__all__ = ["BatchCreateParams", "OutputExpiresAfter"]
 
 
 class BatchCreateParams(TypedDict, total=False):
@@ -17,12 +17,15 @@ class BatchCreateParams(TypedDict, total=False):
     Currently only `24h` is supported.
     """
 
-    endpoint: Required[Literal["/v1/chat/completions", "/v1/embeddings", "/v1/completions"]]
+    endpoint: Required[
+        Literal["/v1/responses", "/v1/chat/completions", "/v1/embeddings", "/v1/completions", "/v1/moderations"]
+    ]
     """The endpoint to be used for all requests in the batch.
 
-    Currently `/v1/chat/completions`, `/v1/embeddings`, and `/v1/completions` are
-    supported. Note that `/v1/embeddings` batches are also restricted to a maximum
-    of 50,000 embedding inputs across all requests in the batch.
+    Currently `/v1/responses`, `/v1/chat/completions`, `/v1/embeddings`,
+    `/v1/completions`, and `/v1/moderations` are supported. Note that
+    `/v1/embeddings` batches are also restricted to a maximum of 50,000 embedding
+    inputs across all requests in the batch.
     """
 
     input_file_id: Required[str]
@@ -46,3 +49,24 @@ class BatchCreateParams(TypedDict, total=False):
     Keys are strings with a maximum length of 64 characters. Values are strings with
     a maximum length of 512 characters.
     """
+
+    output_expires_after: OutputExpiresAfter
+    """
+    The expiration policy for the output and/or error file that are generated for a
+    batch.
+    """
+
+
+class OutputExpiresAfter(TypedDict, total=False):
+    anchor: Required[Literal["created_at"]]
+    """Anchor timestamp after which the expiration policy applies.
+
+    Supported anchors: `created_at`. Note that the anchor is the file creation time,
+    not the time the batch is created.
+    """
+
+    seconds: Required[int]
+    """The number of seconds after the anchor time that the file will expire.
+
+    Must be between 3600 (1 hour) and 2592000 (30 days).
+    """
diff --git a/src/openai/types/batch_request_counts.py b/src/openai/types/batch_request_counts.py
index 7e1d49fb88..068b071af1 100644
--- a/src/openai/types/batch_request_counts.py
+++ b/src/openai/types/batch_request_counts.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from .._models import BaseModel
 
 __all__ = ["BatchRequestCounts"]
diff --git a/src/openai/types/batch_usage.py b/src/openai/types/batch_usage.py
new file mode 100644
index 0000000000..578f64a5e2
--- /dev/null
+++ b/src/openai/types/batch_usage.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["BatchUsage", "InputTokensDetails", "OutputTokensDetails"]
+
+
+class InputTokensDetails(BaseModel):
+    cached_tokens: int
+    """The number of tokens that were retrieved from the cache.
+
+    [More on prompt caching](https://platform.openai.com/docs/guides/prompt-caching).
+    """
+
+
+class OutputTokensDetails(BaseModel):
+    reasoning_tokens: int
+    """The number of reasoning tokens."""
+
+
+class BatchUsage(BaseModel):
+    input_tokens: int
+    """The number of input tokens."""
+
+    input_tokens_details: InputTokensDetails
+    """A detailed breakdown of the input tokens."""
+
+    output_tokens: int
+    """The number of output tokens."""
+
+    output_tokens_details: OutputTokensDetails
+    """A detailed breakdown of the output tokens."""
+
+    total_tokens: int
+    """The total number of tokens used."""
diff --git a/src/openai/types/beta/__init__.py b/src/openai/types/beta/__init__.py
index 5ba3eadf3c..deb2369677 100644
--- a/src/openai/types/beta/__init__.py
+++ b/src/openai/types/beta/__init__.py
@@ -7,6 +7,7 @@
 from .function_tool import FunctionTool as FunctionTool
 from .assistant_tool import AssistantTool as AssistantTool
 from .thread_deleted import ThreadDeleted as ThreadDeleted
+from .chatkit_workflow import ChatKitWorkflow as ChatKitWorkflow
 from .file_search_tool import FileSearchTool as FileSearchTool
 from .assistant_deleted import AssistantDeleted as AssistantDeleted
 from .function_tool_param import FunctionToolParam as FunctionToolParam
diff --git a/src/openai/types/beta/assistant_create_params.py b/src/openai/types/beta/assistant_create_params.py
index 8b3c331850..009b0f49e3 100644
--- a/src/openai/types/beta/assistant_create_params.py
+++ b/src/openai/types/beta/assistant_create_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable, Optional
+from typing import Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from ..shared.chat_model import ChatModel
 from .assistant_tool_param import AssistantToolParam
 from ..shared_params.metadata import Metadata
@@ -58,12 +59,19 @@ class AssistantCreateParams(TypedDict, total=False):
     """The name of the assistant. The maximum length is 256 characters."""
 
     reasoning_effort: Optional[ReasoningEffort]
-    """**o-series models only**
-
+    """
     Constrains effort on reasoning for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-    result in faster responses and fewer tokens used on reasoning in a response.
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     """
 
     response_format: Optional[AssistantResponseFormatOptionParam]
@@ -123,7 +131,7 @@ class AssistantCreateParams(TypedDict, total=False):
 
 
 class ToolResourcesCodeInterpreter(TypedDict, total=False):
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs made
     available to the `code_interpreter` tool. There can be a maximum of 20 files
@@ -170,7 +178,7 @@ class ToolResourcesFileSearchVectorStore(TypedDict, total=False):
     If not set, will use the `auto` strategy.
     """
 
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs to
     add to the vector store. There can be a maximum of 10000 files in a vector
@@ -189,7 +197,7 @@ class ToolResourcesFileSearchVectorStore(TypedDict, total=False):
 
 
 class ToolResourcesFileSearch(TypedDict, total=False):
-    vector_store_ids: List[str]
+    vector_store_ids: SequenceNotStr[str]
     """
     The
     [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
diff --git a/src/openai/types/beta/assistant_tool_choice_function.py b/src/openai/types/beta/assistant_tool_choice_function.py
index 0c896d8087..87f38310ca 100644
--- a/src/openai/types/beta/assistant_tool_choice_function.py
+++ b/src/openai/types/beta/assistant_tool_choice_function.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from ..._models import BaseModel
 
 __all__ = ["AssistantToolChoiceFunction"]
diff --git a/src/openai/types/beta/assistant_update_params.py b/src/openai/types/beta/assistant_update_params.py
index d3ec7614fd..432116ad52 100644
--- a/src/openai/types/beta/assistant_update_params.py
+++ b/src/openai/types/beta/assistant_update_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable, Optional
+from typing import Union, Iterable, Optional
 from typing_extensions import Literal, TypedDict
 
+from ..._types import SequenceNotStr
 from .assistant_tool_param import AssistantToolParam
 from ..shared_params.metadata import Metadata
 from ..shared.reasoning_effort import ReasoningEffort
@@ -36,6 +37,18 @@ class AssistantUpdateParams(TypedDict, total=False):
     model: Union[
         str,
         Literal[
+            "gpt-5",
+            "gpt-5-mini",
+            "gpt-5-nano",
+            "gpt-5-2025-08-07",
+            "gpt-5-mini-2025-08-07",
+            "gpt-5-nano-2025-08-07",
+            "gpt-4.1",
+            "gpt-4.1-mini",
+            "gpt-4.1-nano",
+            "gpt-4.1-2025-04-14",
+            "gpt-4.1-mini-2025-04-14",
+            "gpt-4.1-nano-2025-04-14",
             "o3-mini",
             "o3-mini-2025-01-31",
             "o1",
@@ -81,12 +94,19 @@ class AssistantUpdateParams(TypedDict, total=False):
     """The name of the assistant. The maximum length is 256 characters."""
 
     reasoning_effort: Optional[ReasoningEffort]
-    """**o-series models only**
-
+    """
     Constrains effort on reasoning for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-    result in faster responses and fewer tokens used on reasoning in a response.
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     """
 
     response_format: Optional[AssistantResponseFormatOptionParam]
@@ -146,7 +166,7 @@ class AssistantUpdateParams(TypedDict, total=False):
 
 
 class ToolResourcesCodeInterpreter(TypedDict, total=False):
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     Overrides the list of
     [file](https://platform.openai.com/docs/api-reference/files) IDs made available
@@ -156,7 +176,7 @@ class ToolResourcesCodeInterpreter(TypedDict, total=False):
 
 
 class ToolResourcesFileSearch(TypedDict, total=False):
-    vector_store_ids: List[str]
+    vector_store_ids: SequenceNotStr[str]
     """
     Overrides the
     [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
diff --git a/src/openai/types/beta/chatkit/__init__.py b/src/openai/types/beta/chatkit/__init__.py
new file mode 100644
index 0000000000..eafed9dd99
--- /dev/null
+++ b/src/openai/types/beta/chatkit/__init__.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .chat_session import ChatSession as ChatSession
+from .chatkit_thread import ChatKitThread as ChatKitThread
+from .chatkit_attachment import ChatKitAttachment as ChatKitAttachment
+from .thread_list_params import ThreadListParams as ThreadListParams
+from .chat_session_status import ChatSessionStatus as ChatSessionStatus
+from .chatkit_widget_item import ChatKitWidgetItem as ChatKitWidgetItem
+from .chat_session_history import ChatSessionHistory as ChatSessionHistory
+from .session_create_params import SessionCreateParams as SessionCreateParams
+from .thread_delete_response import ThreadDeleteResponse as ThreadDeleteResponse
+from .chat_session_file_upload import ChatSessionFileUpload as ChatSessionFileUpload
+from .chat_session_rate_limits import ChatSessionRateLimits as ChatSessionRateLimits
+from .chatkit_thread_item_list import ChatKitThreadItemList as ChatKitThreadItemList
+from .thread_list_items_params import ThreadListItemsParams as ThreadListItemsParams
+from .chat_session_workflow_param import ChatSessionWorkflowParam as ChatSessionWorkflowParam
+from .chatkit_response_output_text import ChatKitResponseOutputText as ChatKitResponseOutputText
+from .chat_session_rate_limits_param import ChatSessionRateLimitsParam as ChatSessionRateLimitsParam
+from .chat_session_expires_after_param import ChatSessionExpiresAfterParam as ChatSessionExpiresAfterParam
+from .chatkit_thread_user_message_item import ChatKitThreadUserMessageItem as ChatKitThreadUserMessageItem
+from .chat_session_chatkit_configuration import ChatSessionChatKitConfiguration as ChatSessionChatKitConfiguration
+from .chat_session_automatic_thread_titling import (
+    ChatSessionAutomaticThreadTitling as ChatSessionAutomaticThreadTitling,
+)
+from .chatkit_thread_assistant_message_item import (
+    ChatKitThreadAssistantMessageItem as ChatKitThreadAssistantMessageItem,
+)
+from .chat_session_chatkit_configuration_param import (
+    ChatSessionChatKitConfigurationParam as ChatSessionChatKitConfigurationParam,
+)
diff --git a/src/openai/types/beta/chatkit/chat_session.py b/src/openai/types/beta/chatkit/chat_session.py
new file mode 100644
index 0000000000..82baea211c
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session.py
@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from ..chatkit_workflow import ChatKitWorkflow
+from .chat_session_status import ChatSessionStatus
+from .chat_session_rate_limits import ChatSessionRateLimits
+from .chat_session_chatkit_configuration import ChatSessionChatKitConfiguration
+
+__all__ = ["ChatSession"]
+
+
+class ChatSession(BaseModel):
+    id: str
+    """Identifier for the ChatKit session."""
+
+    chatkit_configuration: ChatSessionChatKitConfiguration
+    """Resolved ChatKit feature configuration for the session."""
+
+    client_secret: str
+    """Ephemeral client secret that authenticates session requests."""
+
+    expires_at: int
+    """Unix timestamp (in seconds) for when the session expires."""
+
+    max_requests_per_1_minute: int
+    """Convenience copy of the per-minute request limit."""
+
+    object: Literal["chatkit.session"]
+    """Type discriminator that is always `chatkit.session`."""
+
+    rate_limits: ChatSessionRateLimits
+    """Resolved rate limit values."""
+
+    status: ChatSessionStatus
+    """Current lifecycle state of the session."""
+
+    user: str
+    """User identifier associated with the session."""
+
+    workflow: ChatKitWorkflow
+    """Workflow metadata for the session."""
diff --git a/src/openai/types/beta/chatkit/chat_session_automatic_thread_titling.py b/src/openai/types/beta/chatkit/chat_session_automatic_thread_titling.py
new file mode 100644
index 0000000000..4fa96a4433
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_automatic_thread_titling.py
@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ...._models import BaseModel
+
+__all__ = ["ChatSessionAutomaticThreadTitling"]
+
+
+class ChatSessionAutomaticThreadTitling(BaseModel):
+    enabled: bool
+    """Whether automatic thread titling is enabled."""
diff --git a/src/openai/types/beta/chatkit/chat_session_chatkit_configuration.py b/src/openai/types/beta/chatkit/chat_session_chatkit_configuration.py
new file mode 100644
index 0000000000..6205b172cf
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_chatkit_configuration.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ...._models import BaseModel
+from .chat_session_history import ChatSessionHistory
+from .chat_session_file_upload import ChatSessionFileUpload
+from .chat_session_automatic_thread_titling import ChatSessionAutomaticThreadTitling
+
+__all__ = ["ChatSessionChatKitConfiguration"]
+
+
+class ChatSessionChatKitConfiguration(BaseModel):
+    automatic_thread_titling: ChatSessionAutomaticThreadTitling
+    """Automatic thread titling preferences."""
+
+    file_upload: ChatSessionFileUpload
+    """Upload settings for the session."""
+
+    history: ChatSessionHistory
+    """History retention configuration."""
diff --git a/src/openai/types/beta/chatkit/chat_session_chatkit_configuration_param.py b/src/openai/types/beta/chatkit/chat_session_chatkit_configuration_param.py
new file mode 100644
index 0000000000..0a5ae80a76
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_chatkit_configuration_param.py
@@ -0,0 +1,59 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["ChatSessionChatKitConfigurationParam", "AutomaticThreadTitling", "FileUpload", "History"]
+
+
+class AutomaticThreadTitling(TypedDict, total=False):
+    enabled: bool
+    """Enable automatic thread title generation. Defaults to true."""
+
+
+class FileUpload(TypedDict, total=False):
+    enabled: bool
+    """Enable uploads for this session. Defaults to false."""
+
+    max_file_size: int
+    """Maximum size in megabytes for each uploaded file.
+
+    Defaults to 512 MB, which is the maximum allowable size.
+    """
+
+    max_files: int
+    """Maximum number of files that can be uploaded to the session. Defaults to 10."""
+
+
+class History(TypedDict, total=False):
+    enabled: bool
+    """Enables chat users to access previous ChatKit threads. Defaults to true."""
+
+    recent_threads: int
+    """Number of recent ChatKit threads users have access to.
+
+    Defaults to unlimited when unset.
+    """
+
+
+class ChatSessionChatKitConfigurationParam(TypedDict, total=False):
+    automatic_thread_titling: AutomaticThreadTitling
+    """Configuration for automatic thread titling.
+
+    When omitted, automatic thread titling is enabled by default.
+    """
+
+    file_upload: FileUpload
+    """Configuration for upload enablement and limits.
+
+    When omitted, uploads are disabled by default (max_files 10, max_file_size 512
+    MB).
+    """
+
+    history: History
+    """Configuration for chat history retention.
+
+    When omitted, history is enabled by default with no limit on recent_threads
+    (null).
+    """
diff --git a/src/openai/types/beta/chatkit/chat_session_expires_after_param.py b/src/openai/types/beta/chatkit/chat_session_expires_after_param.py
new file mode 100644
index 0000000000..ceb5a984c5
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_expires_after_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatSessionExpiresAfterParam"]
+
+
+class ChatSessionExpiresAfterParam(TypedDict, total=False):
+    anchor: Required[Literal["created_at"]]
+    """Base timestamp used to calculate expiration. Currently fixed to `created_at`."""
+
+    seconds: Required[int]
+    """Number of seconds after the anchor when the session expires."""
diff --git a/src/openai/types/beta/chatkit/chat_session_file_upload.py b/src/openai/types/beta/chatkit/chat_session_file_upload.py
new file mode 100644
index 0000000000..c63c7a0149
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_file_upload.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ...._models import BaseModel
+
+__all__ = ["ChatSessionFileUpload"]
+
+
+class ChatSessionFileUpload(BaseModel):
+    enabled: bool
+    """Indicates if uploads are enabled for the session."""
+
+    max_file_size: Optional[int] = None
+    """Maximum upload size in megabytes."""
+
+    max_files: Optional[int] = None
+    """Maximum number of uploads allowed during the session."""
diff --git a/src/openai/types/beta/chatkit/chat_session_history.py b/src/openai/types/beta/chatkit/chat_session_history.py
new file mode 100644
index 0000000000..66ebe00877
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_history.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ...._models import BaseModel
+
+__all__ = ["ChatSessionHistory"]
+
+
+class ChatSessionHistory(BaseModel):
+    enabled: bool
+    """Indicates if chat history is persisted for the session."""
+
+    recent_threads: Optional[int] = None
+    """Number of prior threads surfaced in history views.
+
+    Defaults to null when all history is retained.
+    """
diff --git a/src/openai/types/beta/chatkit/chat_session_rate_limits.py b/src/openai/types/beta/chatkit/chat_session_rate_limits.py
new file mode 100644
index 0000000000..392225e347
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_rate_limits.py
@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ...._models import BaseModel
+
+__all__ = ["ChatSessionRateLimits"]
+
+
+class ChatSessionRateLimits(BaseModel):
+    max_requests_per_1_minute: int
+    """Maximum allowed requests per one-minute window."""
diff --git a/src/openai/types/beta/chatkit/chat_session_rate_limits_param.py b/src/openai/types/beta/chatkit/chat_session_rate_limits_param.py
new file mode 100644
index 0000000000..7894c06484
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_rate_limits_param.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["ChatSessionRateLimitsParam"]
+
+
+class ChatSessionRateLimitsParam(TypedDict, total=False):
+    max_requests_per_1_minute: int
+    """Maximum number of requests allowed per minute for the session. Defaults to 10."""
diff --git a/src/openai/types/beta/chatkit/chat_session_status.py b/src/openai/types/beta/chatkit/chat_session_status.py
new file mode 100644
index 0000000000..a483099c6c
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_status.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["ChatSessionStatus"]
+
+ChatSessionStatus: TypeAlias = Literal["active", "expired", "cancelled"]
diff --git a/src/openai/types/beta/chatkit/chat_session_workflow_param.py b/src/openai/types/beta/chatkit/chat_session_workflow_param.py
new file mode 100644
index 0000000000..5542922102
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chat_session_workflow_param.py
@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union
+from typing_extensions import Required, TypedDict
+
+__all__ = ["ChatSessionWorkflowParam", "Tracing"]
+
+
+class Tracing(TypedDict, total=False):
+    enabled: bool
+    """Whether tracing is enabled during the session. Defaults to true."""
+
+
+class ChatSessionWorkflowParam(TypedDict, total=False):
+    id: Required[str]
+    """Identifier for the workflow invoked by the session."""
+
+    state_variables: Dict[str, Union[str, bool, float]]
+    """State variables forwarded to the workflow.
+
+    Keys may be up to 64 characters, values must be primitive types, and the map
+    defaults to an empty object.
+    """
+
+    tracing: Tracing
+    """Optional tracing overrides for the workflow invocation.
+
+    When omitted, tracing is enabled by default.
+    """
+
+    version: str
+    """Specific workflow version to run. Defaults to the latest deployed version."""
diff --git a/src/openai/types/beta/chatkit/chatkit_attachment.py b/src/openai/types/beta/chatkit/chatkit_attachment.py
new file mode 100644
index 0000000000..8d8ad3e128
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chatkit_attachment.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["ChatKitAttachment"]
+
+
+class ChatKitAttachment(BaseModel):
+    id: str
+    """Identifier for the attachment."""
+
+    mime_type: str
+    """MIME type of the attachment."""
+
+    name: str
+    """Original display name for the attachment."""
+
+    preview_url: Optional[str] = None
+    """Preview URL for rendering the attachment inline."""
+
+    type: Literal["image", "file"]
+    """Attachment discriminator."""
diff --git a/src/openai/types/beta/chatkit/chatkit_response_output_text.py b/src/openai/types/beta/chatkit/chatkit_response_output_text.py
new file mode 100644
index 0000000000..116b797ec2
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chatkit_response_output_text.py
@@ -0,0 +1,62 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ...._utils import PropertyInfo
+from ...._models import BaseModel
+
+__all__ = [
+    "ChatKitResponseOutputText",
+    "Annotation",
+    "AnnotationFile",
+    "AnnotationFileSource",
+    "AnnotationURL",
+    "AnnotationURLSource",
+]
+
+
+class AnnotationFileSource(BaseModel):
+    filename: str
+    """Filename referenced by the annotation."""
+
+    type: Literal["file"]
+    """Type discriminator that is always `file`."""
+
+
+class AnnotationFile(BaseModel):
+    source: AnnotationFileSource
+    """File attachment referenced by the annotation."""
+
+    type: Literal["file"]
+    """Type discriminator that is always `file` for this annotation."""
+
+
+class AnnotationURLSource(BaseModel):
+    type: Literal["url"]
+    """Type discriminator that is always `url`."""
+
+    url: str
+    """URL referenced by the annotation."""
+
+
+class AnnotationURL(BaseModel):
+    source: AnnotationURLSource
+    """URL referenced by the annotation."""
+
+    type: Literal["url"]
+    """Type discriminator that is always `url` for this annotation."""
+
+
+Annotation: TypeAlias = Annotated[Union[AnnotationFile, AnnotationURL], PropertyInfo(discriminator="type")]
+
+
+class ChatKitResponseOutputText(BaseModel):
+    annotations: List[Annotation]
+    """Ordered list of annotations attached to the response text."""
+
+    text: str
+    """Assistant generated text."""
+
+    type: Literal["output_text"]
+    """Type discriminator that is always `output_text`."""
diff --git a/src/openai/types/beta/chatkit/chatkit_thread.py b/src/openai/types/beta/chatkit/chatkit_thread.py
new file mode 100644
index 0000000000..abd1a9ea01
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chatkit_thread.py
@@ -0,0 +1,56 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ...._utils import PropertyInfo
+from ...._models import BaseModel
+
+__all__ = ["ChatKitThread", "Status", "StatusActive", "StatusLocked", "StatusClosed"]
+
+
+class StatusActive(BaseModel):
+    type: Literal["active"]
+    """Status discriminator that is always `active`."""
+
+
+class StatusLocked(BaseModel):
+    reason: Optional[str] = None
+    """Reason that the thread was locked. Defaults to null when no reason is recorded."""
+
+    type: Literal["locked"]
+    """Status discriminator that is always `locked`."""
+
+
+class StatusClosed(BaseModel):
+    reason: Optional[str] = None
+    """Reason that the thread was closed. Defaults to null when no reason is recorded."""
+
+    type: Literal["closed"]
+    """Status discriminator that is always `closed`."""
+
+
+Status: TypeAlias = Annotated[Union[StatusActive, StatusLocked, StatusClosed], PropertyInfo(discriminator="type")]
+
+
+class ChatKitThread(BaseModel):
+    id: str
+    """Identifier of the thread."""
+
+    created_at: int
+    """Unix timestamp (in seconds) for when the thread was created."""
+
+    object: Literal["chatkit.thread"]
+    """Type discriminator that is always `chatkit.thread`."""
+
+    status: Status
+    """Current status for the thread. Defaults to `active` for newly created threads."""
+
+    title: Optional[str] = None
+    """Optional human-readable title for the thread.
+
+    Defaults to null when no title has been generated.
+    """
+
+    user: str
+    """Free-form string that identifies your end user who owns the thread."""
diff --git a/src/openai/types/beta/chatkit/chatkit_thread_assistant_message_item.py b/src/openai/types/beta/chatkit/chatkit_thread_assistant_message_item.py
new file mode 100644
index 0000000000..f4afd053b6
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chatkit_thread_assistant_message_item.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from .chatkit_response_output_text import ChatKitResponseOutputText
+
+__all__ = ["ChatKitThreadAssistantMessageItem"]
+
+
+class ChatKitThreadAssistantMessageItem(BaseModel):
+    id: str
+    """Identifier of the thread item."""
+
+    content: List[ChatKitResponseOutputText]
+    """Ordered assistant response segments."""
+
+    created_at: int
+    """Unix timestamp (in seconds) for when the item was created."""
+
+    object: Literal["chatkit.thread_item"]
+    """Type discriminator that is always `chatkit.thread_item`."""
+
+    thread_id: str
+    """Identifier of the parent thread."""
+
+    type: Literal["chatkit.assistant_message"]
+    """Type discriminator that is always `chatkit.assistant_message`."""
diff --git a/src/openai/types/beta/chatkit/chatkit_thread_item_list.py b/src/openai/types/beta/chatkit/chatkit_thread_item_list.py
new file mode 100644
index 0000000000..173bd15055
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chatkit_thread_item_list.py
@@ -0,0 +1,144 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ...._utils import PropertyInfo
+from ...._models import BaseModel
+from .chatkit_widget_item import ChatKitWidgetItem
+from .chatkit_thread_user_message_item import ChatKitThreadUserMessageItem
+from .chatkit_thread_assistant_message_item import ChatKitThreadAssistantMessageItem
+
+__all__ = [
+    "ChatKitThreadItemList",
+    "Data",
+    "DataChatKitClientToolCall",
+    "DataChatKitTask",
+    "DataChatKitTaskGroup",
+    "DataChatKitTaskGroupTask",
+]
+
+
+class DataChatKitClientToolCall(BaseModel):
+    id: str
+    """Identifier of the thread item."""
+
+    arguments: str
+    """JSON-encoded arguments that were sent to the tool."""
+
+    call_id: str
+    """Identifier for the client tool call."""
+
+    created_at: int
+    """Unix timestamp (in seconds) for when the item was created."""
+
+    name: str
+    """Tool name that was invoked."""
+
+    object: Literal["chatkit.thread_item"]
+    """Type discriminator that is always `chatkit.thread_item`."""
+
+    output: Optional[str] = None
+    """JSON-encoded output captured from the tool.
+
+    Defaults to null while execution is in progress.
+    """
+
+    status: Literal["in_progress", "completed"]
+    """Execution status for the tool call."""
+
+    thread_id: str
+    """Identifier of the parent thread."""
+
+    type: Literal["chatkit.client_tool_call"]
+    """Type discriminator that is always `chatkit.client_tool_call`."""
+
+
+class DataChatKitTask(BaseModel):
+    id: str
+    """Identifier of the thread item."""
+
+    created_at: int
+    """Unix timestamp (in seconds) for when the item was created."""
+
+    heading: Optional[str] = None
+    """Optional heading for the task. Defaults to null when not provided."""
+
+    object: Literal["chatkit.thread_item"]
+    """Type discriminator that is always `chatkit.thread_item`."""
+
+    summary: Optional[str] = None
+    """Optional summary that describes the task. Defaults to null when omitted."""
+
+    task_type: Literal["custom", "thought"]
+    """Subtype for the task."""
+
+    thread_id: str
+    """Identifier of the parent thread."""
+
+    type: Literal["chatkit.task"]
+    """Type discriminator that is always `chatkit.task`."""
+
+
+class DataChatKitTaskGroupTask(BaseModel):
+    heading: Optional[str] = None
+    """Optional heading for the grouped task. Defaults to null when not provided."""
+
+    summary: Optional[str] = None
+    """Optional summary that describes the grouped task.
+
+    Defaults to null when omitted.
+    """
+
+    type: Literal["custom", "thought"]
+    """Subtype for the grouped task."""
+
+
+class DataChatKitTaskGroup(BaseModel):
+    id: str
+    """Identifier of the thread item."""
+
+    created_at: int
+    """Unix timestamp (in seconds) for when the item was created."""
+
+    object: Literal["chatkit.thread_item"]
+    """Type discriminator that is always `chatkit.thread_item`."""
+
+    tasks: List[DataChatKitTaskGroupTask]
+    """Tasks included in the group."""
+
+    thread_id: str
+    """Identifier of the parent thread."""
+
+    type: Literal["chatkit.task_group"]
+    """Type discriminator that is always `chatkit.task_group`."""
+
+
+Data: TypeAlias = Annotated[
+    Union[
+        ChatKitThreadUserMessageItem,
+        ChatKitThreadAssistantMessageItem,
+        ChatKitWidgetItem,
+        DataChatKitClientToolCall,
+        DataChatKitTask,
+        DataChatKitTaskGroup,
+    ],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class ChatKitThreadItemList(BaseModel):
+    data: List[Data]
+    """A list of items"""
+
+    first_id: Optional[str] = None
+    """The ID of the first item in the list."""
+
+    has_more: bool
+    """Whether there are more items available."""
+
+    last_id: Optional[str] = None
+    """The ID of the last item in the list."""
+
+    object: Literal["list"]
+    """The type of object returned, must be `list`."""
diff --git a/src/openai/types/beta/chatkit/chatkit_thread_user_message_item.py b/src/openai/types/beta/chatkit/chatkit_thread_user_message_item.py
new file mode 100644
index 0000000000..233d07232f
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chatkit_thread_user_message_item.py
@@ -0,0 +1,77 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ...._utils import PropertyInfo
+from ...._models import BaseModel
+from .chatkit_attachment import ChatKitAttachment
+
+__all__ = [
+    "ChatKitThreadUserMessageItem",
+    "Content",
+    "ContentInputText",
+    "ContentQuotedText",
+    "InferenceOptions",
+    "InferenceOptionsToolChoice",
+]
+
+
+class ContentInputText(BaseModel):
+    text: str
+    """Plain-text content supplied by the user."""
+
+    type: Literal["input_text"]
+    """Type discriminator that is always `input_text`."""
+
+
+class ContentQuotedText(BaseModel):
+    text: str
+    """Quoted text content."""
+
+    type: Literal["quoted_text"]
+    """Type discriminator that is always `quoted_text`."""
+
+
+Content: TypeAlias = Annotated[Union[ContentInputText, ContentQuotedText], PropertyInfo(discriminator="type")]
+
+
+class InferenceOptionsToolChoice(BaseModel):
+    id: str
+    """Identifier of the requested tool."""
+
+
+class InferenceOptions(BaseModel):
+    model: Optional[str] = None
+    """Model name that generated the response.
+
+    Defaults to null when using the session default.
+    """
+
+    tool_choice: Optional[InferenceOptionsToolChoice] = None
+    """Preferred tool to invoke. Defaults to null when ChatKit should auto-select."""
+
+
+class ChatKitThreadUserMessageItem(BaseModel):
+    id: str
+    """Identifier of the thread item."""
+
+    attachments: List[ChatKitAttachment]
+    """Attachments associated with the user message. Defaults to an empty list."""
+
+    content: List[Content]
+    """Ordered content elements supplied by the user."""
+
+    created_at: int
+    """Unix timestamp (in seconds) for when the item was created."""
+
+    inference_options: Optional[InferenceOptions] = None
+    """Inference overrides applied to the message. Defaults to null when unset."""
+
+    object: Literal["chatkit.thread_item"]
+    """Type discriminator that is always `chatkit.thread_item`."""
+
+    thread_id: str
+    """Identifier of the parent thread."""
+
+    type: Literal["chatkit.user_message"]
diff --git a/src/openai/types/beta/chatkit/chatkit_widget_item.py b/src/openai/types/beta/chatkit/chatkit_widget_item.py
new file mode 100644
index 0000000000..c7f182259a
--- /dev/null
+++ b/src/openai/types/beta/chatkit/chatkit_widget_item.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["ChatKitWidgetItem"]
+
+
+class ChatKitWidgetItem(BaseModel):
+    id: str
+    """Identifier of the thread item."""
+
+    created_at: int
+    """Unix timestamp (in seconds) for when the item was created."""
+
+    object: Literal["chatkit.thread_item"]
+    """Type discriminator that is always `chatkit.thread_item`."""
+
+    thread_id: str
+    """Identifier of the parent thread."""
+
+    type: Literal["chatkit.widget"]
+    """Type discriminator that is always `chatkit.widget`."""
+
+    widget: str
+    """Serialized widget payload rendered in the UI."""
diff --git a/src/openai/types/beta/chatkit/session_create_params.py b/src/openai/types/beta/chatkit/session_create_params.py
new file mode 100644
index 0000000000..1803d18cf6
--- /dev/null
+++ b/src/openai/types/beta/chatkit/session_create_params.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from .chat_session_workflow_param import ChatSessionWorkflowParam
+from .chat_session_rate_limits_param import ChatSessionRateLimitsParam
+from .chat_session_expires_after_param import ChatSessionExpiresAfterParam
+from .chat_session_chatkit_configuration_param import ChatSessionChatKitConfigurationParam
+
+__all__ = ["SessionCreateParams"]
+
+
+class SessionCreateParams(TypedDict, total=False):
+    user: Required[str]
+    """
+    A free-form string that identifies your end user; ensures this Session can
+    access other objects that have the same `user` scope.
+    """
+
+    workflow: Required[ChatSessionWorkflowParam]
+    """Workflow that powers the session."""
+
+    chatkit_configuration: ChatSessionChatKitConfigurationParam
+    """Optional overrides for ChatKit runtime configuration features"""
+
+    expires_after: ChatSessionExpiresAfterParam
+    """Optional override for session expiration timing in seconds from creation.
+
+    Defaults to 10 minutes.
+    """
+
+    rate_limits: ChatSessionRateLimitsParam
+    """Optional override for per-minute request limits. When omitted, defaults to 10."""
diff --git a/src/openai/types/beta/chatkit/thread_delete_response.py b/src/openai/types/beta/chatkit/thread_delete_response.py
new file mode 100644
index 0000000000..03fdec9c2c
--- /dev/null
+++ b/src/openai/types/beta/chatkit/thread_delete_response.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["ThreadDeleteResponse"]
+
+
+class ThreadDeleteResponse(BaseModel):
+    id: str
+    """Identifier of the deleted thread."""
+
+    deleted: bool
+    """Indicates that the thread has been deleted."""
+
+    object: Literal["chatkit.thread.deleted"]
+    """Type discriminator that is always `chatkit.thread.deleted`."""
diff --git a/src/openai/types/beta/chatkit/thread_list_items_params.py b/src/openai/types/beta/chatkit/thread_list_items_params.py
new file mode 100644
index 0000000000..95c959d719
--- /dev/null
+++ b/src/openai/types/beta/chatkit/thread_list_items_params.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["ThreadListItemsParams"]
+
+
+class ThreadListItemsParams(TypedDict, total=False):
+    after: str
+    """List items created after this thread item ID.
+
+    Defaults to null for the first page.
+    """
+
+    before: str
+    """List items created before this thread item ID.
+
+    Defaults to null for the newest results.
+    """
+
+    limit: int
+    """Maximum number of thread items to return. Defaults to 20."""
+
+    order: Literal["asc", "desc"]
+    """Sort order for results by creation time. Defaults to `desc`."""
diff --git a/src/openai/types/beta/chatkit/thread_list_params.py b/src/openai/types/beta/chatkit/thread_list_params.py
new file mode 100644
index 0000000000..bb759c7ea3
--- /dev/null
+++ b/src/openai/types/beta/chatkit/thread_list_params.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["ThreadListParams"]
+
+
+class ThreadListParams(TypedDict, total=False):
+    after: str
+    """List items created after this thread item ID.
+
+    Defaults to null for the first page.
+    """
+
+    before: str
+    """List items created before this thread item ID.
+
+    Defaults to null for the newest results.
+    """
+
+    limit: int
+    """Maximum number of thread items to return. Defaults to 20."""
+
+    order: Literal["asc", "desc"]
+    """Sort order for results by creation time. Defaults to `desc`."""
+
+    user: str
+    """Filter threads that belong to this user identifier.
+
+    Defaults to null to return all users.
+    """
diff --git a/src/openai/types/beta/chatkit_workflow.py b/src/openai/types/beta/chatkit_workflow.py
new file mode 100644
index 0000000000..00fbcf41ce
--- /dev/null
+++ b/src/openai/types/beta/chatkit_workflow.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Union, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["ChatKitWorkflow", "Tracing"]
+
+
+class Tracing(BaseModel):
+    enabled: bool
+    """Indicates whether tracing is enabled."""
+
+
+class ChatKitWorkflow(BaseModel):
+    id: str
+    """Identifier of the workflow backing the session."""
+
+    state_variables: Optional[Dict[str, Union[str, bool, float]]] = None
+    """State variable key-value pairs applied when invoking the workflow.
+
+    Defaults to null when no overrides were provided.
+    """
+
+    tracing: Tracing
+    """Tracing settings applied to the workflow."""
+
+    version: Optional[str] = None
+    """Specific workflow version used for the session.
+
+    Defaults to null when using the latest deployment.
+    """
diff --git a/src/openai/types/beta/realtime/__init__.py b/src/openai/types/beta/realtime/__init__.py
index cd0616dcfa..0374b9b457 100644
--- a/src/openai/types/beta/realtime/__init__.py
+++ b/src/openai/types/beta/realtime/__init__.py
@@ -15,6 +15,7 @@
 from .session_create_params import SessionCreateParams as SessionCreateParams
 from .session_created_event import SessionCreatedEvent as SessionCreatedEvent
 from .session_updated_event import SessionUpdatedEvent as SessionUpdatedEvent
+from .transcription_session import TranscriptionSession as TranscriptionSession
 from .response_created_event import ResponseCreatedEvent as ResponseCreatedEvent
 from .conversation_item_param import ConversationItemParam as ConversationItemParam
 from .realtime_connect_params import RealtimeConnectParams as RealtimeConnectParams
@@ -32,6 +33,7 @@
 from .realtime_client_event_param import RealtimeClientEventParam as RealtimeClientEventParam
 from .response_cancel_event_param import ResponseCancelEventParam as ResponseCancelEventParam
 from .response_create_event_param import ResponseCreateEventParam as ResponseCreateEventParam
+from .transcription_session_update import TranscriptionSessionUpdate as TranscriptionSessionUpdate
 from .conversation_item_create_event import ConversationItemCreateEvent as ConversationItemCreateEvent
 from .conversation_item_delete_event import ConversationItemDeleteEvent as ConversationItemDeleteEvent
 from .input_audio_buffer_clear_event import InputAudioBufferClearEvent as InputAudioBufferClearEvent
@@ -41,6 +43,7 @@
 from .input_audio_buffer_append_event import InputAudioBufferAppendEvent as InputAudioBufferAppendEvent
 from .input_audio_buffer_commit_event import InputAudioBufferCommitEvent as InputAudioBufferCommitEvent
 from .response_output_item_done_event import ResponseOutputItemDoneEvent as ResponseOutputItemDoneEvent
+from .conversation_item_retrieve_event import ConversationItemRetrieveEvent as ConversationItemRetrieveEvent
 from .conversation_item_truncate_event import ConversationItemTruncateEvent as ConversationItemTruncateEvent
 from .conversation_item_with_reference import ConversationItemWithReference as ConversationItemWithReference
 from .input_audio_buffer_cleared_event import InputAudioBufferClearedEvent as InputAudioBufferClearedEvent
@@ -49,6 +52,9 @@
 from .conversation_item_truncated_event import ConversationItemTruncatedEvent as ConversationItemTruncatedEvent
 from .response_content_part_added_event import ResponseContentPartAddedEvent as ResponseContentPartAddedEvent
 from .input_audio_buffer_committed_event import InputAudioBufferCommittedEvent as InputAudioBufferCommittedEvent
+from .transcription_session_update_param import TranscriptionSessionUpdateParam as TranscriptionSessionUpdateParam
+from .transcription_session_create_params import TranscriptionSessionCreateParams as TranscriptionSessionCreateParams
+from .transcription_session_updated_event import TranscriptionSessionUpdatedEvent as TranscriptionSessionUpdatedEvent
 from .conversation_item_create_event_param import ConversationItemCreateEventParam as ConversationItemCreateEventParam
 from .conversation_item_delete_event_param import ConversationItemDeleteEventParam as ConversationItemDeleteEventParam
 from .input_audio_buffer_clear_event_param import InputAudioBufferClearEventParam as InputAudioBufferClearEventParam
@@ -58,6 +64,9 @@
 from .response_audio_transcript_delta_event import (
     ResponseAudioTranscriptDeltaEvent as ResponseAudioTranscriptDeltaEvent,
 )
+from .conversation_item_retrieve_event_param import (
+    ConversationItemRetrieveEventParam as ConversationItemRetrieveEventParam,
+)
 from .conversation_item_truncate_event_param import (
     ConversationItemTruncateEventParam as ConversationItemTruncateEventParam,
 )
@@ -76,6 +85,9 @@
 from .response_function_call_arguments_delta_event import (
     ResponseFunctionCallArgumentsDeltaEvent as ResponseFunctionCallArgumentsDeltaEvent,
 )
+from .conversation_item_input_audio_transcription_delta_event import (
+    ConversationItemInputAudioTranscriptionDeltaEvent as ConversationItemInputAudioTranscriptionDeltaEvent,
+)
 from .conversation_item_input_audio_transcription_failed_event import (
     ConversationItemInputAudioTranscriptionFailedEvent as ConversationItemInputAudioTranscriptionFailedEvent,
 )
diff --git a/src/openai/types/beta/realtime/conversation_item.py b/src/openai/types/beta/realtime/conversation_item.py
index 4edf6c4d5f..21b7a8ac1f 100644
--- a/src/openai/types/beta/realtime/conversation_item.py
+++ b/src/openai/types/beta/realtime/conversation_item.py
@@ -50,8 +50,8 @@ class ConversationItem(BaseModel):
     for `message` items.
     """
 
-    status: Optional[Literal["completed", "incomplete"]] = None
-    """The status of the item (`completed`, `incomplete`).
+    status: Optional[Literal["completed", "incomplete", "in_progress"]] = None
+    """The status of the item (`completed`, `incomplete`, `in_progress`).
 
     These have no effect on the conversation, but are accepted for consistency with
     the `conversation.item.created` event.
diff --git a/src/openai/types/beta/realtime/conversation_item_content.py b/src/openai/types/beta/realtime/conversation_item_content.py
index ab40a4a1a7..fe9cef80e3 100644
--- a/src/openai/types/beta/realtime/conversation_item_content.py
+++ b/src/openai/types/beta/realtime/conversation_item_content.py
@@ -23,7 +23,10 @@ class ConversationItemContent(BaseModel):
     """The text content, used for `input_text` and `text` content types."""
 
     transcript: Optional[str] = None
-    """The transcript of the audio, used for `input_audio` content type."""
+    """The transcript of the audio, used for `input_audio` and `audio` content types."""
 
-    type: Optional[Literal["input_text", "input_audio", "item_reference", "text"]] = None
-    """The content type (`input_text`, `input_audio`, `item_reference`, `text`)."""
+    type: Optional[Literal["input_text", "input_audio", "item_reference", "text", "audio"]] = None
+    """
+    The content type (`input_text`, `input_audio`, `item_reference`, `text`,
+    `audio`).
+    """
diff --git a/src/openai/types/beta/realtime/conversation_item_content_param.py b/src/openai/types/beta/realtime/conversation_item_content_param.py
index 7a3a92a39d..6042e7f90f 100644
--- a/src/openai/types/beta/realtime/conversation_item_content_param.py
+++ b/src/openai/types/beta/realtime/conversation_item_content_param.py
@@ -22,7 +22,10 @@ class ConversationItemContentParam(TypedDict, total=False):
     """The text content, used for `input_text` and `text` content types."""
 
     transcript: str
-    """The transcript of the audio, used for `input_audio` content type."""
+    """The transcript of the audio, used for `input_audio` and `audio` content types."""
 
-    type: Literal["input_text", "input_audio", "item_reference", "text"]
-    """The content type (`input_text`, `input_audio`, `item_reference`, `text`)."""
+    type: Literal["input_text", "input_audio", "item_reference", "text", "audio"]
+    """
+    The content type (`input_text`, `input_audio`, `item_reference`, `text`,
+    `audio`).
+    """
diff --git a/src/openai/types/beta/realtime/conversation_item_created_event.py b/src/openai/types/beta/realtime/conversation_item_created_event.py
index 2f20388246..aea7ad5b4b 100644
--- a/src/openai/types/beta/realtime/conversation_item_created_event.py
+++ b/src/openai/types/beta/realtime/conversation_item_created_event.py
@@ -1,5 +1,6 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import Optional
 from typing_extensions import Literal
 
 from ...._models import BaseModel
@@ -15,11 +16,12 @@ class ConversationItemCreatedEvent(BaseModel):
     item: ConversationItem
     """The item to add to the conversation."""
 
-    previous_item_id: str
+    type: Literal["conversation.item.created"]
+    """The event type, must be `conversation.item.created`."""
+
+    previous_item_id: Optional[str] = None
     """
     The ID of the preceding item in the Conversation context, allows the client to
-    understand the order of the conversation.
+    understand the order of the conversation. Can be `null` if the item has no
+    predecessor.
     """
-
-    type: Literal["conversation.item.created"]
-    """The event type, must be `conversation.item.created`."""
diff --git a/src/openai/types/beta/realtime/conversation_item_input_audio_transcription_completed_event.py b/src/openai/types/beta/realtime/conversation_item_input_audio_transcription_completed_event.py
index ded79cc0f7..e7c457d4b2 100644
--- a/src/openai/types/beta/realtime/conversation_item_input_audio_transcription_completed_event.py
+++ b/src/openai/types/beta/realtime/conversation_item_input_audio_transcription_completed_event.py
@@ -1,10 +1,65 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing_extensions import Literal
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
 
 from ...._models import BaseModel
 
-__all__ = ["ConversationItemInputAudioTranscriptionCompletedEvent"]
+__all__ = [
+    "ConversationItemInputAudioTranscriptionCompletedEvent",
+    "Usage",
+    "UsageTranscriptTextUsageTokens",
+    "UsageTranscriptTextUsageTokensInputTokenDetails",
+    "UsageTranscriptTextUsageDuration",
+    "Logprob",
+]
+
+
+class UsageTranscriptTextUsageTokensInputTokenDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """Number of audio tokens billed for this request."""
+
+    text_tokens: Optional[int] = None
+    """Number of text tokens billed for this request."""
+
+
+class UsageTranscriptTextUsageTokens(BaseModel):
+    input_tokens: int
+    """Number of input tokens billed for this request."""
+
+    output_tokens: int
+    """Number of output tokens generated."""
+
+    total_tokens: int
+    """Total number of tokens used (input + output)."""
+
+    type: Literal["tokens"]
+    """The type of the usage object. Always `tokens` for this variant."""
+
+    input_token_details: Optional[UsageTranscriptTextUsageTokensInputTokenDetails] = None
+    """Details about the input tokens billed for this request."""
+
+
+class UsageTranscriptTextUsageDuration(BaseModel):
+    seconds: float
+    """Duration of the input audio in seconds."""
+
+    type: Literal["duration"]
+    """The type of the usage object. Always `duration` for this variant."""
+
+
+Usage: TypeAlias = Union[UsageTranscriptTextUsageTokens, UsageTranscriptTextUsageDuration]
+
+
+class Logprob(BaseModel):
+    token: str
+    """The token that was used to generate the log probability."""
+
+    bytes: List[int]
+    """The bytes that were used to generate the log probability."""
+
+    logprob: float
+    """The log probability of the token."""
 
 
 class ConversationItemInputAudioTranscriptionCompletedEvent(BaseModel):
@@ -24,3 +79,9 @@ class ConversationItemInputAudioTranscriptionCompletedEvent(BaseModel):
     """
     The event type, must be `conversation.item.input_audio_transcription.completed`.
     """
+
+    usage: Usage
+    """Usage statistics for the transcription."""
+
+    logprobs: Optional[List[Logprob]] = None
+    """The log probabilities of the transcription."""
diff --git a/src/openai/types/beta/realtime/conversation_item_input_audio_transcription_delta_event.py b/src/openai/types/beta/realtime/conversation_item_input_audio_transcription_delta_event.py
new file mode 100644
index 0000000000..924d06d98a
--- /dev/null
+++ b/src/openai/types/beta/realtime/conversation_item_input_audio_transcription_delta_event.py
@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["ConversationItemInputAudioTranscriptionDeltaEvent", "Logprob"]
+
+
+class Logprob(BaseModel):
+    token: str
+    """The token that was used to generate the log probability."""
+
+    bytes: List[int]
+    """The bytes that were used to generate the log probability."""
+
+    logprob: float
+    """The log probability of the token."""
+
+
+class ConversationItemInputAudioTranscriptionDeltaEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    type: Literal["conversation.item.input_audio_transcription.delta"]
+    """The event type, must be `conversation.item.input_audio_transcription.delta`."""
+
+    content_index: Optional[int] = None
+    """The index of the content part in the item's content array."""
+
+    delta: Optional[str] = None
+    """The text delta."""
+
+    logprobs: Optional[List[Logprob]] = None
+    """The log probabilities of the transcription."""
diff --git a/src/openai/types/beta/realtime/conversation_item_param.py b/src/openai/types/beta/realtime/conversation_item_param.py
index ac0f8431e5..8bbd539c0c 100644
--- a/src/openai/types/beta/realtime/conversation_item_param.py
+++ b/src/openai/types/beta/realtime/conversation_item_param.py
@@ -51,8 +51,8 @@ class ConversationItemParam(TypedDict, total=False):
     for `message` items.
     """
 
-    status: Literal["completed", "incomplete"]
-    """The status of the item (`completed`, `incomplete`).
+    status: Literal["completed", "incomplete", "in_progress"]
+    """The status of the item (`completed`, `incomplete`, `in_progress`).
 
     These have no effect on the conversation, but are accepted for consistency with
     the `conversation.item.created` event.
diff --git a/src/openai/types/beta/realtime/conversation_item_retrieve_event.py b/src/openai/types/beta/realtime/conversation_item_retrieve_event.py
new file mode 100644
index 0000000000..822386055c
--- /dev/null
+++ b/src/openai/types/beta/realtime/conversation_item_retrieve_event.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["ConversationItemRetrieveEvent"]
+
+
+class ConversationItemRetrieveEvent(BaseModel):
+    item_id: str
+    """The ID of the item to retrieve."""
+
+    type: Literal["conversation.item.retrieve"]
+    """The event type, must be `conversation.item.retrieve`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/beta/realtime/conversation_item_retrieve_event_param.py b/src/openai/types/beta/realtime/conversation_item_retrieve_event_param.py
new file mode 100644
index 0000000000..71b3ffa499
--- /dev/null
+++ b/src/openai/types/beta/realtime/conversation_item_retrieve_event_param.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ConversationItemRetrieveEventParam"]
+
+
+class ConversationItemRetrieveEventParam(TypedDict, total=False):
+    item_id: Required[str]
+    """The ID of the item to retrieve."""
+
+    type: Required[Literal["conversation.item.retrieve"]]
+    """The event type, must be `conversation.item.retrieve`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/beta/realtime/conversation_item_with_reference.py b/src/openai/types/beta/realtime/conversation_item_with_reference.py
index 31806afc33..0edcfc76b6 100644
--- a/src/openai/types/beta/realtime/conversation_item_with_reference.py
+++ b/src/openai/types/beta/realtime/conversation_item_with_reference.py
@@ -4,9 +4,29 @@
 from typing_extensions import Literal
 
 from ...._models import BaseModel
-from .conversation_item_content import ConversationItemContent
 
-__all__ = ["ConversationItemWithReference"]
+__all__ = ["ConversationItemWithReference", "Content"]
+
+
+class Content(BaseModel):
+    id: Optional[str] = None
+    """
+    ID of a previous conversation item to reference (for `item_reference` content
+    types in `response.create` events). These can reference both client and server
+    created items.
+    """
+
+    audio: Optional[str] = None
+    """Base64-encoded audio bytes, used for `input_audio` content type."""
+
+    text: Optional[str] = None
+    """The text content, used for `input_text` and `text` content types."""
+
+    transcript: Optional[str] = None
+    """The transcript of the audio, used for `input_audio` content type."""
+
+    type: Optional[Literal["input_text", "input_audio", "item_reference", "text"]] = None
+    """The content type (`input_text`, `input_audio`, `item_reference`, `text`)."""
 
 
 class ConversationItemWithReference(BaseModel):
@@ -30,7 +50,7 @@ class ConversationItemWithReference(BaseModel):
     `function_call` item with the same ID exists in the conversation history.
     """
 
-    content: Optional[List[ConversationItemContent]] = None
+    content: Optional[List[Content]] = None
     """The content of the message, applicable for `message` items.
 
     - Message items of role `system` support only `input_text` content
@@ -53,8 +73,8 @@ class ConversationItemWithReference(BaseModel):
     for `message` items.
     """
 
-    status: Optional[Literal["completed", "incomplete"]] = None
-    """The status of the item (`completed`, `incomplete`).
+    status: Optional[Literal["completed", "incomplete", "in_progress"]] = None
+    """The status of the item (`completed`, `incomplete`, `in_progress`).
 
     These have no effect on the conversation, but are accepted for consistency with
     the `conversation.item.created` event.
diff --git a/src/openai/types/beta/realtime/conversation_item_with_reference_param.py b/src/openai/types/beta/realtime/conversation_item_with_reference_param.py
index e266cdce32..c83dc92ab7 100644
--- a/src/openai/types/beta/realtime/conversation_item_with_reference_param.py
+++ b/src/openai/types/beta/realtime/conversation_item_with_reference_param.py
@@ -5,9 +5,28 @@
 from typing import Iterable
 from typing_extensions import Literal, TypedDict
 
-from .conversation_item_content_param import ConversationItemContentParam
+__all__ = ["ConversationItemWithReferenceParam", "Content"]
 
-__all__ = ["ConversationItemWithReferenceParam"]
+
+class Content(TypedDict, total=False):
+    id: str
+    """
+    ID of a previous conversation item to reference (for `item_reference` content
+    types in `response.create` events). These can reference both client and server
+    created items.
+    """
+
+    audio: str
+    """Base64-encoded audio bytes, used for `input_audio` content type."""
+
+    text: str
+    """The text content, used for `input_text` and `text` content types."""
+
+    transcript: str
+    """The transcript of the audio, used for `input_audio` content type."""
+
+    type: Literal["input_text", "input_audio", "item_reference", "text"]
+    """The content type (`input_text`, `input_audio`, `item_reference`, `text`)."""
 
 
 class ConversationItemWithReferenceParam(TypedDict, total=False):
@@ -31,7 +50,7 @@ class ConversationItemWithReferenceParam(TypedDict, total=False):
     `function_call` item with the same ID exists in the conversation history.
     """
 
-    content: Iterable[ConversationItemContentParam]
+    content: Iterable[Content]
     """The content of the message, applicable for `message` items.
 
     - Message items of role `system` support only `input_text` content
@@ -54,8 +73,8 @@ class ConversationItemWithReferenceParam(TypedDict, total=False):
     for `message` items.
     """
 
-    status: Literal["completed", "incomplete"]
-    """The status of the item (`completed`, `incomplete`).
+    status: Literal["completed", "incomplete", "in_progress"]
+    """The status of the item (`completed`, `incomplete`, `in_progress`).
 
     These have no effect on the conversation, but are accepted for consistency with
     the `conversation.item.created` event.
diff --git a/src/openai/types/beta/realtime/input_audio_buffer_committed_event.py b/src/openai/types/beta/realtime/input_audio_buffer_committed_event.py
index 3071eff357..22eb53b117 100644
--- a/src/openai/types/beta/realtime/input_audio_buffer_committed_event.py
+++ b/src/openai/types/beta/realtime/input_audio_buffer_committed_event.py
@@ -1,5 +1,6 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import Optional
 from typing_extensions import Literal
 
 from ...._models import BaseModel
@@ -14,8 +15,11 @@ class InputAudioBufferCommittedEvent(BaseModel):
     item_id: str
     """The ID of the user message item that will be created."""
 
-    previous_item_id: str
-    """The ID of the preceding item after which the new item will be inserted."""
-
     type: Literal["input_audio_buffer.committed"]
     """The event type, must be `input_audio_buffer.committed`."""
+
+    previous_item_id: Optional[str] = None
+    """
+    The ID of the preceding item after which the new item will be inserted. Can be
+    `null` if the item has no predecessor.
+    """
diff --git a/src/openai/types/beta/realtime/realtime_client_event.py b/src/openai/types/beta/realtime/realtime_client_event.py
index 0769184cd0..5f4858d688 100644
--- a/src/openai/types/beta/realtime/realtime_client_event.py
+++ b/src/openai/types/beta/realtime/realtime_client_event.py
@@ -1,32 +1,47 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Union
-from typing_extensions import Annotated, TypeAlias
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
 
 from ...._utils import PropertyInfo
+from ...._models import BaseModel
 from .session_update_event import SessionUpdateEvent
 from .response_cancel_event import ResponseCancelEvent
 from .response_create_event import ResponseCreateEvent
+from .transcription_session_update import TranscriptionSessionUpdate
 from .conversation_item_create_event import ConversationItemCreateEvent
 from .conversation_item_delete_event import ConversationItemDeleteEvent
 from .input_audio_buffer_clear_event import InputAudioBufferClearEvent
 from .input_audio_buffer_append_event import InputAudioBufferAppendEvent
 from .input_audio_buffer_commit_event import InputAudioBufferCommitEvent
+from .conversation_item_retrieve_event import ConversationItemRetrieveEvent
 from .conversation_item_truncate_event import ConversationItemTruncateEvent
 
-__all__ = ["RealtimeClientEvent"]
+__all__ = ["RealtimeClientEvent", "OutputAudioBufferClear"]
+
+
+class OutputAudioBufferClear(BaseModel):
+    type: Literal["output_audio_buffer.clear"]
+    """The event type, must be `output_audio_buffer.clear`."""
+
+    event_id: Optional[str] = None
+    """The unique ID of the client event used for error handling."""
+
 
 RealtimeClientEvent: TypeAlias = Annotated[
     Union[
-        SessionUpdateEvent,
-        InputAudioBufferAppendEvent,
-        InputAudioBufferCommitEvent,
-        InputAudioBufferClearEvent,
         ConversationItemCreateEvent,
-        ConversationItemTruncateEvent,
         ConversationItemDeleteEvent,
-        ResponseCreateEvent,
+        ConversationItemRetrieveEvent,
+        ConversationItemTruncateEvent,
+        InputAudioBufferAppendEvent,
+        InputAudioBufferClearEvent,
+        OutputAudioBufferClear,
+        InputAudioBufferCommitEvent,
         ResponseCancelEvent,
+        ResponseCreateEvent,
+        SessionUpdateEvent,
+        TranscriptionSessionUpdate,
     ],
     PropertyInfo(discriminator="type"),
 ]
diff --git a/src/openai/types/beta/realtime/realtime_client_event_param.py b/src/openai/types/beta/realtime/realtime_client_event_param.py
index 4020892c33..e7dfba241e 100644
--- a/src/openai/types/beta/realtime/realtime_client_event_param.py
+++ b/src/openai/types/beta/realtime/realtime_client_event_param.py
@@ -3,28 +3,42 @@
 from __future__ import annotations
 
 from typing import Union
-from typing_extensions import TypeAlias
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
 from .session_update_event_param import SessionUpdateEventParam
 from .response_cancel_event_param import ResponseCancelEventParam
 from .response_create_event_param import ResponseCreateEventParam
+from .transcription_session_update_param import TranscriptionSessionUpdateParam
 from .conversation_item_create_event_param import ConversationItemCreateEventParam
 from .conversation_item_delete_event_param import ConversationItemDeleteEventParam
 from .input_audio_buffer_clear_event_param import InputAudioBufferClearEventParam
 from .input_audio_buffer_append_event_param import InputAudioBufferAppendEventParam
 from .input_audio_buffer_commit_event_param import InputAudioBufferCommitEventParam
+from .conversation_item_retrieve_event_param import ConversationItemRetrieveEventParam
 from .conversation_item_truncate_event_param import ConversationItemTruncateEventParam
 
-__all__ = ["RealtimeClientEventParam"]
+__all__ = ["RealtimeClientEventParam", "OutputAudioBufferClear"]
+
+
+class OutputAudioBufferClear(TypedDict, total=False):
+    type: Required[Literal["output_audio_buffer.clear"]]
+    """The event type, must be `output_audio_buffer.clear`."""
+
+    event_id: str
+    """The unique ID of the client event used for error handling."""
+
 
 RealtimeClientEventParam: TypeAlias = Union[
-    SessionUpdateEventParam,
-    InputAudioBufferAppendEventParam,
-    InputAudioBufferCommitEventParam,
-    InputAudioBufferClearEventParam,
     ConversationItemCreateEventParam,
-    ConversationItemTruncateEventParam,
     ConversationItemDeleteEventParam,
-    ResponseCreateEventParam,
+    ConversationItemRetrieveEventParam,
+    ConversationItemTruncateEventParam,
+    InputAudioBufferAppendEventParam,
+    InputAudioBufferClearEventParam,
+    OutputAudioBufferClear,
+    InputAudioBufferCommitEventParam,
     ResponseCancelEventParam,
+    ResponseCreateEventParam,
+    SessionUpdateEventParam,
+    TranscriptionSessionUpdateParam,
 ]
diff --git a/src/openai/types/beta/realtime/realtime_response.py b/src/openai/types/beta/realtime/realtime_response.py
index 4c3c83d666..ccc97c5d22 100644
--- a/src/openai/types/beta/realtime/realtime_response.py
+++ b/src/openai/types/beta/realtime/realtime_response.py
@@ -60,10 +60,10 @@ class RealtimeResponse(BaseModel):
     output_audio_format: Optional[Literal["pcm16", "g711_ulaw", "g711_alaw"]] = None
     """The format of output audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`."""
 
-    status: Optional[Literal["completed", "cancelled", "failed", "incomplete"]] = None
+    status: Optional[Literal["completed", "cancelled", "failed", "incomplete", "in_progress"]] = None
     """
     The final status of the response (`completed`, `cancelled`, `failed`, or
-    `incomplete`).
+    `incomplete`, `in_progress`).
     """
 
     status_details: Optional[RealtimeResponseStatus] = None
@@ -80,8 +80,8 @@ class RealtimeResponse(BaseModel):
     will become the input for later turns.
     """
 
-    voice: Optional[Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]] = None
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"], None] = None
     """
     The voice the model used to respond. Current voice options are `alloy`, `ash`,
-    `ballad`, `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `ballad`, `coral`, `echo`, `sage`, `shimmer`, and `verse`.
     """
diff --git a/src/openai/types/beta/realtime/realtime_server_event.py b/src/openai/types/beta/realtime/realtime_server_event.py
index 5f8ed55b13..c12f5df977 100644
--- a/src/openai/types/beta/realtime/realtime_server_event.py
+++ b/src/openai/types/beta/realtime/realtime_server_event.py
@@ -1,10 +1,12 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import Union
-from typing_extensions import Annotated, TypeAlias
+from typing_extensions import Literal, Annotated, TypeAlias
 
 from ...._utils import PropertyInfo
+from ...._models import BaseModel
 from .error_event import ErrorEvent
+from .conversation_item import ConversationItem
 from .response_done_event import ResponseDoneEvent
 from .session_created_event import SessionCreatedEvent
 from .session_updated_event import SessionUpdatedEvent
@@ -24,49 +26,108 @@
 from .conversation_item_truncated_event import ConversationItemTruncatedEvent
 from .response_content_part_added_event import ResponseContentPartAddedEvent
 from .input_audio_buffer_committed_event import InputAudioBufferCommittedEvent
+from .transcription_session_updated_event import TranscriptionSessionUpdatedEvent
 from .response_audio_transcript_done_event import ResponseAudioTranscriptDoneEvent
 from .response_audio_transcript_delta_event import ResponseAudioTranscriptDeltaEvent
 from .input_audio_buffer_speech_started_event import InputAudioBufferSpeechStartedEvent
 from .input_audio_buffer_speech_stopped_event import InputAudioBufferSpeechStoppedEvent
 from .response_function_call_arguments_done_event import ResponseFunctionCallArgumentsDoneEvent
 from .response_function_call_arguments_delta_event import ResponseFunctionCallArgumentsDeltaEvent
+from .conversation_item_input_audio_transcription_delta_event import ConversationItemInputAudioTranscriptionDeltaEvent
 from .conversation_item_input_audio_transcription_failed_event import ConversationItemInputAudioTranscriptionFailedEvent
 from .conversation_item_input_audio_transcription_completed_event import (
     ConversationItemInputAudioTranscriptionCompletedEvent,
 )
 
-__all__ = ["RealtimeServerEvent"]
+__all__ = [
+    "RealtimeServerEvent",
+    "ConversationItemRetrieved",
+    "OutputAudioBufferStarted",
+    "OutputAudioBufferStopped",
+    "OutputAudioBufferCleared",
+]
+
+
+class ConversationItemRetrieved(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """The item to add to the conversation."""
+
+    type: Literal["conversation.item.retrieved"]
+    """The event type, must be `conversation.item.retrieved`."""
+
+
+class OutputAudioBufferStarted(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response_id: str
+    """The unique ID of the response that produced the audio."""
+
+    type: Literal["output_audio_buffer.started"]
+    """The event type, must be `output_audio_buffer.started`."""
+
+
+class OutputAudioBufferStopped(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response_id: str
+    """The unique ID of the response that produced the audio."""
+
+    type: Literal["output_audio_buffer.stopped"]
+    """The event type, must be `output_audio_buffer.stopped`."""
+
+
+class OutputAudioBufferCleared(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response_id: str
+    """The unique ID of the response that produced the audio."""
+
+    type: Literal["output_audio_buffer.cleared"]
+    """The event type, must be `output_audio_buffer.cleared`."""
+
 
 RealtimeServerEvent: TypeAlias = Annotated[
     Union[
-        ErrorEvent,
-        SessionCreatedEvent,
-        SessionUpdatedEvent,
         ConversationCreatedEvent,
-        InputAudioBufferCommittedEvent,
-        InputAudioBufferClearedEvent,
-        InputAudioBufferSpeechStartedEvent,
-        InputAudioBufferSpeechStoppedEvent,
         ConversationItemCreatedEvent,
+        ConversationItemDeletedEvent,
         ConversationItemInputAudioTranscriptionCompletedEvent,
+        ConversationItemInputAudioTranscriptionDeltaEvent,
         ConversationItemInputAudioTranscriptionFailedEvent,
+        ConversationItemRetrieved,
         ConversationItemTruncatedEvent,
-        ConversationItemDeletedEvent,
+        ErrorEvent,
+        InputAudioBufferClearedEvent,
+        InputAudioBufferCommittedEvent,
+        InputAudioBufferSpeechStartedEvent,
+        InputAudioBufferSpeechStoppedEvent,
+        RateLimitsUpdatedEvent,
+        ResponseAudioDeltaEvent,
+        ResponseAudioDoneEvent,
+        ResponseAudioTranscriptDeltaEvent,
+        ResponseAudioTranscriptDoneEvent,
+        ResponseContentPartAddedEvent,
+        ResponseContentPartDoneEvent,
         ResponseCreatedEvent,
         ResponseDoneEvent,
+        ResponseFunctionCallArgumentsDeltaEvent,
+        ResponseFunctionCallArgumentsDoneEvent,
         ResponseOutputItemAddedEvent,
         ResponseOutputItemDoneEvent,
-        ResponseContentPartAddedEvent,
-        ResponseContentPartDoneEvent,
         ResponseTextDeltaEvent,
         ResponseTextDoneEvent,
-        ResponseAudioTranscriptDeltaEvent,
-        ResponseAudioTranscriptDoneEvent,
-        ResponseAudioDeltaEvent,
-        ResponseAudioDoneEvent,
-        ResponseFunctionCallArgumentsDeltaEvent,
-        ResponseFunctionCallArgumentsDoneEvent,
-        RateLimitsUpdatedEvent,
+        SessionCreatedEvent,
+        SessionUpdatedEvent,
+        TranscriptionSessionUpdatedEvent,
+        OutputAudioBufferStarted,
+        OutputAudioBufferStopped,
+        OutputAudioBufferCleared,
     ],
     PropertyInfo(discriminator="type"),
 ]
diff --git a/src/openai/types/beta/realtime/response_create_event.py b/src/openai/types/beta/realtime/response_create_event.py
index d6c5fda926..7219cedbf3 100644
--- a/src/openai/types/beta/realtime/response_create_event.py
+++ b/src/openai/types/beta/realtime/response_create_event.py
@@ -101,12 +101,12 @@ class Response(BaseModel):
     tools: Optional[List[ResponseTool]] = None
     """Tools (functions) available to the model."""
 
-    voice: Optional[Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]] = None
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"], None] = None
     """The voice the model uses to respond.
 
     Voice cannot be changed during the session once the model has responded with
     audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
-    `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `coral`, `echo`, `sage`, `shimmer`, and `verse`.
     """
 
 
diff --git a/src/openai/types/beta/realtime/response_create_event_param.py b/src/openai/types/beta/realtime/response_create_event_param.py
index c02fe1b34e..b4d54bba92 100644
--- a/src/openai/types/beta/realtime/response_create_event_param.py
+++ b/src/openai/types/beta/realtime/response_create_event_param.py
@@ -102,12 +102,12 @@ class Response(TypedDict, total=False):
     tools: Iterable[ResponseTool]
     """Tools (functions) available to the model."""
 
-    voice: Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]]
     """The voice the model uses to respond.
 
     Voice cannot be changed during the session once the model has responded with
     audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
-    `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `coral`, `echo`, `sage`, `shimmer`, and `verse`.
     """
 
 
diff --git a/src/openai/types/beta/realtime/session.py b/src/openai/types/beta/realtime/session.py
index aee20fa906..2e099a2e98 100644
--- a/src/openai/types/beta/realtime/session.py
+++ b/src/openai/types/beta/realtime/session.py
@@ -1,18 +1,52 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import List, Union, Optional
-from typing_extensions import Literal
+from typing_extensions import Literal, TypeAlias
 
 from ...._models import BaseModel
 
-__all__ = ["Session", "InputAudioTranscription", "Tool", "TurnDetection"]
+__all__ = [
+    "Session",
+    "InputAudioNoiseReduction",
+    "InputAudioTranscription",
+    "Tool",
+    "Tracing",
+    "TracingTracingConfiguration",
+    "TurnDetection",
+]
+
+
+class InputAudioNoiseReduction(BaseModel):
+    type: Optional[Literal["near_field", "far_field"]] = None
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
 
 
 class InputAudioTranscription(BaseModel):
+    language: Optional[str] = None
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
     model: Optional[str] = None
     """
-    The model to use for transcription, `whisper-1` is the only currently supported
-    model.
+    The model to use for transcription, current options are `gpt-4o-transcribe`,
+    `gpt-4o-mini-transcribe`, and `whisper-1`.
+    """
+
+    prompt: Optional[str] = None
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+    "expect words related to technology".
     """
 
 
@@ -33,48 +67,81 @@ class Tool(BaseModel):
     """The type of the tool, i.e. `function`."""
 
 
+class TracingTracingConfiguration(BaseModel):
+    group_id: Optional[str] = None
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    traces dashboard.
+    """
+
+    metadata: Optional[object] = None
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the traces
+    dashboard.
+    """
+
+    workflow_name: Optional[str] = None
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the traces dashboard.
+    """
+
+
+Tracing: TypeAlias = Union[Literal["auto"], TracingTracingConfiguration]
+
+
 class TurnDetection(BaseModel):
     create_response: Optional[bool] = None
-    """Whether or not to automatically generate a response when a VAD stop event
+    """
+    Whether or not to automatically generate a response when a VAD stop event
     occurs.
+    """
+
+    eagerness: Optional[Literal["low", "medium", "high", "auto"]] = None
+    """Used only for `semantic_vad` mode.
 
-    `true` by default.
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`.
     """
 
     interrupt_response: Optional[bool] = None
     """
     Whether or not to automatically interrupt any ongoing response with output to
     the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-    occurs. `true` by default.
+    occurs.
     """
 
     prefix_padding_ms: Optional[int] = None
-    """Amount of audio to include before the VAD detected speech (in milliseconds).
+    """Used only for `server_vad` mode.
 
+    Amount of audio to include before the VAD detected speech (in milliseconds).
     Defaults to 300ms.
     """
 
     silence_duration_ms: Optional[int] = None
-    """Duration of silence to detect speech stop (in milliseconds).
+    """Used only for `server_vad` mode.
 
-    Defaults to 500ms. With shorter values the model will respond more quickly, but
-    may jump in on short pauses from the user.
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
     """
 
     threshold: Optional[float] = None
-    """Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5.
+    """Used only for `server_vad` mode.
 
-    A higher threshold will require louder audio to activate the model, and thus
-    might perform better in noisy environments.
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
     """
 
-    type: Optional[Literal["server_vad"]] = None
-    """Type of turn detection, only `server_vad` is currently supported."""
+    type: Optional[Literal["server_vad", "semantic_vad"]] = None
+    """Type of turn detection."""
 
 
 class Session(BaseModel):
     id: Optional[str] = None
-    """Unique identifier for the session object."""
+    """Unique identifier for the session that looks like `sess_1234567890abcdef`."""
 
     input_audio_format: Optional[Literal["pcm16", "g711_ulaw", "g711_alaw"]] = None
     """The format of input audio.
@@ -84,13 +151,25 @@ class Session(BaseModel):
     byte order.
     """
 
+    input_audio_noise_reduction: Optional[InputAudioNoiseReduction] = None
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
     input_audio_transcription: Optional[InputAudioTranscription] = None
     """
     Configuration for input audio transcription, defaults to off and can be set to
     `null` to turn off once on. Input audio transcription is not native to the
     model, since the model consumes audio directly. Transcription runs
-    asynchronously through Whisper and should be treated as rough guidance rather
-    than the representation understood by the model.
+    asynchronously through
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
     """
 
     instructions: Optional[str] = None
@@ -122,16 +201,17 @@ class Session(BaseModel):
     To disable audio, set this to ["text"].
     """
 
-    model: Union[
-        str,
+    model: Optional[
         Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
             "gpt-4o-realtime-preview",
             "gpt-4o-realtime-preview-2024-10-01",
             "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
             "gpt-4o-mini-realtime-preview",
             "gpt-4o-mini-realtime-preview-2024-12-17",
-        ],
-        None,
+        ]
     ] = None
     """The Realtime model used for this session."""
 
@@ -142,8 +222,20 @@ class Session(BaseModel):
     sampled at a rate of 24kHz.
     """
 
+    speed: Optional[float] = None
+    """The speed of the model's spoken response.
+
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+    """
+
     temperature: Optional[float] = None
-    """Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8."""
+    """Sampling temperature for the model, limited to [0.6, 1.2].
+
+    For audio models a temperature of 0.8 is highly recommended for best
+    performance.
+    """
 
     tool_choice: Optional[str] = None
     """How the model chooses tools.
@@ -154,18 +246,34 @@ class Session(BaseModel):
     tools: Optional[List[Tool]] = None
     """Tools (functions) available to the model."""
 
-    turn_detection: Optional[TurnDetection] = None
-    """Configuration for turn detection.
+    tracing: Optional[Tracing] = None
+    """Configuration options for tracing.
 
-    Can be set to `null` to turn off. Server VAD means that the model will detect
-    the start and end of speech based on audio volume and respond at the end of user
-    speech.
+    Set to null to disable tracing. Once tracing is enabled for a session, the
+    configuration cannot be modified.
+
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    turn_detection: Optional[TurnDetection] = None
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response. Server VAD means that the model will detect the start
+    and end of speech based on audio volume and respond at the end of user speech.
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
     """
 
-    voice: Optional[Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]] = None
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"], None] = None
     """The voice the model uses to respond.
 
     Voice cannot be changed during the session once the model has responded with
     audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
-    `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `coral`, `echo`, `sage`, `shimmer`, and `verse`.
     """
diff --git a/src/openai/types/beta/realtime/session_create_params.py b/src/openai/types/beta/realtime/session_create_params.py
index bbc86d7c7d..38465a56c3 100644
--- a/src/openai/types/beta/realtime/session_create_params.py
+++ b/src/openai/types/beta/realtime/session_create_params.py
@@ -3,12 +3,25 @@
 from __future__ import annotations
 
 from typing import List, Union, Iterable
-from typing_extensions import Literal, TypedDict
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
-__all__ = ["SessionCreateParams", "InputAudioTranscription", "Tool", "TurnDetection"]
+__all__ = [
+    "SessionCreateParams",
+    "ClientSecret",
+    "ClientSecretExpiresAfter",
+    "InputAudioNoiseReduction",
+    "InputAudioTranscription",
+    "Tool",
+    "Tracing",
+    "TracingTracingConfiguration",
+    "TurnDetection",
+]
 
 
 class SessionCreateParams(TypedDict, total=False):
+    client_secret: ClientSecret
+    """Configuration options for the generated client secret."""
+
     input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"]
     """The format of input audio.
 
@@ -17,16 +30,25 @@ class SessionCreateParams(TypedDict, total=False):
     byte order.
     """
 
+    input_audio_noise_reduction: InputAudioNoiseReduction
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
     input_audio_transcription: InputAudioTranscription
     """
     Configuration for input audio transcription, defaults to off and can be set to
     `null` to turn off once on. Input audio transcription is not native to the
     model, since the model consumes audio directly. Transcription runs
     asynchronously through
-    [OpenAI Whisper transcription](https://platform.openai.com/docs/api-reference/audio/createTranscription)
-    and should be treated as rough guidance rather than the representation
-    understood by the model. The client can optionally set the language and prompt
-    for transcription, these fields will be passed to the Whisper API.
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
     """
 
     instructions: str
@@ -59,9 +81,12 @@ class SessionCreateParams(TypedDict, total=False):
     """
 
     model: Literal[
+        "gpt-realtime",
+        "gpt-realtime-2025-08-28",
         "gpt-4o-realtime-preview",
         "gpt-4o-realtime-preview-2024-10-01",
         "gpt-4o-realtime-preview-2024-12-17",
+        "gpt-4o-realtime-preview-2025-06-03",
         "gpt-4o-mini-realtime-preview",
         "gpt-4o-mini-realtime-preview-2024-12-17",
     ]
@@ -74,8 +99,20 @@ class SessionCreateParams(TypedDict, total=False):
     sampled at a rate of 24kHz.
     """
 
+    speed: float
+    """The speed of the model's spoken response.
+
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+    """
+
     temperature: float
-    """Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8."""
+    """Sampling temperature for the model, limited to [0.6, 1.2].
+
+    For audio models a temperature of 0.8 is highly recommended for best
+    performance.
+    """
 
     tool_choice: str
     """How the model chooses tools.
@@ -86,20 +123,64 @@ class SessionCreateParams(TypedDict, total=False):
     tools: Iterable[Tool]
     """Tools (functions) available to the model."""
 
-    turn_detection: TurnDetection
-    """Configuration for turn detection.
+    tracing: Tracing
+    """Configuration options for tracing.
+
+    Set to null to disable tracing. Once tracing is enabled for a session, the
+    configuration cannot be modified.
 
-    Can be set to `null` to turn off. Server VAD means that the model will detect
-    the start and end of speech based on audio volume and respond at the end of user
-    speech.
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
     """
 
-    voice: Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]
+    turn_detection: TurnDetection
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response. Server VAD means that the model will detect the start
+    and end of speech based on audio volume and respond at the end of user speech.
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
+
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]]
     """The voice the model uses to respond.
 
     Voice cannot be changed during the session once the model has responded with
     audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
-    `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `coral`, `echo`, `sage`, `shimmer`, and `verse`.
+    """
+
+
+class ClientSecretExpiresAfter(TypedDict, total=False):
+    anchor: Required[Literal["created_at"]]
+    """The anchor point for the ephemeral token expiration.
+
+    Only `created_at` is currently supported.
+    """
+
+    seconds: int
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200`.
+    """
+
+
+class ClientSecret(TypedDict, total=False):
+    expires_after: ClientSecretExpiresAfter
+    """Configuration for the ephemeral token expiration."""
+
+
+class InputAudioNoiseReduction(TypedDict, total=False):
+    type: Literal["near_field", "far_field"]
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
     """
 
 
@@ -114,16 +195,17 @@ class InputAudioTranscription(TypedDict, total=False):
 
     model: str
     """
-    The model to use for transcription, `whisper-1` is the only currently supported
-    model.
+    The model to use for transcription, current options are `gpt-4o-transcribe`,
+    `gpt-4o-mini-transcribe`, and `whisper-1`.
     """
 
     prompt: str
-    """An optional text to guide the model's style or continue a previous audio
-    segment.
-
-    The [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-    should match the audio language.
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+    "expect words related to technology".
     """
 
 
@@ -144,40 +226,73 @@ class Tool(TypedDict, total=False):
     """The type of the tool, i.e. `function`."""
 
 
+class TracingTracingConfiguration(TypedDict, total=False):
+    group_id: str
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    traces dashboard.
+    """
+
+    metadata: object
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the traces
+    dashboard.
+    """
+
+    workflow_name: str
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the traces dashboard.
+    """
+
+
+Tracing: TypeAlias = Union[Literal["auto"], TracingTracingConfiguration]
+
+
 class TurnDetection(TypedDict, total=False):
     create_response: bool
-    """Whether or not to automatically generate a response when a VAD stop event
+    """
+    Whether or not to automatically generate a response when a VAD stop event
     occurs.
+    """
 
-    `true` by default.
+    eagerness: Literal["low", "medium", "high", "auto"]
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`.
     """
 
     interrupt_response: bool
     """
     Whether or not to automatically interrupt any ongoing response with output to
     the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-    occurs. `true` by default.
+    occurs.
     """
 
     prefix_padding_ms: int
-    """Amount of audio to include before the VAD detected speech (in milliseconds).
+    """Used only for `server_vad` mode.
 
+    Amount of audio to include before the VAD detected speech (in milliseconds).
     Defaults to 300ms.
     """
 
     silence_duration_ms: int
-    """Duration of silence to detect speech stop (in milliseconds).
+    """Used only for `server_vad` mode.
 
-    Defaults to 500ms. With shorter values the model will respond more quickly, but
-    may jump in on short pauses from the user.
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
     """
 
     threshold: float
-    """Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5.
+    """Used only for `server_vad` mode.
 
-    A higher threshold will require louder audio to activate the model, and thus
-    might perform better in noisy environments.
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
     """
 
-    type: str
-    """Type of turn detection, only `server_vad` is currently supported."""
+    type: Literal["server_vad", "semantic_vad"]
+    """Type of turn detection."""
diff --git a/src/openai/types/beta/realtime/session_create_response.py b/src/openai/types/beta/realtime/session_create_response.py
index c26e62bef1..471da03691 100644
--- a/src/openai/types/beta/realtime/session_create_response.py
+++ b/src/openai/types/beta/realtime/session_create_response.py
@@ -1,11 +1,19 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import List, Union, Optional
-from typing_extensions import Literal
+from typing_extensions import Literal, TypeAlias
 
 from ...._models import BaseModel
 
-__all__ = ["SessionCreateResponse", "ClientSecret", "InputAudioTranscription", "Tool", "TurnDetection"]
+__all__ = [
+    "SessionCreateResponse",
+    "ClientSecret",
+    "InputAudioTranscription",
+    "Tool",
+    "Tracing",
+    "TracingTracingConfiguration",
+    "TurnDetection",
+]
 
 
 class ClientSecret(BaseModel):
@@ -25,10 +33,7 @@ class ClientSecret(BaseModel):
 
 class InputAudioTranscription(BaseModel):
     model: Optional[str] = None
-    """
-    The model to use for transcription, `whisper-1` is the only currently supported
-    model.
-    """
+    """The model to use for transcription."""
 
 
 class Tool(BaseModel):
@@ -48,6 +53,29 @@ class Tool(BaseModel):
     """The type of the tool, i.e. `function`."""
 
 
+class TracingTracingConfiguration(BaseModel):
+    group_id: Optional[str] = None
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    traces dashboard.
+    """
+
+    metadata: Optional[object] = None
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the traces
+    dashboard.
+    """
+
+    workflow_name: Optional[str] = None
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the traces dashboard.
+    """
+
+
+Tracing: TypeAlias = Union[Literal["auto"], TracingTracingConfiguration]
+
+
 class TurnDetection(BaseModel):
     prefix_padding_ms: Optional[int] = None
     """Amount of audio to include before the VAD detected speech (in milliseconds).
@@ -85,8 +113,8 @@ class SessionCreateResponse(BaseModel):
     Configuration for input audio transcription, defaults to off and can be set to
     `null` to turn off once on. Input audio transcription is not native to the
     model, since the model consumes audio directly. Transcription runs
-    asynchronously through Whisper and should be treated as rough guidance rather
-    than the representation understood by the model.
+    asynchronously and should be treated as rough guidance rather than the
+    representation understood by the model.
     """
 
     instructions: Optional[str] = None
@@ -121,6 +149,14 @@ class SessionCreateResponse(BaseModel):
     output_audio_format: Optional[str] = None
     """The format of output audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`."""
 
+    speed: Optional[float] = None
+    """The speed of the model's spoken response.
+
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+    """
+
     temperature: Optional[float] = None
     """Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8."""
 
@@ -133,6 +169,16 @@ class SessionCreateResponse(BaseModel):
     tools: Optional[List[Tool]] = None
     """Tools (functions) available to the model."""
 
+    tracing: Optional[Tracing] = None
+    """Configuration options for tracing.
+
+    Set to null to disable tracing. Once tracing is enabled for a session, the
+    configuration cannot be modified.
+
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
     turn_detection: Optional[TurnDetection] = None
     """Configuration for turn detection.
 
@@ -141,10 +187,10 @@ class SessionCreateResponse(BaseModel):
     speech.
     """
 
-    voice: Optional[Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]] = None
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"], None] = None
     """The voice the model uses to respond.
 
     Voice cannot be changed during the session once the model has responded with
     audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
-    `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `coral`, `echo`, `sage`, `shimmer`, and `verse`.
     """
diff --git a/src/openai/types/beta/realtime/session_update_event.py b/src/openai/types/beta/realtime/session_update_event.py
index 999cd8d660..78d2e4bb18 100644
--- a/src/openai/types/beta/realtime/session_update_event.py
+++ b/src/openai/types/beta/realtime/session_update_event.py
@@ -1,11 +1,50 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import List, Union, Optional
-from typing_extensions import Literal
+from typing_extensions import Literal, TypeAlias
 
 from ...._models import BaseModel
 
-__all__ = ["SessionUpdateEvent", "Session", "SessionInputAudioTranscription", "SessionTool", "SessionTurnDetection"]
+__all__ = [
+    "SessionUpdateEvent",
+    "Session",
+    "SessionClientSecret",
+    "SessionClientSecretExpiresAfter",
+    "SessionInputAudioNoiseReduction",
+    "SessionInputAudioTranscription",
+    "SessionTool",
+    "SessionTracing",
+    "SessionTracingTracingConfiguration",
+    "SessionTurnDetection",
+]
+
+
+class SessionClientSecretExpiresAfter(BaseModel):
+    anchor: Literal["created_at"]
+    """The anchor point for the ephemeral token expiration.
+
+    Only `created_at` is currently supported.
+    """
+
+    seconds: Optional[int] = None
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200`.
+    """
+
+
+class SessionClientSecret(BaseModel):
+    expires_after: Optional[SessionClientSecretExpiresAfter] = None
+    """Configuration for the ephemeral token expiration."""
+
+
+class SessionInputAudioNoiseReduction(BaseModel):
+    type: Optional[Literal["near_field", "far_field"]] = None
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
 
 
 class SessionInputAudioTranscription(BaseModel):
@@ -19,16 +58,17 @@ class SessionInputAudioTranscription(BaseModel):
 
     model: Optional[str] = None
     """
-    The model to use for transcription, `whisper-1` is the only currently supported
-    model.
+    The model to use for transcription, current options are `gpt-4o-transcribe`,
+    `gpt-4o-mini-transcribe`, and `whisper-1`.
     """
 
     prompt: Optional[str] = None
-    """An optional text to guide the model's style or continue a previous audio
-    segment.
-
-    The [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-    should match the audio language.
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+    "expect words related to technology".
     """
 
 
@@ -49,46 +89,82 @@ class SessionTool(BaseModel):
     """The type of the tool, i.e. `function`."""
 
 
+class SessionTracingTracingConfiguration(BaseModel):
+    group_id: Optional[str] = None
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    traces dashboard.
+    """
+
+    metadata: Optional[object] = None
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the traces
+    dashboard.
+    """
+
+    workflow_name: Optional[str] = None
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the traces dashboard.
+    """
+
+
+SessionTracing: TypeAlias = Union[Literal["auto"], SessionTracingTracingConfiguration]
+
+
 class SessionTurnDetection(BaseModel):
     create_response: Optional[bool] = None
-    """Whether or not to automatically generate a response when a VAD stop event
+    """
+    Whether or not to automatically generate a response when a VAD stop event
     occurs.
+    """
+
+    eagerness: Optional[Literal["low", "medium", "high", "auto"]] = None
+    """Used only for `semantic_vad` mode.
 
-    `true` by default.
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`.
     """
 
     interrupt_response: Optional[bool] = None
     """
     Whether or not to automatically interrupt any ongoing response with output to
     the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-    occurs. `true` by default.
+    occurs.
     """
 
     prefix_padding_ms: Optional[int] = None
-    """Amount of audio to include before the VAD detected speech (in milliseconds).
+    """Used only for `server_vad` mode.
 
+    Amount of audio to include before the VAD detected speech (in milliseconds).
     Defaults to 300ms.
     """
 
     silence_duration_ms: Optional[int] = None
-    """Duration of silence to detect speech stop (in milliseconds).
+    """Used only for `server_vad` mode.
 
-    Defaults to 500ms. With shorter values the model will respond more quickly, but
-    may jump in on short pauses from the user.
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
     """
 
     threshold: Optional[float] = None
-    """Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5.
+    """Used only for `server_vad` mode.
 
-    A higher threshold will require louder audio to activate the model, and thus
-    might perform better in noisy environments.
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
     """
 
-    type: Optional[str] = None
-    """Type of turn detection, only `server_vad` is currently supported."""
+    type: Optional[Literal["server_vad", "semantic_vad"]] = None
+    """Type of turn detection."""
 
 
 class Session(BaseModel):
+    client_secret: Optional[SessionClientSecret] = None
+    """Configuration options for the generated client secret."""
+
     input_audio_format: Optional[Literal["pcm16", "g711_ulaw", "g711_alaw"]] = None
     """The format of input audio.
 
@@ -97,16 +173,25 @@ class Session(BaseModel):
     byte order.
     """
 
+    input_audio_noise_reduction: Optional[SessionInputAudioNoiseReduction] = None
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
     input_audio_transcription: Optional[SessionInputAudioTranscription] = None
     """
     Configuration for input audio transcription, defaults to off and can be set to
     `null` to turn off once on. Input audio transcription is not native to the
     model, since the model consumes audio directly. Transcription runs
     asynchronously through
-    [OpenAI Whisper transcription](https://platform.openai.com/docs/api-reference/audio/createTranscription)
-    and should be treated as rough guidance rather than the representation
-    understood by the model. The client can optionally set the language and prompt
-    for transcription, these fields will be passed to the Whisper API.
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
     """
 
     instructions: Optional[str] = None
@@ -140,9 +225,12 @@ class Session(BaseModel):
 
     model: Optional[
         Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
             "gpt-4o-realtime-preview",
             "gpt-4o-realtime-preview-2024-10-01",
             "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
             "gpt-4o-mini-realtime-preview",
             "gpt-4o-mini-realtime-preview-2024-12-17",
         ]
@@ -156,8 +244,20 @@ class Session(BaseModel):
     sampled at a rate of 24kHz.
     """
 
+    speed: Optional[float] = None
+    """The speed of the model's spoken response.
+
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+    """
+
     temperature: Optional[float] = None
-    """Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8."""
+    """Sampling temperature for the model, limited to [0.6, 1.2].
+
+    For audio models a temperature of 0.8 is highly recommended for best
+    performance.
+    """
 
     tool_choice: Optional[str] = None
     """How the model chooses tools.
@@ -168,20 +268,36 @@ class Session(BaseModel):
     tools: Optional[List[SessionTool]] = None
     """Tools (functions) available to the model."""
 
-    turn_detection: Optional[SessionTurnDetection] = None
-    """Configuration for turn detection.
+    tracing: Optional[SessionTracing] = None
+    """Configuration options for tracing.
+
+    Set to null to disable tracing. Once tracing is enabled for a session, the
+    configuration cannot be modified.
 
-    Can be set to `null` to turn off. Server VAD means that the model will detect
-    the start and end of speech based on audio volume and respond at the end of user
-    speech.
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    turn_detection: Optional[SessionTurnDetection] = None
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response. Server VAD means that the model will detect the start
+    and end of speech based on audio volume and respond at the end of user speech.
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
     """
 
-    voice: Optional[Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]] = None
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"], None] = None
     """The voice the model uses to respond.
 
     Voice cannot be changed during the session once the model has responded with
     audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
-    `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `coral`, `echo`, `sage`, `shimmer`, and `verse`.
     """
 
 
diff --git a/src/openai/types/beta/realtime/session_update_event_param.py b/src/openai/types/beta/realtime/session_update_event_param.py
index 07fdba9d85..c58b202a71 100644
--- a/src/openai/types/beta/realtime/session_update_event_param.py
+++ b/src/openai/types/beta/realtime/session_update_event_param.py
@@ -3,17 +3,50 @@
 from __future__ import annotations
 
 from typing import List, Union, Iterable
-from typing_extensions import Literal, Required, TypedDict
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
 __all__ = [
     "SessionUpdateEventParam",
     "Session",
+    "SessionClientSecret",
+    "SessionClientSecretExpiresAfter",
+    "SessionInputAudioNoiseReduction",
     "SessionInputAudioTranscription",
     "SessionTool",
+    "SessionTracing",
+    "SessionTracingTracingConfiguration",
     "SessionTurnDetection",
 ]
 
 
+class SessionClientSecretExpiresAfter(TypedDict, total=False):
+    anchor: Required[Literal["created_at"]]
+    """The anchor point for the ephemeral token expiration.
+
+    Only `created_at` is currently supported.
+    """
+
+    seconds: int
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200`.
+    """
+
+
+class SessionClientSecret(TypedDict, total=False):
+    expires_after: SessionClientSecretExpiresAfter
+    """Configuration for the ephemeral token expiration."""
+
+
+class SessionInputAudioNoiseReduction(TypedDict, total=False):
+    type: Literal["near_field", "far_field"]
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
 class SessionInputAudioTranscription(TypedDict, total=False):
     language: str
     """The language of the input audio.
@@ -25,16 +58,17 @@ class SessionInputAudioTranscription(TypedDict, total=False):
 
     model: str
     """
-    The model to use for transcription, `whisper-1` is the only currently supported
-    model.
+    The model to use for transcription, current options are `gpt-4o-transcribe`,
+    `gpt-4o-mini-transcribe`, and `whisper-1`.
     """
 
     prompt: str
-    """An optional text to guide the model's style or continue a previous audio
-    segment.
-
-    The [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-    should match the audio language.
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+    "expect words related to technology".
     """
 
 
@@ -55,46 +89,82 @@ class SessionTool(TypedDict, total=False):
     """The type of the tool, i.e. `function`."""
 
 
+class SessionTracingTracingConfiguration(TypedDict, total=False):
+    group_id: str
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    traces dashboard.
+    """
+
+    metadata: object
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the traces
+    dashboard.
+    """
+
+    workflow_name: str
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the traces dashboard.
+    """
+
+
+SessionTracing: TypeAlias = Union[Literal["auto"], SessionTracingTracingConfiguration]
+
+
 class SessionTurnDetection(TypedDict, total=False):
     create_response: bool
-    """Whether or not to automatically generate a response when a VAD stop event
+    """
+    Whether or not to automatically generate a response when a VAD stop event
     occurs.
+    """
 
-    `true` by default.
+    eagerness: Literal["low", "medium", "high", "auto"]
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`.
     """
 
     interrupt_response: bool
     """
     Whether or not to automatically interrupt any ongoing response with output to
     the default conversation (i.e. `conversation` of `auto`) when a VAD start event
-    occurs. `true` by default.
+    occurs.
     """
 
     prefix_padding_ms: int
-    """Amount of audio to include before the VAD detected speech (in milliseconds).
+    """Used only for `server_vad` mode.
 
+    Amount of audio to include before the VAD detected speech (in milliseconds).
     Defaults to 300ms.
     """
 
     silence_duration_ms: int
-    """Duration of silence to detect speech stop (in milliseconds).
+    """Used only for `server_vad` mode.
 
-    Defaults to 500ms. With shorter values the model will respond more quickly, but
-    may jump in on short pauses from the user.
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
     """
 
     threshold: float
-    """Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5.
+    """Used only for `server_vad` mode.
 
-    A higher threshold will require louder audio to activate the model, and thus
-    might perform better in noisy environments.
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
     """
 
-    type: str
-    """Type of turn detection, only `server_vad` is currently supported."""
+    type: Literal["server_vad", "semantic_vad"]
+    """Type of turn detection."""
 
 
 class Session(TypedDict, total=False):
+    client_secret: SessionClientSecret
+    """Configuration options for the generated client secret."""
+
     input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"]
     """The format of input audio.
 
@@ -103,16 +173,25 @@ class Session(TypedDict, total=False):
     byte order.
     """
 
+    input_audio_noise_reduction: SessionInputAudioNoiseReduction
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
     input_audio_transcription: SessionInputAudioTranscription
     """
     Configuration for input audio transcription, defaults to off and can be set to
     `null` to turn off once on. Input audio transcription is not native to the
     model, since the model consumes audio directly. Transcription runs
     asynchronously through
-    [OpenAI Whisper transcription](https://platform.openai.com/docs/api-reference/audio/createTranscription)
-    and should be treated as rough guidance rather than the representation
-    understood by the model. The client can optionally set the language and prompt
-    for transcription, these fields will be passed to the Whisper API.
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
     """
 
     instructions: str
@@ -145,9 +224,12 @@ class Session(TypedDict, total=False):
     """
 
     model: Literal[
+        "gpt-realtime",
+        "gpt-realtime-2025-08-28",
         "gpt-4o-realtime-preview",
         "gpt-4o-realtime-preview-2024-10-01",
         "gpt-4o-realtime-preview-2024-12-17",
+        "gpt-4o-realtime-preview-2025-06-03",
         "gpt-4o-mini-realtime-preview",
         "gpt-4o-mini-realtime-preview-2024-12-17",
     ]
@@ -160,8 +242,20 @@ class Session(TypedDict, total=False):
     sampled at a rate of 24kHz.
     """
 
+    speed: float
+    """The speed of the model's spoken response.
+
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+    """
+
     temperature: float
-    """Sampling temperature for the model, limited to [0.6, 1.2]. Defaults to 0.8."""
+    """Sampling temperature for the model, limited to [0.6, 1.2].
+
+    For audio models a temperature of 0.8 is highly recommended for best
+    performance.
+    """
 
     tool_choice: str
     """How the model chooses tools.
@@ -172,20 +266,36 @@ class Session(TypedDict, total=False):
     tools: Iterable[SessionTool]
     """Tools (functions) available to the model."""
 
-    turn_detection: SessionTurnDetection
-    """Configuration for turn detection.
+    tracing: SessionTracing
+    """Configuration options for tracing.
+
+    Set to null to disable tracing. Once tracing is enabled for a session, the
+    configuration cannot be modified.
 
-    Can be set to `null` to turn off. Server VAD means that the model will detect
-    the start and end of speech based on audio volume and respond at the end of user
-    speech.
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    turn_detection: SessionTurnDetection
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response. Server VAD means that the model will detect the start
+    and end of speech based on audio volume and respond at the end of user speech.
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
     """
 
-    voice: Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]]
     """The voice the model uses to respond.
 
     Voice cannot be changed during the session once the model has responded with
     audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
-    `coral`, `echo` `sage`, `shimmer` and `verse`.
+    `coral`, `echo`, `sage`, `shimmer`, and `verse`.
     """
 
 
diff --git a/src/openai/types/beta/realtime/transcription_session.py b/src/openai/types/beta/realtime/transcription_session.py
new file mode 100644
index 0000000000..7c7abf37b6
--- /dev/null
+++ b/src/openai/types/beta/realtime/transcription_session.py
@@ -0,0 +1,100 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["TranscriptionSession", "ClientSecret", "InputAudioTranscription", "TurnDetection"]
+
+
+class ClientSecret(BaseModel):
+    expires_at: int
+    """Timestamp for when the token expires.
+
+    Currently, all tokens expire after one minute.
+    """
+
+    value: str
+    """
+    Ephemeral key usable in client environments to authenticate connections to the
+    Realtime API. Use this in client-side environments rather than a standard API
+    token, which should only be used server-side.
+    """
+
+
+class InputAudioTranscription(BaseModel):
+    language: Optional[str] = None
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Optional[Literal["gpt-4o-transcribe", "gpt-4o-mini-transcribe", "whisper-1"]] = None
+    """The model to use for transcription.
+
+    Can be `gpt-4o-transcribe`, `gpt-4o-mini-transcribe`, or `whisper-1`.
+    """
+
+    prompt: Optional[str] = None
+    """An optional text to guide the model's style or continue a previous audio
+    segment.
+
+    The [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
+    should match the audio language.
+    """
+
+
+class TurnDetection(BaseModel):
+    prefix_padding_ms: Optional[int] = None
+    """Amount of audio to include before the VAD detected speech (in milliseconds).
+
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: Optional[int] = None
+    """Duration of silence to detect speech stop (in milliseconds).
+
+    Defaults to 500ms. With shorter values the model will respond more quickly, but
+    may jump in on short pauses from the user.
+    """
+
+    threshold: Optional[float] = None
+    """Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5.
+
+    A higher threshold will require louder audio to activate the model, and thus
+    might perform better in noisy environments.
+    """
+
+    type: Optional[str] = None
+    """Type of turn detection, only `server_vad` is currently supported."""
+
+
+class TranscriptionSession(BaseModel):
+    client_secret: ClientSecret
+    """Ephemeral key returned by the API.
+
+    Only present when the session is created on the server via REST API.
+    """
+
+    input_audio_format: Optional[str] = None
+    """The format of input audio. Options are `pcm16`, `g711_ulaw`, or `g711_alaw`."""
+
+    input_audio_transcription: Optional[InputAudioTranscription] = None
+    """Configuration of the transcription model."""
+
+    modalities: Optional[List[Literal["text", "audio"]]] = None
+    """The set of modalities the model can respond with.
+
+    To disable audio, set this to ["text"].
+    """
+
+    turn_detection: Optional[TurnDetection] = None
+    """Configuration for turn detection.
+
+    Can be set to `null` to turn off. Server VAD means that the model will detect
+    the start and end of speech based on audio volume and respond at the end of user
+    speech.
+    """
diff --git a/src/openai/types/beta/realtime/transcription_session_create_params.py b/src/openai/types/beta/realtime/transcription_session_create_params.py
new file mode 100644
index 0000000000..3ac3af4fa9
--- /dev/null
+++ b/src/openai/types/beta/realtime/transcription_session_create_params.py
@@ -0,0 +1,173 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, TypedDict
+
+__all__ = [
+    "TranscriptionSessionCreateParams",
+    "ClientSecret",
+    "ClientSecretExpiresAt",
+    "InputAudioNoiseReduction",
+    "InputAudioTranscription",
+    "TurnDetection",
+]
+
+
+class TranscriptionSessionCreateParams(TypedDict, total=False):
+    client_secret: ClientSecret
+    """Configuration options for the generated client secret."""
+
+    include: List[str]
+    """The set of items to include in the transcription. Current available items are:
+
+    - `item.input_audio_transcription.logprobs`
+    """
+
+    input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"]
+    """The format of input audio.
+
+    Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. For `pcm16`, input audio must
+    be 16-bit PCM at a 24kHz sample rate, single channel (mono), and little-endian
+    byte order.
+    """
+
+    input_audio_noise_reduction: InputAudioNoiseReduction
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    input_audio_transcription: InputAudioTranscription
+    """Configuration for input audio transcription.
+
+    The client can optionally set the language and prompt for transcription, these
+    offer additional guidance to the transcription service.
+    """
+
+    modalities: List[Literal["text", "audio"]]
+    """The set of modalities the model can respond with.
+
+    To disable audio, set this to ["text"].
+    """
+
+    turn_detection: TurnDetection
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response. Server VAD means that the model will detect the start
+    and end of speech based on audio volume and respond at the end of user speech.
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
+
+
+class ClientSecretExpiresAt(TypedDict, total=False):
+    anchor: Literal["created_at"]
+    """The anchor point for the ephemeral token expiration.
+
+    Only `created_at` is currently supported.
+    """
+
+    seconds: int
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200`.
+    """
+
+
+class ClientSecret(TypedDict, total=False):
+    expires_at: ClientSecretExpiresAt
+    """Configuration for the ephemeral token expiration."""
+
+
+class InputAudioNoiseReduction(TypedDict, total=False):
+    type: Literal["near_field", "far_field"]
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class InputAudioTranscription(TypedDict, total=False):
+    language: str
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Literal["gpt-4o-transcribe", "gpt-4o-mini-transcribe", "whisper-1"]
+    """
+    The model to use for transcription, current options are `gpt-4o-transcribe`,
+    `gpt-4o-mini-transcribe`, and `whisper-1`.
+    """
+
+    prompt: str
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+    "expect words related to technology".
+    """
+
+
+class TurnDetection(TypedDict, total=False):
+    create_response: bool
+    """Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+
+    Not available for transcription sessions.
+    """
+
+    eagerness: Literal["low", "medium", "high", "auto"]
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`.
+    """
+
+    interrupt_response: bool
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs. Not available for transcription sessions.
+    """
+
+    prefix_padding_ms: int
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: int
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: float
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+    type: Literal["server_vad", "semantic_vad"]
+    """Type of turn detection."""
diff --git a/src/openai/types/beta/realtime/transcription_session_update.py b/src/openai/types/beta/realtime/transcription_session_update.py
new file mode 100644
index 0000000000..5ae1ad226d
--- /dev/null
+++ b/src/openai/types/beta/realtime/transcription_session_update.py
@@ -0,0 +1,185 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = [
+    "TranscriptionSessionUpdate",
+    "Session",
+    "SessionClientSecret",
+    "SessionClientSecretExpiresAt",
+    "SessionInputAudioNoiseReduction",
+    "SessionInputAudioTranscription",
+    "SessionTurnDetection",
+]
+
+
+class SessionClientSecretExpiresAt(BaseModel):
+    anchor: Optional[Literal["created_at"]] = None
+    """The anchor point for the ephemeral token expiration.
+
+    Only `created_at` is currently supported.
+    """
+
+    seconds: Optional[int] = None
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200`.
+    """
+
+
+class SessionClientSecret(BaseModel):
+    expires_at: Optional[SessionClientSecretExpiresAt] = None
+    """Configuration for the ephemeral token expiration."""
+
+
+class SessionInputAudioNoiseReduction(BaseModel):
+    type: Optional[Literal["near_field", "far_field"]] = None
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class SessionInputAudioTranscription(BaseModel):
+    language: Optional[str] = None
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Optional[Literal["gpt-4o-transcribe", "gpt-4o-mini-transcribe", "whisper-1"]] = None
+    """
+    The model to use for transcription, current options are `gpt-4o-transcribe`,
+    `gpt-4o-mini-transcribe`, and `whisper-1`.
+    """
+
+    prompt: Optional[str] = None
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+    "expect words related to technology".
+    """
+
+
+class SessionTurnDetection(BaseModel):
+    create_response: Optional[bool] = None
+    """Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+
+    Not available for transcription sessions.
+    """
+
+    eagerness: Optional[Literal["low", "medium", "high", "auto"]] = None
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`.
+    """
+
+    interrupt_response: Optional[bool] = None
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs. Not available for transcription sessions.
+    """
+
+    prefix_padding_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: Optional[float] = None
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+    type: Optional[Literal["server_vad", "semantic_vad"]] = None
+    """Type of turn detection."""
+
+
+class Session(BaseModel):
+    client_secret: Optional[SessionClientSecret] = None
+    """Configuration options for the generated client secret."""
+
+    include: Optional[List[str]] = None
+    """The set of items to include in the transcription. Current available items are:
+
+    - `item.input_audio_transcription.logprobs`
+    """
+
+    input_audio_format: Optional[Literal["pcm16", "g711_ulaw", "g711_alaw"]] = None
+    """The format of input audio.
+
+    Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. For `pcm16`, input audio must
+    be 16-bit PCM at a 24kHz sample rate, single channel (mono), and little-endian
+    byte order.
+    """
+
+    input_audio_noise_reduction: Optional[SessionInputAudioNoiseReduction] = None
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    input_audio_transcription: Optional[SessionInputAudioTranscription] = None
+    """Configuration for input audio transcription.
+
+    The client can optionally set the language and prompt for transcription, these
+    offer additional guidance to the transcription service.
+    """
+
+    modalities: Optional[List[Literal["text", "audio"]]] = None
+    """The set of modalities the model can respond with.
+
+    To disable audio, set this to ["text"].
+    """
+
+    turn_detection: Optional[SessionTurnDetection] = None
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response. Server VAD means that the model will detect the start
+    and end of speech based on audio volume and respond at the end of user speech.
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
+
+
+class TranscriptionSessionUpdate(BaseModel):
+    session: Session
+    """Realtime transcription session object configuration."""
+
+    type: Literal["transcription_session.update"]
+    """The event type, must be `transcription_session.update`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/beta/realtime/transcription_session_update_param.py b/src/openai/types/beta/realtime/transcription_session_update_param.py
new file mode 100644
index 0000000000..d7065f61c7
--- /dev/null
+++ b/src/openai/types/beta/realtime/transcription_session_update_param.py
@@ -0,0 +1,185 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = [
+    "TranscriptionSessionUpdateParam",
+    "Session",
+    "SessionClientSecret",
+    "SessionClientSecretExpiresAt",
+    "SessionInputAudioNoiseReduction",
+    "SessionInputAudioTranscription",
+    "SessionTurnDetection",
+]
+
+
+class SessionClientSecretExpiresAt(TypedDict, total=False):
+    anchor: Literal["created_at"]
+    """The anchor point for the ephemeral token expiration.
+
+    Only `created_at` is currently supported.
+    """
+
+    seconds: int
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200`.
+    """
+
+
+class SessionClientSecret(TypedDict, total=False):
+    expires_at: SessionClientSecretExpiresAt
+    """Configuration for the ephemeral token expiration."""
+
+
+class SessionInputAudioNoiseReduction(TypedDict, total=False):
+    type: Literal["near_field", "far_field"]
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class SessionInputAudioTranscription(TypedDict, total=False):
+    language: str
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Literal["gpt-4o-transcribe", "gpt-4o-mini-transcribe", "whisper-1"]
+    """
+    The model to use for transcription, current options are `gpt-4o-transcribe`,
+    `gpt-4o-mini-transcribe`, and `whisper-1`.
+    """
+
+    prompt: str
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models, the prompt is a free text string, for example
+    "expect words related to technology".
+    """
+
+
+class SessionTurnDetection(TypedDict, total=False):
+    create_response: bool
+    """Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+
+    Not available for transcription sessions.
+    """
+
+    eagerness: Literal["low", "medium", "high", "auto"]
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`.
+    """
+
+    interrupt_response: bool
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs. Not available for transcription sessions.
+    """
+
+    prefix_padding_ms: int
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: int
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: float
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+    type: Literal["server_vad", "semantic_vad"]
+    """Type of turn detection."""
+
+
+class Session(TypedDict, total=False):
+    client_secret: SessionClientSecret
+    """Configuration options for the generated client secret."""
+
+    include: List[str]
+    """The set of items to include in the transcription. Current available items are:
+
+    - `item.input_audio_transcription.logprobs`
+    """
+
+    input_audio_format: Literal["pcm16", "g711_ulaw", "g711_alaw"]
+    """The format of input audio.
+
+    Options are `pcm16`, `g711_ulaw`, or `g711_alaw`. For `pcm16`, input audio must
+    be 16-bit PCM at a 24kHz sample rate, single channel (mono), and little-endian
+    byte order.
+    """
+
+    input_audio_noise_reduction: SessionInputAudioNoiseReduction
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    input_audio_transcription: SessionInputAudioTranscription
+    """Configuration for input audio transcription.
+
+    The client can optionally set the language and prompt for transcription, these
+    offer additional guidance to the transcription service.
+    """
+
+    modalities: List[Literal["text", "audio"]]
+    """The set of modalities the model can respond with.
+
+    To disable audio, set this to ["text"].
+    """
+
+    turn_detection: SessionTurnDetection
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response. Server VAD means that the model will detect the start
+    and end of speech based on audio volume and respond at the end of user speech.
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
+
+
+class TranscriptionSessionUpdateParam(TypedDict, total=False):
+    session: Required[Session]
+    """Realtime transcription session object configuration."""
+
+    type: Required[Literal["transcription_session.update"]]
+    """The event type, must be `transcription_session.update`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/beta/realtime/transcription_session_updated_event.py b/src/openai/types/beta/realtime/transcription_session_updated_event.py
new file mode 100644
index 0000000000..1f1fbdae14
--- /dev/null
+++ b/src/openai/types/beta/realtime/transcription_session_updated_event.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from .transcription_session import TranscriptionSession
+
+__all__ = ["TranscriptionSessionUpdatedEvent"]
+
+
+class TranscriptionSessionUpdatedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    session: TranscriptionSession
+    """A new Realtime transcription session configuration.
+
+    When a session is created on the server via REST API, the session object also
+    contains an ephemeral key. Default TTL for keys is 10 minutes. This property is
+    not present when a session is updated via the WebSocket API.
+    """
+
+    type: Literal["transcription_session.updated"]
+    """The event type, must be `transcription_session.updated`."""
diff --git a/src/openai/types/beta/thread_create_and_run_params.py b/src/openai/types/beta/thread_create_and_run_params.py
index 065c390f4e..734e5e2a4e 100644
--- a/src/openai/types/beta/thread_create_and_run_params.py
+++ b/src/openai/types/beta/thread_create_and_run_params.py
@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable, Optional
+from typing import Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from ..shared.chat_model import ChatModel
-from .function_tool_param import FunctionToolParam
-from .file_search_tool_param import FileSearchToolParam
+from .assistant_tool_param import AssistantToolParam
 from ..shared_params.metadata import Metadata
 from .code_interpreter_tool_param import CodeInterpreterToolParam
 from .assistant_tool_choice_option_param import AssistantToolChoiceOptionParam
@@ -32,7 +32,6 @@
     "ToolResources",
     "ToolResourcesCodeInterpreter",
     "ToolResourcesFileSearch",
-    "Tool",
     "TruncationStrategy",
     "ThreadCreateAndRunParamsNonStreaming",
     "ThreadCreateAndRunParamsStreaming",
@@ -153,7 +152,7 @@ class ThreadCreateAndRunParamsBase(TypedDict, total=False):
     tool requires a list of vector store IDs.
     """
 
-    tools: Optional[Iterable[Tool]]
+    tools: Optional[Iterable[AssistantToolParam]]
     """Override the tools the assistant can use for this run.
 
     This is useful for modifying the behavior on a per-run basis.
@@ -171,7 +170,7 @@ class ThreadCreateAndRunParamsBase(TypedDict, total=False):
     truncation_strategy: Optional[TruncationStrategy]
     """Controls for how a thread will be truncated prior to the run.
 
-    Use this to control the intial context window of the run.
+    Use this to control the initial context window of the run.
     """
 
 
@@ -219,7 +218,7 @@ class ThreadMessage(TypedDict, total=False):
 
 
 class ThreadToolResourcesCodeInterpreter(TypedDict, total=False):
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs made
     available to the `code_interpreter` tool. There can be a maximum of 20 files
@@ -267,7 +266,7 @@ class ThreadToolResourcesFileSearchVectorStore(TypedDict, total=False):
     If not set, will use the `auto` strategy.
     """
 
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs to
     add to the vector store. There can be a maximum of 10000 files in a vector
@@ -286,7 +285,7 @@ class ThreadToolResourcesFileSearchVectorStore(TypedDict, total=False):
 
 
 class ThreadToolResourcesFileSearch(TypedDict, total=False):
-    vector_store_ids: List[str]
+    vector_store_ids: SequenceNotStr[str]
     """
     The
     [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
@@ -336,7 +335,7 @@ class Thread(TypedDict, total=False):
 
 
 class ToolResourcesCodeInterpreter(TypedDict, total=False):
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs made
     available to the `code_interpreter` tool. There can be a maximum of 20 files
@@ -345,7 +344,7 @@ class ToolResourcesCodeInterpreter(TypedDict, total=False):
 
 
 class ToolResourcesFileSearch(TypedDict, total=False):
-    vector_store_ids: List[str]
+    vector_store_ids: SequenceNotStr[str]
     """
     The ID of the
     [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
@@ -360,9 +359,6 @@ class ToolResources(TypedDict, total=False):
     file_search: ToolResourcesFileSearch
 
 
-Tool: TypeAlias = Union[CodeInterpreterToolParam, FileSearchToolParam, FunctionToolParam]
-
-
 class TruncationStrategy(TypedDict, total=False):
     type: Required[Literal["auto", "last_messages"]]
     """The truncation strategy to use for the thread.
diff --git a/src/openai/types/beta/thread_create_params.py b/src/openai/types/beta/thread_create_params.py
index ec1ccf19a6..8fd9f38df7 100644
--- a/src/openai/types/beta/thread_create_params.py
+++ b/src/openai/types/beta/thread_create_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable, Optional
+from typing import Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from ..shared_params.metadata import Metadata
 from .code_interpreter_tool_param import CodeInterpreterToolParam
 from .threads.message_content_part_param import MessageContentPartParam
@@ -96,7 +97,7 @@ class Message(TypedDict, total=False):
 
 
 class ToolResourcesCodeInterpreter(TypedDict, total=False):
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs made
     available to the `code_interpreter` tool. There can be a maximum of 20 files
@@ -143,7 +144,7 @@ class ToolResourcesFileSearchVectorStore(TypedDict, total=False):
     If not set, will use the `auto` strategy.
     """
 
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs to
     add to the vector store. There can be a maximum of 10000 files in a vector
@@ -162,7 +163,7 @@ class ToolResourcesFileSearchVectorStore(TypedDict, total=False):
 
 
 class ToolResourcesFileSearch(TypedDict, total=False):
-    vector_store_ids: List[str]
+    vector_store_ids: SequenceNotStr[str]
     """
     The
     [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
diff --git a/src/openai/types/beta/thread_update_params.py b/src/openai/types/beta/thread_update_params.py
index b47ea8f3b0..464ea8d7eb 100644
--- a/src/openai/types/beta/thread_update_params.py
+++ b/src/openai/types/beta/thread_update_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 from typing_extensions import TypedDict
 
+from ..._types import SequenceNotStr
 from ..shared_params.metadata import Metadata
 
 __all__ = ["ThreadUpdateParams", "ToolResources", "ToolResourcesCodeInterpreter", "ToolResourcesFileSearch"]
@@ -31,7 +32,7 @@ class ThreadUpdateParams(TypedDict, total=False):
 
 
 class ToolResourcesCodeInterpreter(TypedDict, total=False):
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [file](https://platform.openai.com/docs/api-reference/files) IDs made
     available to the `code_interpreter` tool. There can be a maximum of 20 files
@@ -40,7 +41,7 @@ class ToolResourcesCodeInterpreter(TypedDict, total=False):
 
 
 class ToolResourcesFileSearch(TypedDict, total=False):
-    vector_store_ids: List[str]
+    vector_store_ids: SequenceNotStr[str]
     """
     The
     [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
diff --git a/src/openai/types/beta/threads/run.py b/src/openai/types/beta/threads/run.py
index da9418d6f9..c545cc3759 100644
--- a/src/openai/types/beta/threads/run.py
+++ b/src/openai/types/beta/threads/run.py
@@ -228,7 +228,7 @@ class Run(BaseModel):
     truncation_strategy: Optional[TruncationStrategy] = None
     """Controls for how a thread will be truncated prior to the run.
 
-    Use this to control the intial context window of the run.
+    Use this to control the initial context window of the run.
     """
 
     usage: Optional[Usage] = None
diff --git a/src/openai/types/beta/threads/run_create_params.py b/src/openai/types/beta/threads/run_create_params.py
index fc70227862..74786d7d5c 100644
--- a/src/openai/types/beta/threads/run_create_params.py
+++ b/src/openai/types/beta/threads/run_create_params.py
@@ -108,12 +108,19 @@ class RunCreateParamsBase(TypedDict, total=False):
     """
 
     reasoning_effort: Optional[ReasoningEffort]
-    """**o-series models only**
-
+    """
     Constrains effort on reasoning for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-    result in faster responses and fewer tokens used on reasoning in a response.
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     """
 
     response_format: Optional[AssistantResponseFormatOptionParam]
@@ -176,7 +183,7 @@ class RunCreateParamsBase(TypedDict, total=False):
     truncation_strategy: Optional[TruncationStrategy]
     """Controls for how a thread will be truncated prior to the run.
 
-    Use this to control the intial context window of the run.
+    Use this to control the initial context window of the run.
     """
 
 
diff --git a/src/openai/types/chat/__init__.py b/src/openai/types/chat/__init__.py
index b4f43b298f..50bdac7c65 100644
--- a/src/openai/types/chat/__init__.py
+++ b/src/openai/types/chat/__init__.py
@@ -23,14 +23,24 @@
 )
 from .chat_completion_tool_param import ChatCompletionToolParam as ChatCompletionToolParam
 from .chat_completion_audio_param import ChatCompletionAudioParam as ChatCompletionAudioParam
+from .chat_completion_function_tool import ChatCompletionFunctionTool as ChatCompletionFunctionTool
 from .chat_completion_message_param import ChatCompletionMessageParam as ChatCompletionMessageParam
 from .chat_completion_store_message import ChatCompletionStoreMessage as ChatCompletionStoreMessage
 from .chat_completion_token_logprob import ChatCompletionTokenLogprob as ChatCompletionTokenLogprob
 from .chat_completion_reasoning_effort import ChatCompletionReasoningEffort as ChatCompletionReasoningEffort
-from .chat_completion_message_tool_call import ChatCompletionMessageToolCall as ChatCompletionMessageToolCall
+from .chat_completion_tool_union_param import ChatCompletionToolUnionParam as ChatCompletionToolUnionParam
+from .chat_completion_content_part_text import ChatCompletionContentPartText as ChatCompletionContentPartText
+from .chat_completion_custom_tool_param import ChatCompletionCustomToolParam as ChatCompletionCustomToolParam
+from .chat_completion_message_tool_call import (
+    ChatCompletionMessageToolCall as ChatCompletionMessageToolCall,
+    ChatCompletionMessageToolCallUnion as ChatCompletionMessageToolCallUnion,
+)
+from .chat_completion_content_part_image import ChatCompletionContentPartImage as ChatCompletionContentPartImage
 from .chat_completion_content_part_param import ChatCompletionContentPartParam as ChatCompletionContentPartParam
 from .chat_completion_tool_message_param import ChatCompletionToolMessageParam as ChatCompletionToolMessageParam
 from .chat_completion_user_message_param import ChatCompletionUserMessageParam as ChatCompletionUserMessageParam
+from .chat_completion_allowed_tools_param import ChatCompletionAllowedToolsParam as ChatCompletionAllowedToolsParam
+from .chat_completion_function_tool_param import ChatCompletionFunctionToolParam as ChatCompletionFunctionToolParam
 from .chat_completion_stream_options_param import ChatCompletionStreamOptionsParam as ChatCompletionStreamOptionsParam
 from .chat_completion_system_message_param import ChatCompletionSystemMessageParam as ChatCompletionSystemMessageParam
 from .chat_completion_function_message_param import (
@@ -54,18 +64,39 @@
 from .chat_completion_content_part_image_param import (
     ChatCompletionContentPartImageParam as ChatCompletionContentPartImageParam,
 )
+from .chat_completion_message_custom_tool_call import (
+    ChatCompletionMessageCustomToolCall as ChatCompletionMessageCustomToolCall,
+)
 from .chat_completion_prediction_content_param import (
     ChatCompletionPredictionContentParam as ChatCompletionPredictionContentParam,
 )
 from .chat_completion_tool_choice_option_param import (
     ChatCompletionToolChoiceOptionParam as ChatCompletionToolChoiceOptionParam,
 )
+from .chat_completion_allowed_tool_choice_param import (
+    ChatCompletionAllowedToolChoiceParam as ChatCompletionAllowedToolChoiceParam,
+)
 from .chat_completion_content_part_refusal_param import (
     ChatCompletionContentPartRefusalParam as ChatCompletionContentPartRefusalParam,
 )
 from .chat_completion_function_call_option_param import (
     ChatCompletionFunctionCallOptionParam as ChatCompletionFunctionCallOptionParam,
 )
+from .chat_completion_message_function_tool_call import (
+    ChatCompletionMessageFunctionToolCall as ChatCompletionMessageFunctionToolCall,
+)
+from .chat_completion_message_tool_call_union_param import (
+    ChatCompletionMessageToolCallUnionParam as ChatCompletionMessageToolCallUnionParam,
+)
 from .chat_completion_content_part_input_audio_param import (
     ChatCompletionContentPartInputAudioParam as ChatCompletionContentPartInputAudioParam,
 )
+from .chat_completion_message_custom_tool_call_param import (
+    ChatCompletionMessageCustomToolCallParam as ChatCompletionMessageCustomToolCallParam,
+)
+from .chat_completion_named_tool_choice_custom_param import (
+    ChatCompletionNamedToolChoiceCustomParam as ChatCompletionNamedToolChoiceCustomParam,
+)
+from .chat_completion_message_function_tool_call_param import (
+    ChatCompletionMessageFunctionToolCallParam as ChatCompletionMessageFunctionToolCallParam,
+)
diff --git a/src/openai/types/chat/chat_completion.py b/src/openai/types/chat/chat_completion.py
index cb812a2702..6bc4bafe79 100644
--- a/src/openai/types/chat/chat_completion.py
+++ b/src/openai/types/chat/chat_completion.py
@@ -59,8 +59,24 @@ class ChatCompletion(BaseModel):
     object: Literal["chat.completion"]
     """The object type, which is always `chat.completion`."""
 
-    service_tier: Optional[Literal["scale", "default"]] = None
-    """The service tier used for processing the request."""
+    service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] = None
+    """Specifies the processing type used for serving the request.
+
+    - If set to 'auto', then the request will be processed with the service tier
+      configured in the Project settings. Unless otherwise configured, the Project
+      will use 'default'.
+    - If set to 'default', then the request will be processed with the standard
+      pricing and performance for the selected model.
+    - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+      '[priority](https://openai.com/api-priority-processing/)', then the request
+      will be processed with the corresponding service tier.
+    - When not set, the default behavior is 'auto'.
+
+    When the `service_tier` parameter is set, the response body will include the
+    `service_tier` value based on the processing mode actually used to serve the
+    request. This response value may be different from the value set in the
+    parameter.
+    """
 
     system_fingerprint: Optional[str] = None
     """This fingerprint represents the backend configuration that the model runs with.
diff --git a/src/openai/types/chat/chat_completion_allowed_tool_choice_param.py b/src/openai/types/chat/chat_completion_allowed_tool_choice_param.py
new file mode 100644
index 0000000000..813e6293f9
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_allowed_tool_choice_param.py
@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .chat_completion_allowed_tools_param import ChatCompletionAllowedToolsParam
+
+__all__ = ["ChatCompletionAllowedToolChoiceParam"]
+
+
+class ChatCompletionAllowedToolChoiceParam(TypedDict, total=False):
+    allowed_tools: Required[ChatCompletionAllowedToolsParam]
+    """Constrains the tools available to the model to a pre-defined set."""
+
+    type: Required[Literal["allowed_tools"]]
+    """Allowed tool configuration type. Always `allowed_tools`."""
diff --git a/src/openai/types/chat/chat_completion_allowed_tools_param.py b/src/openai/types/chat/chat_completion_allowed_tools_param.py
new file mode 100644
index 0000000000..d9b72d8f34
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_allowed_tools_param.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatCompletionAllowedToolsParam"]
+
+
+class ChatCompletionAllowedToolsParam(TypedDict, total=False):
+    mode: Required[Literal["auto", "required"]]
+    """Constrains the tools available to the model to a pre-defined set.
+
+    `auto` allows the model to pick from among the allowed tools and generate a
+    message.
+
+    `required` requires the model to call one or more of the allowed tools.
+    """
+
+    tools: Required[Iterable[Dict[str, object]]]
+    """A list of tool definitions that the model should be allowed to call.
+
+    For the Chat Completions API, the list of tool definitions might look like:
+
+    ```json
+    [
+      { "type": "function", "function": { "name": "get_weather" } },
+      { "type": "function", "function": { "name": "get_time" } }
+    ]
+    ```
+    """
diff --git a/src/openai/types/chat/chat_completion_assistant_message_param.py b/src/openai/types/chat/chat_completion_assistant_message_param.py
index 35e3a3d784..1a08a959db 100644
--- a/src/openai/types/chat/chat_completion_assistant_message_param.py
+++ b/src/openai/types/chat/chat_completion_assistant_message_param.py
@@ -6,8 +6,8 @@
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
 from .chat_completion_content_part_text_param import ChatCompletionContentPartTextParam
-from .chat_completion_message_tool_call_param import ChatCompletionMessageToolCallParam
 from .chat_completion_content_part_refusal_param import ChatCompletionContentPartRefusalParam
+from .chat_completion_message_tool_call_union_param import ChatCompletionMessageToolCallUnionParam
 
 __all__ = ["ChatCompletionAssistantMessageParam", "Audio", "ContentArrayOfContentPart", "FunctionCall"]
 
@@ -38,8 +38,8 @@ class ChatCompletionAssistantMessageParam(TypedDict, total=False):
     """The role of the messages author, in this case `assistant`."""
 
     audio: Optional[Audio]
-    """Data about a previous audio response from the model.
-
+    """
+    Data about a previous audio response from the model.
     [Learn more](https://platform.openai.com/docs/guides/audio).
     """
 
@@ -66,5 +66,5 @@ class ChatCompletionAssistantMessageParam(TypedDict, total=False):
     refusal: Optional[str]
     """The refusal message by the assistant."""
 
-    tool_calls: Iterable[ChatCompletionMessageToolCallParam]
+    tool_calls: Iterable[ChatCompletionMessageToolCallUnionParam]
     """The tool calls generated by the model, such as function calls."""
diff --git a/src/openai/types/chat/chat_completion_audio.py b/src/openai/types/chat/chat_completion_audio.py
index dd15508ebb..232d60563d 100644
--- a/src/openai/types/chat/chat_completion_audio.py
+++ b/src/openai/types/chat/chat_completion_audio.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from ..._models import BaseModel
 
 __all__ = ["ChatCompletionAudio"]
diff --git a/src/openai/types/chat/chat_completion_audio_param.py b/src/openai/types/chat/chat_completion_audio_param.py
index 6321417826..b1576b41df 100644
--- a/src/openai/types/chat/chat_completion_audio_param.py
+++ b/src/openai/types/chat/chat_completion_audio_param.py
@@ -2,21 +2,24 @@
 
 from __future__ import annotations
 
+from typing import Union
 from typing_extensions import Literal, Required, TypedDict
 
 __all__ = ["ChatCompletionAudioParam"]
 
 
 class ChatCompletionAudioParam(TypedDict, total=False):
-    format: Required[Literal["wav", "mp3", "flac", "opus", "pcm16"]]
+    format: Required[Literal["wav", "aac", "mp3", "flac", "opus", "pcm16"]]
     """Specifies the output audio format.
 
     Must be one of `wav`, `mp3`, `flac`, `opus`, or `pcm16`.
     """
 
-    voice: Required[Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"]]
+    voice: Required[
+        Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"]]
+    ]
     """The voice the model uses to respond.
 
-    Supported voices are `alloy`, `ash`, `ballad`, `coral`, `echo`, `sage`, and
-    `shimmer`.
+    Supported voices are `alloy`, `ash`, `ballad`, `coral`, `echo`, `fable`, `nova`,
+    `onyx`, `sage`, and `shimmer`.
     """
diff --git a/src/openai/types/chat/chat_completion_chunk.py b/src/openai/types/chat/chat_completion_chunk.py
index dede513f1e..ea32d157ef 100644
--- a/src/openai/types/chat/chat_completion_chunk.py
+++ b/src/openai/types/chat/chat_completion_chunk.py
@@ -128,8 +128,24 @@ class ChatCompletionChunk(BaseModel):
     object: Literal["chat.completion.chunk"]
     """The object type, which is always `chat.completion.chunk`."""
 
-    service_tier: Optional[Literal["scale", "default"]] = None
-    """The service tier used for processing the request."""
+    service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] = None
+    """Specifies the processing type used for serving the request.
+
+    - If set to 'auto', then the request will be processed with the service tier
+      configured in the Project settings. Unless otherwise configured, the Project
+      will use 'default'.
+    - If set to 'default', then the request will be processed with the standard
+      pricing and performance for the selected model.
+    - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+      '[priority](https://openai.com/api-priority-processing/)', then the request
+      will be processed with the corresponding service tier.
+    - When not set, the default behavior is 'auto'.
+
+    When the `service_tier` parameter is set, the response body will include the
+    `service_tier` value based on the processing mode actually used to serve the
+    request. This response value may be different from the value set in the
+    parameter.
+    """
 
     system_fingerprint: Optional[str] = None
     """
@@ -142,6 +158,9 @@ class ChatCompletionChunk(BaseModel):
     """
     An optional field that will only be present when you set
     `stream_options: {"include_usage": true}` in your request. When present, it
-    contains a null value except for the last chunk which contains the token usage
-    statistics for the entire request.
+    contains a null value **except for the last chunk** which contains the token
+    usage statistics for the entire request.
+
+    **NOTE:** If the stream is interrupted or cancelled, you may not receive the
+    final usage chunk which contains the total token usage for the request.
     """
diff --git a/src/openai/types/chat/chat_completion_content_part_image.py b/src/openai/types/chat/chat_completion_content_part_image.py
new file mode 100644
index 0000000000..c1386b9dd3
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_content_part_image.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ChatCompletionContentPartImage", "ImageURL"]
+
+
+class ImageURL(BaseModel):
+    url: str
+    """Either a URL of the image or the base64 encoded image data."""
+
+    detail: Optional[Literal["auto", "low", "high"]] = None
+    """Specifies the detail level of the image.
+
+    Learn more in the
+    [Vision guide](https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding).
+    """
+
+
+class ChatCompletionContentPartImage(BaseModel):
+    image_url: ImageURL
+
+    type: Literal["image_url"]
+    """The type of the content part."""
diff --git a/src/openai/types/chat/chat_completion_content_part_param.py b/src/openai/types/chat/chat_completion_content_part_param.py
index 1293c54312..cbedc853ba 100644
--- a/src/openai/types/chat/chat_completion_content_part_param.py
+++ b/src/openai/types/chat/chat_completion_content_part_param.py
@@ -22,7 +22,7 @@ class FileFile(TypedDict, total=False):
     file_id: str
     """The ID of an uploaded file to use as input."""
 
-    file_name: str
+    filename: str
     """The name of the file, used when passing the file to the model as a string."""
 
 
diff --git a/src/openai/types/chat/chat_completion_content_part_text.py b/src/openai/types/chat/chat_completion_content_part_text.py
new file mode 100644
index 0000000000..f09f35f708
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_content_part_text.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ChatCompletionContentPartText"]
+
+
+class ChatCompletionContentPartText(BaseModel):
+    text: str
+    """The text content."""
+
+    type: Literal["text"]
+    """The type of the content part."""
diff --git a/src/openai/types/chat/chat_completion_custom_tool_param.py b/src/openai/types/chat/chat_completion_custom_tool_param.py
new file mode 100644
index 0000000000..14959ee449
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_custom_tool_param.py
@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = [
+    "ChatCompletionCustomToolParam",
+    "Custom",
+    "CustomFormat",
+    "CustomFormatText",
+    "CustomFormatGrammar",
+    "CustomFormatGrammarGrammar",
+]
+
+
+class CustomFormatText(TypedDict, total=False):
+    type: Required[Literal["text"]]
+    """Unconstrained text format. Always `text`."""
+
+
+class CustomFormatGrammarGrammar(TypedDict, total=False):
+    definition: Required[str]
+    """The grammar definition."""
+
+    syntax: Required[Literal["lark", "regex"]]
+    """The syntax of the grammar definition. One of `lark` or `regex`."""
+
+
+class CustomFormatGrammar(TypedDict, total=False):
+    grammar: Required[CustomFormatGrammarGrammar]
+    """Your chosen grammar."""
+
+    type: Required[Literal["grammar"]]
+    """Grammar format. Always `grammar`."""
+
+
+CustomFormat: TypeAlias = Union[CustomFormatText, CustomFormatGrammar]
+
+
+class Custom(TypedDict, total=False):
+    name: Required[str]
+    """The name of the custom tool, used to identify it in tool calls."""
+
+    description: str
+    """Optional description of the custom tool, used to provide more context."""
+
+    format: CustomFormat
+    """The input format for the custom tool. Default is unconstrained text."""
+
+
+class ChatCompletionCustomToolParam(TypedDict, total=False):
+    custom: Required[Custom]
+    """Properties of the custom tool."""
+
+    type: Required[Literal["custom"]]
+    """The type of the custom tool. Always `custom`."""
diff --git a/src/openai/types/chat/chat_completion_function_tool.py b/src/openai/types/chat/chat_completion_function_tool.py
new file mode 100644
index 0000000000..641568acf1
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_function_tool.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..shared.function_definition import FunctionDefinition
+
+__all__ = ["ChatCompletionFunctionTool"]
+
+
+class ChatCompletionFunctionTool(BaseModel):
+    function: FunctionDefinition
+
+    type: Literal["function"]
+    """The type of the tool. Currently, only `function` is supported."""
diff --git a/src/openai/types/chat/chat_completion_function_tool_param.py b/src/openai/types/chat/chat_completion_function_tool_param.py
new file mode 100644
index 0000000000..a39feea542
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_function_tool_param.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from ..shared_params.function_definition import FunctionDefinition
+
+__all__ = ["ChatCompletionFunctionToolParam"]
+
+
+class ChatCompletionFunctionToolParam(TypedDict, total=False):
+    function: Required[FunctionDefinition]
+
+    type: Required[Literal["function"]]
+    """The type of the tool. Currently, only `function` is supported."""
diff --git a/src/openai/types/chat/chat_completion_message.py b/src/openai/types/chat/chat_completion_message.py
index c659ac3da0..5bb153fe3f 100644
--- a/src/openai/types/chat/chat_completion_message.py
+++ b/src/openai/types/chat/chat_completion_message.py
@@ -5,7 +5,7 @@
 
 from ..._models import BaseModel
 from .chat_completion_audio import ChatCompletionAudio
-from .chat_completion_message_tool_call import ChatCompletionMessageToolCall
+from .chat_completion_message_tool_call import ChatCompletionMessageToolCallUnion
 
 __all__ = ["ChatCompletionMessage", "Annotation", "AnnotationURLCitation", "FunctionCall"]
 
@@ -75,5 +75,5 @@ class ChatCompletionMessage(BaseModel):
     model.
     """
 
-    tool_calls: Optional[List[ChatCompletionMessageToolCall]] = None
+    tool_calls: Optional[List[ChatCompletionMessageToolCallUnion]] = None
     """The tool calls generated by the model, such as function calls."""
diff --git a/src/openai/types/chat/chat_completion_message_custom_tool_call.py b/src/openai/types/chat/chat_completion_message_custom_tool_call.py
new file mode 100644
index 0000000000..b13c176afe
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_message_custom_tool_call.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ChatCompletionMessageCustomToolCall", "Custom"]
+
+
+class Custom(BaseModel):
+    input: str
+    """The input for the custom tool call generated by the model."""
+
+    name: str
+    """The name of the custom tool to call."""
+
+
+class ChatCompletionMessageCustomToolCall(BaseModel):
+    id: str
+    """The ID of the tool call."""
+
+    custom: Custom
+    """The custom tool that the model called."""
+
+    type: Literal["custom"]
+    """The type of the tool. Always `custom`."""
diff --git a/src/openai/types/chat/chat_completion_message_custom_tool_call_param.py b/src/openai/types/chat/chat_completion_message_custom_tool_call_param.py
new file mode 100644
index 0000000000..3753e0f200
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_message_custom_tool_call_param.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatCompletionMessageCustomToolCallParam", "Custom"]
+
+
+class Custom(TypedDict, total=False):
+    input: Required[str]
+    """The input for the custom tool call generated by the model."""
+
+    name: Required[str]
+    """The name of the custom tool to call."""
+
+
+class ChatCompletionMessageCustomToolCallParam(TypedDict, total=False):
+    id: Required[str]
+    """The ID of the tool call."""
+
+    custom: Required[Custom]
+    """The custom tool that the model called."""
+
+    type: Required[Literal["custom"]]
+    """The type of the tool. Always `custom`."""
diff --git a/src/openai/types/chat/chat_completion_message_function_tool_call.py b/src/openai/types/chat/chat_completion_message_function_tool_call.py
new file mode 100644
index 0000000000..d056d9aff6
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_message_function_tool_call.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ChatCompletionMessageFunctionToolCall", "Function"]
+
+
+class Function(BaseModel):
+    arguments: str
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: str
+    """The name of the function to call."""
+
+
+class ChatCompletionMessageFunctionToolCall(BaseModel):
+    id: str
+    """The ID of the tool call."""
+
+    function: Function
+    """The function that the model called."""
+
+    type: Literal["function"]
+    """The type of the tool. Currently, only `function` is supported."""
diff --git a/src/openai/types/chat/chat_completion_message_function_tool_call_param.py b/src/openai/types/chat/chat_completion_message_function_tool_call_param.py
new file mode 100644
index 0000000000..7c827edd2c
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_message_function_tool_call_param.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatCompletionMessageFunctionToolCallParam", "Function"]
+
+
+class Function(TypedDict, total=False):
+    arguments: Required[str]
+    """
+    The arguments to call the function with, as generated by the model in JSON
+    format. Note that the model does not always generate valid JSON, and may
+    hallucinate parameters not defined by your function schema. Validate the
+    arguments in your code before calling your function.
+    """
+
+    name: Required[str]
+    """The name of the function to call."""
+
+
+class ChatCompletionMessageFunctionToolCallParam(TypedDict, total=False):
+    id: Required[str]
+    """The ID of the tool call."""
+
+    function: Required[Function]
+    """The function that the model called."""
+
+    type: Required[Literal["function"]]
+    """The type of the tool. Currently, only `function` is supported."""
diff --git a/src/openai/types/chat/chat_completion_message_tool_call.py b/src/openai/types/chat/chat_completion_message_tool_call.py
index 4fec667096..71ac63f58e 100644
--- a/src/openai/types/chat/chat_completion_message_tool_call.py
+++ b/src/openai/types/chat/chat_completion_message_tool_call.py
@@ -1,31 +1,17 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing_extensions import Literal
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
 
-from ..._models import BaseModel
+from ..._utils import PropertyInfo
+from .chat_completion_message_custom_tool_call import ChatCompletionMessageCustomToolCall
+from .chat_completion_message_function_tool_call import Function as Function, ChatCompletionMessageFunctionToolCall
 
-__all__ = ["ChatCompletionMessageToolCall", "Function"]
+__all__ = ["Function", "ChatCompletionMessageToolCallUnion"]
 
+ChatCompletionMessageToolCallUnion: TypeAlias = Annotated[
+    Union[ChatCompletionMessageFunctionToolCall, ChatCompletionMessageCustomToolCall],
+    PropertyInfo(discriminator="type"),
+]
 
-class Function(BaseModel):
-    arguments: str
-    """
-    The arguments to call the function with, as generated by the model in JSON
-    format. Note that the model does not always generate valid JSON, and may
-    hallucinate parameters not defined by your function schema. Validate the
-    arguments in your code before calling your function.
-    """
-
-    name: str
-    """The name of the function to call."""
-
-
-class ChatCompletionMessageToolCall(BaseModel):
-    id: str
-    """The ID of the tool call."""
-
-    function: Function
-    """The function that the model called."""
-
-    type: Literal["function"]
-    """The type of the tool. Currently, only `function` is supported."""
+ChatCompletionMessageToolCall: TypeAlias = ChatCompletionMessageFunctionToolCall
diff --git a/src/openai/types/chat/chat_completion_message_tool_call_param.py b/src/openai/types/chat/chat_completion_message_tool_call_param.py
index f616c363d0..6baa1b57ab 100644
--- a/src/openai/types/chat/chat_completion_message_tool_call_param.py
+++ b/src/openai/types/chat/chat_completion_message_tool_call_param.py
@@ -2,30 +2,13 @@
 
 from __future__ import annotations
 
-from typing_extensions import Literal, Required, TypedDict
+from typing_extensions import TypeAlias
 
-__all__ = ["ChatCompletionMessageToolCallParam", "Function"]
-
-
-class Function(TypedDict, total=False):
-    arguments: Required[str]
-    """
-    The arguments to call the function with, as generated by the model in JSON
-    format. Note that the model does not always generate valid JSON, and may
-    hallucinate parameters not defined by your function schema. Validate the
-    arguments in your code before calling your function.
-    """
-
-    name: Required[str]
-    """The name of the function to call."""
+from .chat_completion_message_function_tool_call_param import (
+    Function as Function,
+    ChatCompletionMessageFunctionToolCallParam,
+)
 
+__all__ = ["ChatCompletionMessageToolCallParam", "Function"]
 
-class ChatCompletionMessageToolCallParam(TypedDict, total=False):
-    id: Required[str]
-    """The ID of the tool call."""
-
-    function: Required[Function]
-    """The function that the model called."""
-
-    type: Required[Literal["function"]]
-    """The type of the tool. Currently, only `function` is supported."""
+ChatCompletionMessageToolCallParam: TypeAlias = ChatCompletionMessageFunctionToolCallParam
diff --git a/src/openai/types/chat/chat_completion_message_tool_call_union_param.py b/src/openai/types/chat/chat_completion_message_tool_call_union_param.py
new file mode 100644
index 0000000000..fcca9bb116
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_message_tool_call_union_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .chat_completion_message_custom_tool_call_param import ChatCompletionMessageCustomToolCallParam
+from .chat_completion_message_function_tool_call_param import ChatCompletionMessageFunctionToolCallParam
+
+__all__ = ["ChatCompletionMessageToolCallUnionParam"]
+
+ChatCompletionMessageToolCallUnionParam: TypeAlias = Union[
+    ChatCompletionMessageFunctionToolCallParam, ChatCompletionMessageCustomToolCallParam
+]
diff --git a/src/openai/types/chat/chat_completion_named_tool_choice_custom_param.py b/src/openai/types/chat/chat_completion_named_tool_choice_custom_param.py
new file mode 100644
index 0000000000..1c123c0acb
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_named_tool_choice_custom_param.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ChatCompletionNamedToolChoiceCustomParam", "Custom"]
+
+
+class Custom(TypedDict, total=False):
+    name: Required[str]
+    """The name of the custom tool to call."""
+
+
+class ChatCompletionNamedToolChoiceCustomParam(TypedDict, total=False):
+    custom: Required[Custom]
+
+    type: Required[Literal["custom"]]
+    """For custom tool calling, the type is always `custom`."""
diff --git a/src/openai/types/chat/chat_completion_named_tool_choice_param.py b/src/openai/types/chat/chat_completion_named_tool_choice_param.py
index 369f8b42dd..ae1acfb909 100644
--- a/src/openai/types/chat/chat_completion_named_tool_choice_param.py
+++ b/src/openai/types/chat/chat_completion_named_tool_choice_param.py
@@ -16,4 +16,4 @@ class ChatCompletionNamedToolChoiceParam(TypedDict, total=False):
     function: Required[Function]
 
     type: Required[Literal["function"]]
-    """The type of the tool. Currently, only `function` is supported."""
+    """For function calling, the type is always `function`."""
diff --git a/src/openai/types/chat/chat_completion_reasoning_effort.py b/src/openai/types/chat/chat_completion_reasoning_effort.py
index e4785c90bf..42a980c5b8 100644
--- a/src/openai/types/chat/chat_completion_reasoning_effort.py
+++ b/src/openai/types/chat/chat_completion_reasoning_effort.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from ..shared.reasoning_effort import ReasoningEffort
 
 __all__ = ["ChatCompletionReasoningEffort"]
diff --git a/src/openai/types/chat/chat_completion_store_message.py b/src/openai/types/chat/chat_completion_store_message.py
index 95adc08af8..661342716b 100644
--- a/src/openai/types/chat/chat_completion_store_message.py
+++ b/src/openai/types/chat/chat_completion_store_message.py
@@ -1,11 +1,23 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import List, Union, Optional
+from typing_extensions import TypeAlias
 
 from .chat_completion_message import ChatCompletionMessage
+from .chat_completion_content_part_text import ChatCompletionContentPartText
+from .chat_completion_content_part_image import ChatCompletionContentPartImage
 
-__all__ = ["ChatCompletionStoreMessage"]
+__all__ = ["ChatCompletionStoreMessage", "ChatCompletionStoreMessageContentPart"]
+
+ChatCompletionStoreMessageContentPart: TypeAlias = Union[ChatCompletionContentPartText, ChatCompletionContentPartImage]
 
 
 class ChatCompletionStoreMessage(ChatCompletionMessage):
     id: str
     """The identifier of the chat message."""
+
+    content_parts: Optional[List[ChatCompletionStoreMessageContentPart]] = None
+    """
+    If a content parts array was provided, this is an array of `text` and
+    `image_url` parts. Otherwise, null.
+    """
diff --git a/src/openai/types/chat/chat_completion_stream_options_param.py b/src/openai/types/chat/chat_completion_stream_options_param.py
index fbf7291821..fc3191d2d1 100644
--- a/src/openai/types/chat/chat_completion_stream_options_param.py
+++ b/src/openai/types/chat/chat_completion_stream_options_param.py
@@ -8,10 +8,24 @@
 
 
 class ChatCompletionStreamOptionsParam(TypedDict, total=False):
+    include_obfuscation: bool
+    """When true, stream obfuscation will be enabled.
+
+    Stream obfuscation adds random characters to an `obfuscation` field on streaming
+    delta events to normalize payload sizes as a mitigation to certain side-channel
+    attacks. These obfuscation fields are included by default, but add a small
+    amount of overhead to the data stream. You can set `include_obfuscation` to
+    false to optimize for bandwidth if you trust the network links between your
+    application and the OpenAI API.
+    """
+
     include_usage: bool
     """If set, an additional chunk will be streamed before the `data: [DONE]` message.
 
     The `usage` field on this chunk shows the token usage statistics for the entire
-    request, and the `choices` field will always be an empty array. All other chunks
-    will also include a `usage` field, but with a null value.
+    request, and the `choices` field will always be an empty array.
+
+    All other chunks will also include a `usage` field, but with a null value.
+    **NOTE:** If the stream is interrupted, you may not receive the final usage
+    chunk which contains the total token usage for the request.
     """
diff --git a/src/openai/types/chat/chat_completion_tool_choice_option_param.py b/src/openai/types/chat/chat_completion_tool_choice_option_param.py
index 7dedf041b7..f3bb0a46df 100644
--- a/src/openai/types/chat/chat_completion_tool_choice_option_param.py
+++ b/src/openai/types/chat/chat_completion_tool_choice_option_param.py
@@ -6,9 +6,14 @@
 from typing_extensions import Literal, TypeAlias
 
 from .chat_completion_named_tool_choice_param import ChatCompletionNamedToolChoiceParam
+from .chat_completion_allowed_tool_choice_param import ChatCompletionAllowedToolChoiceParam
+from .chat_completion_named_tool_choice_custom_param import ChatCompletionNamedToolChoiceCustomParam
 
 __all__ = ["ChatCompletionToolChoiceOptionParam"]
 
 ChatCompletionToolChoiceOptionParam: TypeAlias = Union[
-    Literal["none", "auto", "required"], ChatCompletionNamedToolChoiceParam
+    Literal["none", "auto", "required"],
+    ChatCompletionAllowedToolChoiceParam,
+    ChatCompletionNamedToolChoiceParam,
+    ChatCompletionNamedToolChoiceCustomParam,
 ]
diff --git a/src/openai/types/chat/chat_completion_tool_param.py b/src/openai/types/chat/chat_completion_tool_param.py
index 6c2b1a36f0..a18b13b471 100644
--- a/src/openai/types/chat/chat_completion_tool_param.py
+++ b/src/openai/types/chat/chat_completion_tool_param.py
@@ -2,15 +2,13 @@
 
 from __future__ import annotations
 
-from typing_extensions import Literal, Required, TypedDict
+from typing_extensions import TypeAlias
 
-from ..shared_params.function_definition import FunctionDefinition
+from .chat_completion_function_tool_param import (
+    FunctionDefinition as FunctionDefinition,
+    ChatCompletionFunctionToolParam,
+)
 
-__all__ = ["ChatCompletionToolParam"]
+__all__ = ["ChatCompletionToolParam", "FunctionDefinition"]
 
-
-class ChatCompletionToolParam(TypedDict, total=False):
-    function: Required[FunctionDefinition]
-
-    type: Required[Literal["function"]]
-    """The type of the tool. Currently, only `function` is supported."""
+ChatCompletionToolParam: TypeAlias = ChatCompletionFunctionToolParam
diff --git a/src/openai/types/chat/chat_completion_tool_union_param.py b/src/openai/types/chat/chat_completion_tool_union_param.py
new file mode 100644
index 0000000000..0f8bf7b0e7
--- /dev/null
+++ b/src/openai/types/chat/chat_completion_tool_union_param.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .chat_completion_custom_tool_param import ChatCompletionCustomToolParam
+from .chat_completion_function_tool_param import ChatCompletionFunctionToolParam
+
+__all__ = ["ChatCompletionToolUnionParam"]
+
+ChatCompletionToolUnionParam: TypeAlias = Union[ChatCompletionFunctionToolParam, ChatCompletionCustomToolParam]
diff --git a/src/openai/types/chat/completion_create_params.py b/src/openai/types/chat/completion_create_params.py
index 05103fba91..e02c06cbb0 100644
--- a/src/openai/types/chat/completion_create_params.py
+++ b/src/openai/types/chat/completion_create_params.py
@@ -5,12 +5,13 @@
 from typing import Dict, List, Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from ..shared.chat_model import ChatModel
 from ..shared_params.metadata import Metadata
 from ..shared.reasoning_effort import ReasoningEffort
-from .chat_completion_tool_param import ChatCompletionToolParam
 from .chat_completion_audio_param import ChatCompletionAudioParam
 from .chat_completion_message_param import ChatCompletionMessageParam
+from .chat_completion_tool_union_param import ChatCompletionToolUnionParam
 from ..shared_params.function_parameters import FunctionParameters
 from ..shared_params.response_format_text import ResponseFormatText
 from .chat_completion_stream_options_param import ChatCompletionStreamOptionsParam
@@ -45,7 +46,7 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     """
 
     model: Required[Union[str, ChatModel]]
-    """Model ID used to generate the response, like `gpt-4o` or `o1`.
+    """Model ID used to generate the response, like `gpt-4o` or `o3`.
 
     OpenAI offers a wide range of models with different capabilities, performance
     characteristics, and price points. Refer to the
@@ -123,7 +124,7 @@ class CompletionCreateParamsBase(TypedDict, total=False):
 
     This value is now deprecated in favor of `max_completion_tokens`, and is not
     compatible with
-    [o1 series models](https://platform.openai.com/docs/guides/reasoning).
+    [o-series models](https://platform.openai.com/docs/guides/reasoning).
     """
 
     metadata: Optional[Metadata]
@@ -177,13 +178,35 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     far, increasing the model's likelihood to talk about new topics.
     """
 
-    reasoning_effort: Optional[ReasoningEffort]
-    """**o-series models only**
+    prompt_cache_key: str
+    """
+    Used by OpenAI to cache responses for similar requests to optimize your cache
+    hit rates. Replaces the `user` field.
+    [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+    """
 
+    prompt_cache_retention: Optional[Literal["in-memory", "24h"]]
+    """The retention policy for the prompt cache.
+
+    Set to `24h` to enable extended prompt caching, which keeps cached prefixes
+    active for longer, up to a maximum of 24 hours.
+    [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
+    """
+
+    reasoning_effort: Optional[ReasoningEffort]
+    """
     Constrains effort on reasoning for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-    result in faster responses and fewer tokens used on reasoning in a response.
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     """
 
     response_format: ResponseFormat
@@ -199,6 +222,15 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     preferred for models that support it.
     """
 
+    safety_identifier: str
+    """
+    A stable identifier used to help detect users of your application that may be
+    violating OpenAI's usage policies. The IDs should be a string that uniquely
+    identifies each user. We recommend hashing their username or email address, in
+    order to avoid sending us any identifying information.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+    """
+
     seed: Optional[int]
     """
     This feature is in Beta. If specified, our system will make a best effort to
@@ -208,28 +240,30 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     in the backend.
     """
 
-    service_tier: Optional[Literal["auto", "default"]]
-    """Specifies the latency tier to use for processing the request.
-
-    This parameter is relevant for customers subscribed to the scale tier service:
+    service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]]
+    """Specifies the processing type used for serving the request.
 
-    - If set to 'auto', and the Project is Scale tier enabled, the system will
-      utilize scale tier credits until they are exhausted.
-    - If set to 'auto', and the Project is not Scale tier enabled, the request will
-      be processed using the default service tier with a lower uptime SLA and no
-      latency guarentee.
-    - If set to 'default', the request will be processed using the default service
-      tier with a lower uptime SLA and no latency guarentee.
+    - If set to 'auto', then the request will be processed with the service tier
+      configured in the Project settings. Unless otherwise configured, the Project
+      will use 'default'.
+    - If set to 'default', then the request will be processed with the standard
+      pricing and performance for the selected model.
+    - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+      '[priority](https://openai.com/api-priority-processing/)', then the request
+      will be processed with the corresponding service tier.
     - When not set, the default behavior is 'auto'.
 
-    When this parameter is set, the response body will include the `service_tier`
-    utilized.
+    When the `service_tier` parameter is set, the response body will include the
+    `service_tier` value based on the processing mode actually used to serve the
+    request. This response value may be different from the value set in the
+    parameter.
     """
 
-    stop: Union[Optional[str], List[str], None]
-    """Up to 4 sequences where the API will stop generating further tokens.
+    stop: Union[Optional[str], SequenceNotStr[str], None]
+    """Not supported with latest reasoning models `o3` and `o4-mini`.
 
-    The returned text will not contain the stop sequence.
+    Up to 4 sequences where the API will stop generating further tokens. The
+    returned text will not contain the stop sequence.
     """
 
     store: Optional[bool]
@@ -237,6 +271,8 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     Whether or not to store the output of this chat completion request for use in
     our [model distillation](https://platform.openai.com/docs/guides/distillation)
     or [evals](https://platform.openai.com/docs/guides/evals) products.
+
+    Supports text and image inputs. Note: image inputs over 8MB will be dropped.
     """
 
     stream_options: Optional[ChatCompletionStreamOptionsParam]
@@ -263,12 +299,12 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     are present.
     """
 
-    tools: Iterable[ChatCompletionToolParam]
+    tools: Iterable[ChatCompletionToolUnionParam]
     """A list of tools the model may call.
 
-    Currently, only functions are supported as a tool. Use this to provide a list of
-    functions the model may generate JSON inputs for. A max of 128 functions are
-    supported.
+    You can provide either
+    [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
+    or [function tools](https://platform.openai.com/docs/guides/function-calling).
     """
 
     top_logprobs: Optional[int]
@@ -288,10 +324,20 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     """
 
     user: str
+    """This field is being replaced by `safety_identifier` and `prompt_cache_key`.
+
+    Use `prompt_cache_key` instead to maintain caching optimizations. A stable
+    identifier for your end-users. Used to boost cache hit rates by better bucketing
+    similar requests and to help OpenAI detect and prevent abuse.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
     """
-    A unique identifier representing your end-user, which can help OpenAI to monitor
-    and detect abuse.
-    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+    verbosity: Optional[Literal["low", "medium", "high"]]
+    """Constrains the verbosity of the model's response.
+
+    Lower values will result in more concise responses, while higher values will
+    result in more verbose responses. Currently supported values are `low`,
+    `medium`, and `high`.
     """
 
     web_search_options: WebSearchOptions
diff --git a/src/openai/types/chat/completion_list_params.py b/src/openai/types/chat/completion_list_params.py
index d93da834a3..32bd3f5c0a 100644
--- a/src/openai/types/chat/completion_list_params.py
+++ b/src/openai/types/chat/completion_list_params.py
@@ -18,9 +18,13 @@ class CompletionListParams(TypedDict, total=False):
     """Number of Chat Completions to retrieve."""
 
     metadata: Optional[Metadata]
-    """A list of metadata keys to filter the Chat Completions by. Example:
+    """Set of 16 key-value pairs that can be attached to an object.
 
-    `metadata[key1]=value1&metadata[key2]=value2`
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
     """
 
     model: str
diff --git a/src/openai/types/chat/parsed_function_tool_call.py b/src/openai/types/chat/parsed_function_tool_call.py
index 3e90789f85..e06b3546cb 100644
--- a/src/openai/types/chat/parsed_function_tool_call.py
+++ b/src/openai/types/chat/parsed_function_tool_call.py
@@ -2,7 +2,7 @@
 
 from typing import Optional
 
-from .chat_completion_message_tool_call import Function, ChatCompletionMessageToolCall
+from .chat_completion_message_function_tool_call import Function, ChatCompletionMessageFunctionToolCall
 
 __all__ = ["ParsedFunctionToolCall", "ParsedFunction"]
 
@@ -24,6 +24,6 @@ class ParsedFunction(Function):
     """
 
 
-class ParsedFunctionToolCall(ChatCompletionMessageToolCall):
+class ParsedFunctionToolCall(ChatCompletionMessageFunctionToolCall):
     function: ParsedFunction
     """The function that the model called."""
diff --git a/src/openai/types/chat_model.py b/src/openai/types/chat_model.py
index 9304d195d6..f3b0e310cc 100644
--- a/src/openai/types/chat_model.py
+++ b/src/openai/types/chat_model.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from .shared import chat_model
 
 __all__ = ["ChatModel"]
diff --git a/src/openai/types/completion_create_params.py b/src/openai/types/completion_create_params.py
index fdb1680d26..f9beb9afc7 100644
--- a/src/openai/types/completion_create_params.py
+++ b/src/openai/types/completion_create_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Iterable, Optional
+from typing import Dict, Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypedDict
 
+from .._types import SequenceNotStr
 from .chat.chat_completion_stream_options_param import ChatCompletionStreamOptionsParam
 
 __all__ = ["CompletionCreateParamsBase", "CompletionCreateParamsNonStreaming", "CompletionCreateParamsStreaming"]
@@ -21,7 +22,7 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     them.
     """
 
-    prompt: Required[Union[str, List[str], Iterable[int], Iterable[Iterable[int]], None]]
+    prompt: Required[Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]], None]]
     """
     The prompt(s) to generate completions for, encoded as a string, array of
     strings, array of tokens, or array of token arrays.
@@ -119,10 +120,11 @@ class CompletionCreateParamsBase(TypedDict, total=False):
     response parameter to monitor changes in the backend.
     """
 
-    stop: Union[Optional[str], List[str], None]
-    """Up to 4 sequences where the API will stop generating further tokens.
+    stop: Union[Optional[str], SequenceNotStr[str], None]
+    """Not supported with latest reasoning models `o3` and `o4-mini`.
 
-    The returned text will not contain the stop sequence.
+    Up to 4 sequences where the API will stop generating further tokens. The
+    returned text will not contain the stop sequence.
     """
 
     stream_options: Optional[ChatCompletionStreamOptionsParam]
diff --git a/src/openai/types/container_create_params.py b/src/openai/types/container_create_params.py
new file mode 100644
index 0000000000..01a48ac410
--- /dev/null
+++ b/src/openai/types/container_create_params.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["ContainerCreateParams", "ExpiresAfter"]
+
+
+class ContainerCreateParams(TypedDict, total=False):
+    name: Required[str]
+    """Name of the container to create."""
+
+    expires_after: ExpiresAfter
+    """Container expiration time in seconds relative to the 'anchor' time."""
+
+    file_ids: SequenceNotStr[str]
+    """IDs of files to copy to the container."""
+
+
+class ExpiresAfter(TypedDict, total=False):
+    anchor: Required[Literal["last_active_at"]]
+    """Time anchor for the expiration time.
+
+    Currently only 'last_active_at' is supported.
+    """
+
+    minutes: Required[int]
diff --git a/src/openai/types/container_create_response.py b/src/openai/types/container_create_response.py
new file mode 100644
index 0000000000..c0ccc45a1c
--- /dev/null
+++ b/src/openai/types/container_create_response.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ContainerCreateResponse", "ExpiresAfter"]
+
+
+class ExpiresAfter(BaseModel):
+    anchor: Optional[Literal["last_active_at"]] = None
+    """The reference point for the expiration."""
+
+    minutes: Optional[int] = None
+    """The number of minutes after the anchor before the container expires."""
+
+
+class ContainerCreateResponse(BaseModel):
+    id: str
+    """Unique identifier for the container."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the container was created."""
+
+    name: str
+    """Name of the container."""
+
+    object: str
+    """The type of this object."""
+
+    status: str
+    """Status of the container (e.g., active, deleted)."""
+
+    expires_after: Optional[ExpiresAfter] = None
+    """
+    The container will expire after this time period. The anchor is the reference
+    point for the expiration. The minutes is the number of minutes after the anchor
+    before the container expires.
+    """
diff --git a/src/openai/types/container_list_params.py b/src/openai/types/container_list_params.py
new file mode 100644
index 0000000000..4821a87d18
--- /dev/null
+++ b/src/openai/types/container_list_params.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["ContainerListParams"]
+
+
+class ContainerListParams(TypedDict, total=False):
+    after: str
+    """A cursor for use in pagination.
+
+    `after` is an object ID that defines your place in the list. For instance, if
+    you make a list request and receive 100 objects, ending with obj_foo, your
+    subsequent call can include after=obj_foo in order to fetch the next page of the
+    list.
+    """
+
+    limit: int
+    """A limit on the number of objects to be returned.
+
+    Limit can range between 1 and 100, and the default is 20.
+    """
+
+    order: Literal["asc", "desc"]
+    """Sort order by the `created_at` timestamp of the objects.
+
+    `asc` for ascending order and `desc` for descending order.
+    """
diff --git a/src/openai/types/container_list_response.py b/src/openai/types/container_list_response.py
new file mode 100644
index 0000000000..2d9c11d8a4
--- /dev/null
+++ b/src/openai/types/container_list_response.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ContainerListResponse", "ExpiresAfter"]
+
+
+class ExpiresAfter(BaseModel):
+    anchor: Optional[Literal["last_active_at"]] = None
+    """The reference point for the expiration."""
+
+    minutes: Optional[int] = None
+    """The number of minutes after the anchor before the container expires."""
+
+
+class ContainerListResponse(BaseModel):
+    id: str
+    """Unique identifier for the container."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the container was created."""
+
+    name: str
+    """Name of the container."""
+
+    object: str
+    """The type of this object."""
+
+    status: str
+    """Status of the container (e.g., active, deleted)."""
+
+    expires_after: Optional[ExpiresAfter] = None
+    """
+    The container will expire after this time period. The anchor is the reference
+    point for the expiration. The minutes is the number of minutes after the anchor
+    before the container expires.
+    """
diff --git a/src/openai/types/container_retrieve_response.py b/src/openai/types/container_retrieve_response.py
new file mode 100644
index 0000000000..eab291b34f
--- /dev/null
+++ b/src/openai/types/container_retrieve_response.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ContainerRetrieveResponse", "ExpiresAfter"]
+
+
+class ExpiresAfter(BaseModel):
+    anchor: Optional[Literal["last_active_at"]] = None
+    """The reference point for the expiration."""
+
+    minutes: Optional[int] = None
+    """The number of minutes after the anchor before the container expires."""
+
+
+class ContainerRetrieveResponse(BaseModel):
+    id: str
+    """Unique identifier for the container."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the container was created."""
+
+    name: str
+    """Name of the container."""
+
+    object: str
+    """The type of this object."""
+
+    status: str
+    """Status of the container (e.g., active, deleted)."""
+
+    expires_after: Optional[ExpiresAfter] = None
+    """
+    The container will expire after this time period. The anchor is the reference
+    point for the expiration. The minutes is the number of minutes after the anchor
+    before the container expires.
+    """
diff --git a/src/openai/types/containers/__init__.py b/src/openai/types/containers/__init__.py
new file mode 100644
index 0000000000..7d555ad3a4
--- /dev/null
+++ b/src/openai/types/containers/__init__.py
@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .file_list_params import FileListParams as FileListParams
+from .file_create_params import FileCreateParams as FileCreateParams
+from .file_list_response import FileListResponse as FileListResponse
+from .file_create_response import FileCreateResponse as FileCreateResponse
+from .file_retrieve_response import FileRetrieveResponse as FileRetrieveResponse
diff --git a/src/openai/types/containers/file_create_params.py b/src/openai/types/containers/file_create_params.py
new file mode 100644
index 0000000000..1e41330017
--- /dev/null
+++ b/src/openai/types/containers/file_create_params.py
@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+from ..._types import FileTypes
+
+__all__ = ["FileCreateParams"]
+
+
+class FileCreateParams(TypedDict, total=False):
+    file: FileTypes
+    """The File object (not file name) to be uploaded."""
+
+    file_id: str
+    """Name of the file to create."""
diff --git a/src/openai/types/containers/file_create_response.py b/src/openai/types/containers/file_create_response.py
new file mode 100644
index 0000000000..4a652483fc
--- /dev/null
+++ b/src/openai/types/containers/file_create_response.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["FileCreateResponse"]
+
+
+class FileCreateResponse(BaseModel):
+    id: str
+    """Unique identifier for the file."""
+
+    bytes: int
+    """Size of the file in bytes."""
+
+    container_id: str
+    """The container this file belongs to."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the file was created."""
+
+    object: Literal["container.file"]
+    """The type of this object (`container.file`)."""
+
+    path: str
+    """Path of the file in the container."""
+
+    source: str
+    """Source of the file (e.g., `user`, `assistant`)."""
diff --git a/src/openai/types/containers/file_list_params.py b/src/openai/types/containers/file_list_params.py
new file mode 100644
index 0000000000..3565acaf36
--- /dev/null
+++ b/src/openai/types/containers/file_list_params.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["FileListParams"]
+
+
+class FileListParams(TypedDict, total=False):
+    after: str
+    """A cursor for use in pagination.
+
+    `after` is an object ID that defines your place in the list. For instance, if
+    you make a list request and receive 100 objects, ending with obj_foo, your
+    subsequent call can include after=obj_foo in order to fetch the next page of the
+    list.
+    """
+
+    limit: int
+    """A limit on the number of objects to be returned.
+
+    Limit can range between 1 and 100, and the default is 20.
+    """
+
+    order: Literal["asc", "desc"]
+    """Sort order by the `created_at` timestamp of the objects.
+
+    `asc` for ascending order and `desc` for descending order.
+    """
diff --git a/src/openai/types/containers/file_list_response.py b/src/openai/types/containers/file_list_response.py
new file mode 100644
index 0000000000..e5eee38d99
--- /dev/null
+++ b/src/openai/types/containers/file_list_response.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["FileListResponse"]
+
+
+class FileListResponse(BaseModel):
+    id: str
+    """Unique identifier for the file."""
+
+    bytes: int
+    """Size of the file in bytes."""
+
+    container_id: str
+    """The container this file belongs to."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the file was created."""
+
+    object: Literal["container.file"]
+    """The type of this object (`container.file`)."""
+
+    path: str
+    """Path of the file in the container."""
+
+    source: str
+    """Source of the file (e.g., `user`, `assistant`)."""
diff --git a/src/openai/types/containers/file_retrieve_response.py b/src/openai/types/containers/file_retrieve_response.py
new file mode 100644
index 0000000000..37fb0e43dd
--- /dev/null
+++ b/src/openai/types/containers/file_retrieve_response.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["FileRetrieveResponse"]
+
+
+class FileRetrieveResponse(BaseModel):
+    id: str
+    """Unique identifier for the file."""
+
+    bytes: int
+    """Size of the file in bytes."""
+
+    container_id: str
+    """The container this file belongs to."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the file was created."""
+
+    object: Literal["container.file"]
+    """The type of this object (`container.file`)."""
+
+    path: str
+    """Path of the file in the container."""
+
+    source: str
+    """Source of the file (e.g., `user`, `assistant`)."""
diff --git a/src/openai/types/containers/files/__init__.py b/src/openai/types/containers/files/__init__.py
new file mode 100644
index 0000000000..f8ee8b14b1
--- /dev/null
+++ b/src/openai/types/containers/files/__init__.py
@@ -0,0 +1,3 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
diff --git a/src/openai/types/conversations/__init__.py b/src/openai/types/conversations/__init__.py
new file mode 100644
index 0000000000..9dec848737
--- /dev/null
+++ b/src/openai/types/conversations/__init__.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .message import Message as Message
+from .conversation import Conversation as Conversation
+from .text_content import TextContent as TextContent
+from .refusal_content import RefusalContent as RefusalContent
+from .item_list_params import ItemListParams as ItemListParams
+from .conversation_item import ConversationItem as ConversationItem
+from .input_file_content import InputFileContent as InputFileContent
+from .input_text_content import InputTextContent as InputTextContent
+from .item_create_params import ItemCreateParams as ItemCreateParams
+from .input_image_content import InputImageContent as InputImageContent
+from .output_text_content import OutputTextContent as OutputTextContent
+from .item_retrieve_params import ItemRetrieveParams as ItemRetrieveParams
+from .summary_text_content import SummaryTextContent as SummaryTextContent
+from .refusal_content_param import RefusalContentParam as RefusalContentParam
+from .conversation_item_list import ConversationItemList as ConversationItemList
+from .input_file_content_param import InputFileContentParam as InputFileContentParam
+from .input_text_content_param import InputTextContentParam as InputTextContentParam
+from .input_image_content_param import InputImageContentParam as InputImageContentParam
+from .output_text_content_param import OutputTextContentParam as OutputTextContentParam
+from .conversation_create_params import ConversationCreateParams as ConversationCreateParams
+from .conversation_update_params import ConversationUpdateParams as ConversationUpdateParams
+from .computer_screenshot_content import ComputerScreenshotContent as ComputerScreenshotContent
+from .conversation_deleted_resource import ConversationDeletedResource as ConversationDeletedResource
diff --git a/src/openai/types/conversations/computer_screenshot_content.py b/src/openai/types/conversations/computer_screenshot_content.py
new file mode 100644
index 0000000000..897b7ada0d
--- /dev/null
+++ b/src/openai/types/conversations/computer_screenshot_content.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ComputerScreenshotContent"]
+
+
+class ComputerScreenshotContent(BaseModel):
+    file_id: Optional[str] = None
+    """The identifier of an uploaded file that contains the screenshot."""
+
+    image_url: Optional[str] = None
+    """The URL of the screenshot image."""
+
+    type: Literal["computer_screenshot"]
+    """Specifies the event type.
+
+    For a computer screenshot, this property is always set to `computer_screenshot`.
+    """
diff --git a/src/openai/types/conversations/conversation.py b/src/openai/types/conversations/conversation.py
new file mode 100644
index 0000000000..ed63d40355
--- /dev/null
+++ b/src/openai/types/conversations/conversation.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["Conversation"]
+
+
+class Conversation(BaseModel):
+    id: str
+    """The unique ID of the conversation."""
+
+    created_at: int
+    """
+    The time at which the conversation was created, measured in seconds since the
+    Unix epoch.
+    """
+
+    metadata: object
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard. Keys are
+    strings with a maximum length of 64 characters. Values are strings with a
+    maximum length of 512 characters.
+    """
+
+    object: Literal["conversation"]
+    """The object type, which is always `conversation`."""
diff --git a/src/openai/types/conversations/conversation_create_params.py b/src/openai/types/conversations/conversation_create_params.py
new file mode 100644
index 0000000000..5f38d2aca7
--- /dev/null
+++ b/src/openai/types/conversations/conversation_create_params.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import TypedDict
+
+from ..shared_params.metadata import Metadata
+from ..responses.response_input_item_param import ResponseInputItemParam
+
+__all__ = ["ConversationCreateParams"]
+
+
+class ConversationCreateParams(TypedDict, total=False):
+    items: Optional[Iterable[ResponseInputItemParam]]
+    """Initial items to include in the conversation context.
+
+    You may add up to 20 items at a time.
+    """
+
+    metadata: Optional[Metadata]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
diff --git a/src/openai/types/conversations/conversation_deleted_resource.py b/src/openai/types/conversations/conversation_deleted_resource.py
new file mode 100644
index 0000000000..7abcb2448e
--- /dev/null
+++ b/src/openai/types/conversations/conversation_deleted_resource.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationDeletedResource"]
+
+
+class ConversationDeletedResource(BaseModel):
+    id: str
+
+    deleted: bool
+
+    object: Literal["conversation.deleted"]
diff --git a/src/openai/types/conversations/conversation_item.py b/src/openai/types/conversations/conversation_item.py
new file mode 100644
index 0000000000..052d09ce77
--- /dev/null
+++ b/src/openai/types/conversations/conversation_item.py
@@ -0,0 +1,230 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from .message import Message
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from ..responses.response_reasoning_item import ResponseReasoningItem
+from ..responses.response_custom_tool_call import ResponseCustomToolCall
+from ..responses.response_computer_tool_call import ResponseComputerToolCall
+from ..responses.response_function_web_search import ResponseFunctionWebSearch
+from ..responses.response_apply_patch_tool_call import ResponseApplyPatchToolCall
+from ..responses.response_file_search_tool_call import ResponseFileSearchToolCall
+from ..responses.response_custom_tool_call_output import ResponseCustomToolCallOutput
+from ..responses.response_function_tool_call_item import ResponseFunctionToolCallItem
+from ..responses.response_function_shell_tool_call import ResponseFunctionShellToolCall
+from ..responses.response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
+from ..responses.response_apply_patch_tool_call_output import ResponseApplyPatchToolCallOutput
+from ..responses.response_computer_tool_call_output_item import ResponseComputerToolCallOutputItem
+from ..responses.response_function_tool_call_output_item import ResponseFunctionToolCallOutputItem
+from ..responses.response_function_shell_tool_call_output import ResponseFunctionShellToolCallOutput
+
+__all__ = [
+    "ConversationItem",
+    "ImageGenerationCall",
+    "LocalShellCall",
+    "LocalShellCallAction",
+    "LocalShellCallOutput",
+    "McpListTools",
+    "McpListToolsTool",
+    "McpApprovalRequest",
+    "McpApprovalResponse",
+    "McpCall",
+]
+
+
+class ImageGenerationCall(BaseModel):
+    id: str
+    """The unique ID of the image generation call."""
+
+    result: Optional[str] = None
+    """The generated image encoded in base64."""
+
+    status: Literal["in_progress", "completed", "generating", "failed"]
+    """The status of the image generation call."""
+
+    type: Literal["image_generation_call"]
+    """The type of the image generation call. Always `image_generation_call`."""
+
+
+class LocalShellCallAction(BaseModel):
+    command: List[str]
+    """The command to run."""
+
+    env: Dict[str, str]
+    """Environment variables to set for the command."""
+
+    type: Literal["exec"]
+    """The type of the local shell action. Always `exec`."""
+
+    timeout_ms: Optional[int] = None
+    """Optional timeout in milliseconds for the command."""
+
+    user: Optional[str] = None
+    """Optional user to run the command as."""
+
+    working_directory: Optional[str] = None
+    """Optional working directory to run the command in."""
+
+
+class LocalShellCall(BaseModel):
+    id: str
+    """The unique ID of the local shell call."""
+
+    action: LocalShellCallAction
+    """Execute a shell command on the server."""
+
+    call_id: str
+    """The unique ID of the local shell tool call generated by the model."""
+
+    status: Literal["in_progress", "completed", "incomplete"]
+    """The status of the local shell call."""
+
+    type: Literal["local_shell_call"]
+    """The type of the local shell call. Always `local_shell_call`."""
+
+
+class LocalShellCallOutput(BaseModel):
+    id: str
+    """The unique ID of the local shell tool call generated by the model."""
+
+    output: str
+    """A JSON string of the output of the local shell tool call."""
+
+    type: Literal["local_shell_call_output"]
+    """The type of the local shell tool call output. Always `local_shell_call_output`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the item. One of `in_progress`, `completed`, or `incomplete`."""
+
+
+class McpListToolsTool(BaseModel):
+    input_schema: object
+    """The JSON schema describing the tool's input."""
+
+    name: str
+    """The name of the tool."""
+
+    annotations: Optional[object] = None
+    """Additional annotations about the tool."""
+
+    description: Optional[str] = None
+    """The description of the tool."""
+
+
+class McpListTools(BaseModel):
+    id: str
+    """The unique ID of the list."""
+
+    server_label: str
+    """The label of the MCP server."""
+
+    tools: List[McpListToolsTool]
+    """The tools available on the server."""
+
+    type: Literal["mcp_list_tools"]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    error: Optional[str] = None
+    """Error message if the server could not list tools."""
+
+
+class McpApprovalRequest(BaseModel):
+    id: str
+    """The unique ID of the approval request."""
+
+    arguments: str
+    """A JSON string of arguments for the tool."""
+
+    name: str
+    """The name of the tool to run."""
+
+    server_label: str
+    """The label of the MCP server making the request."""
+
+    type: Literal["mcp_approval_request"]
+    """The type of the item. Always `mcp_approval_request`."""
+
+
+class McpApprovalResponse(BaseModel):
+    id: str
+    """The unique ID of the approval response"""
+
+    approval_request_id: str
+    """The ID of the approval request being answered."""
+
+    approve: bool
+    """Whether the request was approved."""
+
+    type: Literal["mcp_approval_response"]
+    """The type of the item. Always `mcp_approval_response`."""
+
+    reason: Optional[str] = None
+    """Optional reason for the decision."""
+
+
+class McpCall(BaseModel):
+    id: str
+    """The unique ID of the tool call."""
+
+    arguments: str
+    """A JSON string of the arguments passed to the tool."""
+
+    name: str
+    """The name of the tool that was run."""
+
+    server_label: str
+    """The label of the MCP server running the tool."""
+
+    type: Literal["mcp_call"]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str] = None
+    """
+    Unique identifier for the MCP tool call approval request. Include this value in
+    a subsequent `mcp_approval_response` input to approve or reject the
+    corresponding tool call.
+    """
+
+    error: Optional[str] = None
+    """The error from the tool call, if any."""
+
+    output: Optional[str] = None
+    """The output from the tool call."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete", "calling", "failed"]] = None
+    """The status of the tool call.
+
+    One of `in_progress`, `completed`, `incomplete`, `calling`, or `failed`.
+    """
+
+
+ConversationItem: TypeAlias = Annotated[
+    Union[
+        Message,
+        ResponseFunctionToolCallItem,
+        ResponseFunctionToolCallOutputItem,
+        ResponseFileSearchToolCall,
+        ResponseFunctionWebSearch,
+        ImageGenerationCall,
+        ResponseComputerToolCall,
+        ResponseComputerToolCallOutputItem,
+        ResponseReasoningItem,
+        ResponseCodeInterpreterToolCall,
+        LocalShellCall,
+        LocalShellCallOutput,
+        ResponseFunctionShellToolCall,
+        ResponseFunctionShellToolCallOutput,
+        ResponseApplyPatchToolCall,
+        ResponseApplyPatchToolCallOutput,
+        McpListTools,
+        McpApprovalRequest,
+        McpApprovalResponse,
+        McpCall,
+        ResponseCustomToolCall,
+        ResponseCustomToolCallOutput,
+    ],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/conversations/conversation_item_list.py b/src/openai/types/conversations/conversation_item_list.py
new file mode 100644
index 0000000000..20091102cb
--- /dev/null
+++ b/src/openai/types/conversations/conversation_item_list.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ConversationItemList"]
+
+
+class ConversationItemList(BaseModel):
+    data: List[ConversationItem]
+    """A list of conversation items."""
+
+    first_id: str
+    """The ID of the first item in the list."""
+
+    has_more: bool
+    """Whether there are more items available."""
+
+    last_id: str
+    """The ID of the last item in the list."""
+
+    object: Literal["list"]
+    """The type of object returned, must be `list`."""
diff --git a/src/openai/types/conversations/conversation_update_params.py b/src/openai/types/conversations/conversation_update_params.py
new file mode 100644
index 0000000000..1f0dd09e50
--- /dev/null
+++ b/src/openai/types/conversations/conversation_update_params.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+from ..shared_params.metadata import Metadata
+
+__all__ = ["ConversationUpdateParams"]
+
+
+class ConversationUpdateParams(TypedDict, total=False):
+    metadata: Required[Optional[Metadata]]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
diff --git a/src/openai/types/conversations/input_file_content.py b/src/openai/types/conversations/input_file_content.py
new file mode 100644
index 0000000000..ca555d85fc
--- /dev/null
+++ b/src/openai/types/conversations/input_file_content.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..responses.response_input_file import ResponseInputFile
+
+__all__ = ["InputFileContent"]
+
+InputFileContent = ResponseInputFile
diff --git a/src/openai/types/conversations/input_file_content_param.py b/src/openai/types/conversations/input_file_content_param.py
new file mode 100644
index 0000000000..1ed8b8b9d1
--- /dev/null
+++ b/src/openai/types/conversations/input_file_content_param.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..responses.response_input_file_param import ResponseInputFileParam
+
+InputFileContentParam = ResponseInputFileParam
diff --git a/src/openai/types/conversations/input_image_content.py b/src/openai/types/conversations/input_image_content.py
new file mode 100644
index 0000000000..4304323c3a
--- /dev/null
+++ b/src/openai/types/conversations/input_image_content.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..responses.response_input_image import ResponseInputImage
+
+__all__ = ["InputImageContent"]
+
+InputImageContent = ResponseInputImage
diff --git a/src/openai/types/conversations/input_image_content_param.py b/src/openai/types/conversations/input_image_content_param.py
new file mode 100644
index 0000000000..a0ef9f545c
--- /dev/null
+++ b/src/openai/types/conversations/input_image_content_param.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..responses.response_input_image_param import ResponseInputImageParam
+
+InputImageContentParam = ResponseInputImageParam
diff --git a/src/openai/types/conversations/input_text_content.py b/src/openai/types/conversations/input_text_content.py
new file mode 100644
index 0000000000..cab8b26cb1
--- /dev/null
+++ b/src/openai/types/conversations/input_text_content.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..responses.response_input_text import ResponseInputText
+
+__all__ = ["InputTextContent"]
+
+InputTextContent = ResponseInputText
diff --git a/src/openai/types/conversations/input_text_content_param.py b/src/openai/types/conversations/input_text_content_param.py
new file mode 100644
index 0000000000..b1fd9a5f1c
--- /dev/null
+++ b/src/openai/types/conversations/input_text_content_param.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..responses.response_input_text_param import ResponseInputTextParam
+
+InputTextContentParam = ResponseInputTextParam
diff --git a/src/openai/types/conversations/item_create_params.py b/src/openai/types/conversations/item_create_params.py
new file mode 100644
index 0000000000..9158b7167f
--- /dev/null
+++ b/src/openai/types/conversations/item_create_params.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Iterable
+from typing_extensions import Required, TypedDict
+
+from ..responses.response_includable import ResponseIncludable
+from ..responses.response_input_item_param import ResponseInputItemParam
+
+__all__ = ["ItemCreateParams"]
+
+
+class ItemCreateParams(TypedDict, total=False):
+    items: Required[Iterable[ResponseInputItemParam]]
+    """The items to add to the conversation. You may add up to 20 items at a time."""
+
+    include: List[ResponseIncludable]
+    """Additional fields to include in the response.
+
+    See the `include` parameter for
+    [listing Conversation items above](https://platform.openai.com/docs/api-reference/conversations/list-items#conversations_list_items-include)
+    for more information.
+    """
diff --git a/src/openai/types/conversations/item_list_params.py b/src/openai/types/conversations/item_list_params.py
new file mode 100644
index 0000000000..a4dd61f399
--- /dev/null
+++ b/src/openai/types/conversations/item_list_params.py
@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, TypedDict
+
+from ..responses.response_includable import ResponseIncludable
+
+__all__ = ["ItemListParams"]
+
+
+class ItemListParams(TypedDict, total=False):
+    after: str
+    """An item ID to list items after, used in pagination."""
+
+    include: List[ResponseIncludable]
+    """Specify additional output data to include in the model response.
+
+    Currently supported values are:
+
+    - `web_search_call.action.sources`: Include the sources of the web search tool
+      call.
+    - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+      in code interpreter tool call items.
+    - `computer_call_output.output.image_url`: Include image urls from the computer
+      call output.
+    - `file_search_call.results`: Include the search results of the file search tool
+      call.
+    - `message.input_image.image_url`: Include image urls from the input message.
+    - `message.output_text.logprobs`: Include logprobs with assistant messages.
+    - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+      tokens in reasoning item outputs. This enables reasoning items to be used in
+      multi-turn conversations when using the Responses API statelessly (like when
+      the `store` parameter is set to `false`, or when an organization is enrolled
+      in the zero data retention program).
+    """
+
+    limit: int
+    """A limit on the number of objects to be returned.
+
+    Limit can range between 1 and 100, and the default is 20.
+    """
+
+    order: Literal["asc", "desc"]
+    """The order to return the input items in. Default is `desc`.
+
+    - `asc`: Return the input items in ascending order.
+    - `desc`: Return the input items in descending order.
+    """
diff --git a/src/openai/types/conversations/item_retrieve_params.py b/src/openai/types/conversations/item_retrieve_params.py
new file mode 100644
index 0000000000..8c5db1e533
--- /dev/null
+++ b/src/openai/types/conversations/item_retrieve_params.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, TypedDict
+
+from ..responses.response_includable import ResponseIncludable
+
+__all__ = ["ItemRetrieveParams"]
+
+
+class ItemRetrieveParams(TypedDict, total=False):
+    conversation_id: Required[str]
+
+    include: List[ResponseIncludable]
+    """Additional fields to include in the response.
+
+    See the `include` parameter for
+    [listing Conversation items above](https://platform.openai.com/docs/api-reference/conversations/list-items#conversations_list_items-include)
+    for more information.
+    """
diff --git a/src/openai/types/conversations/message.py b/src/openai/types/conversations/message.py
new file mode 100644
index 0000000000..dbf5a14680
--- /dev/null
+++ b/src/openai/types/conversations/message.py
@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .text_content import TextContent
+from .summary_text_content import SummaryTextContent
+from .computer_screenshot_content import ComputerScreenshotContent
+from ..responses.response_input_file import ResponseInputFile
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_image import ResponseInputImage
+from ..responses.response_output_text import ResponseOutputText
+from ..responses.response_output_refusal import ResponseOutputRefusal
+
+__all__ = ["Message", "Content", "ContentReasoningText"]
+
+
+class ContentReasoningText(BaseModel):
+    text: str
+    """The reasoning text from the model."""
+
+    type: Literal["reasoning_text"]
+    """The type of the reasoning text. Always `reasoning_text`."""
+
+
+Content: TypeAlias = Annotated[
+    Union[
+        ResponseInputText,
+        ResponseOutputText,
+        TextContent,
+        SummaryTextContent,
+        ContentReasoningText,
+        ResponseOutputRefusal,
+        ResponseInputImage,
+        ComputerScreenshotContent,
+        ResponseInputFile,
+    ],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class Message(BaseModel):
+    id: str
+    """The unique ID of the message."""
+
+    content: List[Content]
+    """The content of the message"""
+
+    role: Literal["unknown", "user", "assistant", "system", "critic", "discriminator", "developer", "tool"]
+    """The role of the message.
+
+    One of `unknown`, `user`, `assistant`, `system`, `critic`, `discriminator`,
+    `developer`, or `tool`.
+    """
+
+    status: Literal["in_progress", "completed", "incomplete"]
+    """The status of item.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
+    returned via API.
+    """
+
+    type: Literal["message"]
+    """The type of the message. Always set to `message`."""
diff --git a/src/openai/types/conversations/output_text_content.py b/src/openai/types/conversations/output_text_content.py
new file mode 100644
index 0000000000..cfe9307d74
--- /dev/null
+++ b/src/openai/types/conversations/output_text_content.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..responses.response_output_text import ResponseOutputText
+
+__all__ = ["OutputTextContent"]
+
+OutputTextContent = ResponseOutputText
diff --git a/src/openai/types/conversations/output_text_content_param.py b/src/openai/types/conversations/output_text_content_param.py
new file mode 100644
index 0000000000..dc3e2026f6
--- /dev/null
+++ b/src/openai/types/conversations/output_text_content_param.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..responses.response_output_text_param import ResponseOutputTextParam
+
+OutputTextContentParam = ResponseOutputTextParam
diff --git a/src/openai/types/conversations/refusal_content.py b/src/openai/types/conversations/refusal_content.py
new file mode 100644
index 0000000000..6206c267dc
--- /dev/null
+++ b/src/openai/types/conversations/refusal_content.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..responses.response_output_refusal import ResponseOutputRefusal
+
+__all__ = ["RefusalContent"]
+
+RefusalContent = ResponseOutputRefusal
diff --git a/src/openai/types/conversations/refusal_content_param.py b/src/openai/types/conversations/refusal_content_param.py
new file mode 100644
index 0000000000..9b83da5f2d
--- /dev/null
+++ b/src/openai/types/conversations/refusal_content_param.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from ..responses.response_output_refusal_param import ResponseOutputRefusalParam
+
+RefusalContentParam = ResponseOutputRefusalParam
diff --git a/src/openai/types/conversations/summary_text_content.py b/src/openai/types/conversations/summary_text_content.py
new file mode 100644
index 0000000000..d357b15725
--- /dev/null
+++ b/src/openai/types/conversations/summary_text_content.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["SummaryTextContent"]
+
+
+class SummaryTextContent(BaseModel):
+    text: str
+    """A summary of the reasoning output from the model so far."""
+
+    type: Literal["summary_text"]
+    """The type of the object. Always `summary_text`."""
diff --git a/src/openai/types/conversations/text_content.py b/src/openai/types/conversations/text_content.py
new file mode 100644
index 0000000000..f1ae079597
--- /dev/null
+++ b/src/openai/types/conversations/text_content.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TextContent"]
+
+
+class TextContent(BaseModel):
+    text: str
+
+    type: Literal["text"]
diff --git a/src/openai/types/embedding_create_params.py b/src/openai/types/embedding_create_params.py
index a90566449b..ab3e877964 100644
--- a/src/openai/types/embedding_create_params.py
+++ b/src/openai/types/embedding_create_params.py
@@ -2,25 +2,27 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable
+from typing import Union, Iterable
 from typing_extensions import Literal, Required, TypedDict
 
+from .._types import SequenceNotStr
 from .embedding_model import EmbeddingModel
 
 __all__ = ["EmbeddingCreateParams"]
 
 
 class EmbeddingCreateParams(TypedDict, total=False):
-    input: Required[Union[str, List[str], Iterable[int], Iterable[Iterable[int]]]]
+    input: Required[Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]]]]
     """Input text to embed, encoded as a string or array of tokens.
 
     To embed multiple inputs in a single request, pass an array of strings or array
     of token arrays. The input must not exceed the max input tokens for the model
-    (8192 tokens for `text-embedding-ada-002`), cannot be an empty string, and any
-    array must be 2048 dimensions or less.
+    (8192 tokens for all embedding models), cannot be an empty string, and any array
+    must be 2048 dimensions or less.
     [Example Python code](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)
-    for counting tokens. Some models may also impose a limit on total number of
-    tokens summed across inputs.
+    for counting tokens. In addition to the per-input token limit, all embedding
+    models enforce a maximum of 300,000 tokens summed across all inputs in a single
+    request.
     """
 
     model: Required[Union[str, EmbeddingModel]]
diff --git a/src/openai/types/eval_create_params.py b/src/openai/types/eval_create_params.py
new file mode 100644
index 0000000000..eb7f86cd92
--- /dev/null
+++ b/src/openai/types/eval_create_params.py
@@ -0,0 +1,202 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .._types import SequenceNotStr
+from .shared_params.metadata import Metadata
+from .graders.python_grader_param import PythonGraderParam
+from .graders.score_model_grader_param import ScoreModelGraderParam
+from .graders.string_check_grader_param import StringCheckGraderParam
+from .responses.response_input_text_param import ResponseInputTextParam
+from .graders.text_similarity_grader_param import TextSimilarityGraderParam
+from .responses.response_input_audio_param import ResponseInputAudioParam
+
+__all__ = [
+    "EvalCreateParams",
+    "DataSourceConfig",
+    "DataSourceConfigCustom",
+    "DataSourceConfigLogs",
+    "DataSourceConfigStoredCompletions",
+    "TestingCriterion",
+    "TestingCriterionLabelModel",
+    "TestingCriterionLabelModelInput",
+    "TestingCriterionLabelModelInputSimpleInputMessage",
+    "TestingCriterionLabelModelInputEvalItem",
+    "TestingCriterionLabelModelInputEvalItemContent",
+    "TestingCriterionLabelModelInputEvalItemContentOutputText",
+    "TestingCriterionLabelModelInputEvalItemContentInputImage",
+    "TestingCriterionTextSimilarity",
+    "TestingCriterionPython",
+    "TestingCriterionScoreModel",
+]
+
+
+class EvalCreateParams(TypedDict, total=False):
+    data_source_config: Required[DataSourceConfig]
+    """The configuration for the data source used for the evaluation runs.
+
+    Dictates the schema of the data used in the evaluation.
+    """
+
+    testing_criteria: Required[Iterable[TestingCriterion]]
+    """A list of graders for all eval runs in this group.
+
+    Graders can reference variables in the data source using double curly braces
+    notation, like `{{item.variable_name}}`. To reference the model's output, use
+    the `sample` namespace (ie, `{{sample.output_text}}`).
+    """
+
+    metadata: Optional[Metadata]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    name: str
+    """The name of the evaluation."""
+
+
+class DataSourceConfigCustom(TypedDict, total=False):
+    item_schema: Required[Dict[str, object]]
+    """The json schema for each row in the data source."""
+
+    type: Required[Literal["custom"]]
+    """The type of data source. Always `custom`."""
+
+    include_sample_schema: bool
+    """
+    Whether the eval should expect you to populate the sample namespace (ie, by
+    generating responses off of your data source)
+    """
+
+
+class DataSourceConfigLogs(TypedDict, total=False):
+    type: Required[Literal["logs"]]
+    """The type of data source. Always `logs`."""
+
+    metadata: Dict[str, object]
+    """Metadata filters for the logs data source."""
+
+
+class DataSourceConfigStoredCompletions(TypedDict, total=False):
+    type: Required[Literal["stored_completions"]]
+    """The type of data source. Always `stored_completions`."""
+
+    metadata: Dict[str, object]
+    """Metadata filters for the stored completions data source."""
+
+
+DataSourceConfig: TypeAlias = Union[DataSourceConfigCustom, DataSourceConfigLogs, DataSourceConfigStoredCompletions]
+
+
+class TestingCriterionLabelModelInputSimpleInputMessage(TypedDict, total=False):
+    content: Required[str]
+    """The content of the message."""
+
+    role: Required[str]
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class TestingCriterionLabelModelInputEvalItemContentOutputText(TypedDict, total=False):
+    text: Required[str]
+    """The text output from the model."""
+
+    type: Required[Literal["output_text"]]
+    """The type of the output text. Always `output_text`."""
+
+
+class TestingCriterionLabelModelInputEvalItemContentInputImage(TypedDict, total=False):
+    image_url: Required[str]
+    """The URL of the image input."""
+
+    type: Required[Literal["input_image"]]
+    """The type of the image input. Always `input_image`."""
+
+    detail: str
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+TestingCriterionLabelModelInputEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputTextParam,
+    TestingCriterionLabelModelInputEvalItemContentOutputText,
+    TestingCriterionLabelModelInputEvalItemContentInputImage,
+    ResponseInputAudioParam,
+    Iterable[object],
+]
+
+
+class TestingCriterionLabelModelInputEvalItem(TypedDict, total=False):
+    content: Required[TestingCriterionLabelModelInputEvalItemContent]
+    """Inputs to the model - can contain template strings."""
+
+    role: Required[Literal["user", "assistant", "system", "developer"]]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Literal["message"]
+    """The type of the message input. Always `message`."""
+
+
+TestingCriterionLabelModelInput: TypeAlias = Union[
+    TestingCriterionLabelModelInputSimpleInputMessage, TestingCriterionLabelModelInputEvalItem
+]
+
+
+class TestingCriterionLabelModel(TypedDict, total=False):
+    input: Required[Iterable[TestingCriterionLabelModelInput]]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    labels: Required[SequenceNotStr[str]]
+    """The labels to classify to each item in the evaluation."""
+
+    model: Required[str]
+    """The model to use for the evaluation. Must support structured outputs."""
+
+    name: Required[str]
+    """The name of the grader."""
+
+    passing_labels: Required[SequenceNotStr[str]]
+    """The labels that indicate a passing result. Must be a subset of labels."""
+
+    type: Required[Literal["label_model"]]
+    """The object type, which is always `label_model`."""
+
+
+class TestingCriterionTextSimilarity(TextSimilarityGraderParam, total=False):
+    pass_threshold: Required[float]
+    """The threshold for the score."""
+
+
+class TestingCriterionPython(PythonGraderParam, total=False):
+    pass_threshold: float
+    """The threshold for the score."""
+
+
+class TestingCriterionScoreModel(ScoreModelGraderParam, total=False):
+    pass_threshold: float
+    """The threshold for the score."""
+
+
+TestingCriterion: TypeAlias = Union[
+    TestingCriterionLabelModel,
+    StringCheckGraderParam,
+    TestingCriterionTextSimilarity,
+    TestingCriterionPython,
+    TestingCriterionScoreModel,
+]
diff --git a/src/openai/types/eval_create_response.py b/src/openai/types/eval_create_response.py
new file mode 100644
index 0000000000..20b0e3127f
--- /dev/null
+++ b/src/openai/types/eval_create_response.py
@@ -0,0 +1,111 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .shared.metadata import Metadata
+from .graders.python_grader import PythonGrader
+from .graders.label_model_grader import LabelModelGrader
+from .graders.score_model_grader import ScoreModelGrader
+from .graders.string_check_grader import StringCheckGrader
+from .eval_custom_data_source_config import EvalCustomDataSourceConfig
+from .graders.text_similarity_grader import TextSimilarityGrader
+from .eval_stored_completions_data_source_config import EvalStoredCompletionsDataSourceConfig
+
+__all__ = [
+    "EvalCreateResponse",
+    "DataSourceConfig",
+    "DataSourceConfigLogs",
+    "TestingCriterion",
+    "TestingCriterionEvalGraderTextSimilarity",
+    "TestingCriterionEvalGraderPython",
+    "TestingCriterionEvalGraderScoreModel",
+]
+
+
+class DataSourceConfigLogs(BaseModel):
+    schema_: Dict[str, object] = FieldInfo(alias="schema")
+    """
+    The json schema for the run data source items. Learn how to build JSON schemas
+    [here](https://json-schema.org/).
+    """
+
+    type: Literal["logs"]
+    """The type of data source. Always `logs`."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+
+DataSourceConfig: TypeAlias = Annotated[
+    Union[EvalCustomDataSourceConfig, DataSourceConfigLogs, EvalStoredCompletionsDataSourceConfig],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class TestingCriterionEvalGraderTextSimilarity(TextSimilarityGrader):
+    __test__ = False
+    pass_threshold: float
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderPython(PythonGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderScoreModel(ScoreModelGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+TestingCriterion: TypeAlias = Union[
+    LabelModelGrader,
+    StringCheckGrader,
+    TestingCriterionEvalGraderTextSimilarity,
+    TestingCriterionEvalGraderPython,
+    TestingCriterionEvalGraderScoreModel,
+]
+
+
+class EvalCreateResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the eval was created."""
+
+    data_source_config: DataSourceConfig
+    """Configuration of data sources used in runs of the evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    name: str
+    """The name of the evaluation."""
+
+    object: Literal["eval"]
+    """The object type."""
+
+    testing_criteria: List[TestingCriterion]
+    """A list of testing criteria."""
diff --git a/src/openai/types/eval_custom_data_source_config.py b/src/openai/types/eval_custom_data_source_config.py
new file mode 100644
index 0000000000..d99701cc71
--- /dev/null
+++ b/src/openai/types/eval_custom_data_source_config.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["EvalCustomDataSourceConfig"]
+
+
+class EvalCustomDataSourceConfig(BaseModel):
+    schema_: Dict[str, object] = FieldInfo(alias="schema")
+    """
+    The json schema for the run data source items. Learn how to build JSON schemas
+    [here](https://json-schema.org/).
+    """
+
+    type: Literal["custom"]
+    """The type of data source. Always `custom`."""
diff --git a/src/openai/types/eval_delete_response.py b/src/openai/types/eval_delete_response.py
new file mode 100644
index 0000000000..a27261e242
--- /dev/null
+++ b/src/openai/types/eval_delete_response.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["EvalDeleteResponse"]
+
+
+class EvalDeleteResponse(BaseModel):
+    deleted: bool
+
+    eval_id: str
+
+    object: str
diff --git a/src/openai/types/eval_list_params.py b/src/openai/types/eval_list_params.py
new file mode 100644
index 0000000000..d9a12d0ddf
--- /dev/null
+++ b/src/openai/types/eval_list_params.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["EvalListParams"]
+
+
+class EvalListParams(TypedDict, total=False):
+    after: str
+    """Identifier for the last eval from the previous pagination request."""
+
+    limit: int
+    """Number of evals to retrieve."""
+
+    order: Literal["asc", "desc"]
+    """Sort order for evals by timestamp.
+
+    Use `asc` for ascending order or `desc` for descending order.
+    """
+
+    order_by: Literal["created_at", "updated_at"]
+    """Evals can be ordered by creation time or last updated time.
+
+    Use `created_at` for creation time or `updated_at` for last updated time.
+    """
diff --git a/src/openai/types/eval_list_response.py b/src/openai/types/eval_list_response.py
new file mode 100644
index 0000000000..5ac4997cf6
--- /dev/null
+++ b/src/openai/types/eval_list_response.py
@@ -0,0 +1,111 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .shared.metadata import Metadata
+from .graders.python_grader import PythonGrader
+from .graders.label_model_grader import LabelModelGrader
+from .graders.score_model_grader import ScoreModelGrader
+from .graders.string_check_grader import StringCheckGrader
+from .eval_custom_data_source_config import EvalCustomDataSourceConfig
+from .graders.text_similarity_grader import TextSimilarityGrader
+from .eval_stored_completions_data_source_config import EvalStoredCompletionsDataSourceConfig
+
+__all__ = [
+    "EvalListResponse",
+    "DataSourceConfig",
+    "DataSourceConfigLogs",
+    "TestingCriterion",
+    "TestingCriterionEvalGraderTextSimilarity",
+    "TestingCriterionEvalGraderPython",
+    "TestingCriterionEvalGraderScoreModel",
+]
+
+
+class DataSourceConfigLogs(BaseModel):
+    schema_: Dict[str, object] = FieldInfo(alias="schema")
+    """
+    The json schema for the run data source items. Learn how to build JSON schemas
+    [here](https://json-schema.org/).
+    """
+
+    type: Literal["logs"]
+    """The type of data source. Always `logs`."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+
+DataSourceConfig: TypeAlias = Annotated[
+    Union[EvalCustomDataSourceConfig, DataSourceConfigLogs, EvalStoredCompletionsDataSourceConfig],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class TestingCriterionEvalGraderTextSimilarity(TextSimilarityGrader):
+    __test__ = False
+    pass_threshold: float
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderPython(PythonGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderScoreModel(ScoreModelGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+TestingCriterion: TypeAlias = Union[
+    LabelModelGrader,
+    StringCheckGrader,
+    TestingCriterionEvalGraderTextSimilarity,
+    TestingCriterionEvalGraderPython,
+    TestingCriterionEvalGraderScoreModel,
+]
+
+
+class EvalListResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the eval was created."""
+
+    data_source_config: DataSourceConfig
+    """Configuration of data sources used in runs of the evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    name: str
+    """The name of the evaluation."""
+
+    object: Literal["eval"]
+    """The object type."""
+
+    testing_criteria: List[TestingCriterion]
+    """A list of testing criteria."""
diff --git a/src/openai/types/eval_retrieve_response.py b/src/openai/types/eval_retrieve_response.py
new file mode 100644
index 0000000000..758f9cc040
--- /dev/null
+++ b/src/openai/types/eval_retrieve_response.py
@@ -0,0 +1,111 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .shared.metadata import Metadata
+from .graders.python_grader import PythonGrader
+from .graders.label_model_grader import LabelModelGrader
+from .graders.score_model_grader import ScoreModelGrader
+from .graders.string_check_grader import StringCheckGrader
+from .eval_custom_data_source_config import EvalCustomDataSourceConfig
+from .graders.text_similarity_grader import TextSimilarityGrader
+from .eval_stored_completions_data_source_config import EvalStoredCompletionsDataSourceConfig
+
+__all__ = [
+    "EvalRetrieveResponse",
+    "DataSourceConfig",
+    "DataSourceConfigLogs",
+    "TestingCriterion",
+    "TestingCriterionEvalGraderTextSimilarity",
+    "TestingCriterionEvalGraderPython",
+    "TestingCriterionEvalGraderScoreModel",
+]
+
+
+class DataSourceConfigLogs(BaseModel):
+    schema_: Dict[str, object] = FieldInfo(alias="schema")
+    """
+    The json schema for the run data source items. Learn how to build JSON schemas
+    [here](https://json-schema.org/).
+    """
+
+    type: Literal["logs"]
+    """The type of data source. Always `logs`."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+
+DataSourceConfig: TypeAlias = Annotated[
+    Union[EvalCustomDataSourceConfig, DataSourceConfigLogs, EvalStoredCompletionsDataSourceConfig],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class TestingCriterionEvalGraderTextSimilarity(TextSimilarityGrader):
+    __test__ = False
+    pass_threshold: float
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderPython(PythonGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderScoreModel(ScoreModelGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+TestingCriterion: TypeAlias = Union[
+    LabelModelGrader,
+    StringCheckGrader,
+    TestingCriterionEvalGraderTextSimilarity,
+    TestingCriterionEvalGraderPython,
+    TestingCriterionEvalGraderScoreModel,
+]
+
+
+class EvalRetrieveResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the eval was created."""
+
+    data_source_config: DataSourceConfig
+    """Configuration of data sources used in runs of the evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    name: str
+    """The name of the evaluation."""
+
+    object: Literal["eval"]
+    """The object type."""
+
+    testing_criteria: List[TestingCriterion]
+    """A list of testing criteria."""
diff --git a/src/openai/types/eval_stored_completions_data_source_config.py b/src/openai/types/eval_stored_completions_data_source_config.py
new file mode 100644
index 0000000000..98f86a4719
--- /dev/null
+++ b/src/openai/types/eval_stored_completions_data_source_config.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .shared.metadata import Metadata
+
+__all__ = ["EvalStoredCompletionsDataSourceConfig"]
+
+
+class EvalStoredCompletionsDataSourceConfig(BaseModel):
+    schema_: Dict[str, object] = FieldInfo(alias="schema")
+    """
+    The json schema for the run data source items. Learn how to build JSON schemas
+    [here](https://json-schema.org/).
+    """
+
+    type: Literal["stored_completions"]
+    """The type of data source. Always `stored_completions`."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
diff --git a/src/openai/types/eval_update_params.py b/src/openai/types/eval_update_params.py
new file mode 100644
index 0000000000..042db29af5
--- /dev/null
+++ b/src/openai/types/eval_update_params.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+from .shared_params.metadata import Metadata
+
+__all__ = ["EvalUpdateParams"]
+
+
+class EvalUpdateParams(TypedDict, total=False):
+    metadata: Optional[Metadata]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    name: str
+    """Rename the evaluation."""
diff --git a/src/openai/types/eval_update_response.py b/src/openai/types/eval_update_response.py
new file mode 100644
index 0000000000..3f0b90ae03
--- /dev/null
+++ b/src/openai/types/eval_update_response.py
@@ -0,0 +1,111 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .shared.metadata import Metadata
+from .graders.python_grader import PythonGrader
+from .graders.label_model_grader import LabelModelGrader
+from .graders.score_model_grader import ScoreModelGrader
+from .graders.string_check_grader import StringCheckGrader
+from .eval_custom_data_source_config import EvalCustomDataSourceConfig
+from .graders.text_similarity_grader import TextSimilarityGrader
+from .eval_stored_completions_data_source_config import EvalStoredCompletionsDataSourceConfig
+
+__all__ = [
+    "EvalUpdateResponse",
+    "DataSourceConfig",
+    "DataSourceConfigLogs",
+    "TestingCriterion",
+    "TestingCriterionEvalGraderTextSimilarity",
+    "TestingCriterionEvalGraderPython",
+    "TestingCriterionEvalGraderScoreModel",
+]
+
+
+class DataSourceConfigLogs(BaseModel):
+    schema_: Dict[str, object] = FieldInfo(alias="schema")
+    """
+    The json schema for the run data source items. Learn how to build JSON schemas
+    [here](https://json-schema.org/).
+    """
+
+    type: Literal["logs"]
+    """The type of data source. Always `logs`."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+
+DataSourceConfig: TypeAlias = Annotated[
+    Union[EvalCustomDataSourceConfig, DataSourceConfigLogs, EvalStoredCompletionsDataSourceConfig],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class TestingCriterionEvalGraderTextSimilarity(TextSimilarityGrader):
+    __test__ = False
+    pass_threshold: float
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderPython(PythonGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+class TestingCriterionEvalGraderScoreModel(ScoreModelGrader):
+    __test__ = False
+    pass_threshold: Optional[float] = None
+    """The threshold for the score."""
+
+
+TestingCriterion: TypeAlias = Union[
+    LabelModelGrader,
+    StringCheckGrader,
+    TestingCriterionEvalGraderTextSimilarity,
+    TestingCriterionEvalGraderPython,
+    TestingCriterionEvalGraderScoreModel,
+]
+
+
+class EvalUpdateResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the eval was created."""
+
+    data_source_config: DataSourceConfig
+    """Configuration of data sources used in runs of the evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    name: str
+    """The name of the evaluation."""
+
+    object: Literal["eval"]
+    """The object type."""
+
+    testing_criteria: List[TestingCriterion]
+    """A list of testing criteria."""
diff --git a/src/openai/types/evals/__init__.py b/src/openai/types/evals/__init__.py
new file mode 100644
index 0000000000..ebf84c6b8d
--- /dev/null
+++ b/src/openai/types/evals/__init__.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .eval_api_error import EvalAPIError as EvalAPIError
+from .run_list_params import RunListParams as RunListParams
+from .run_create_params import RunCreateParams as RunCreateParams
+from .run_list_response import RunListResponse as RunListResponse
+from .run_cancel_response import RunCancelResponse as RunCancelResponse
+from .run_create_response import RunCreateResponse as RunCreateResponse
+from .run_delete_response import RunDeleteResponse as RunDeleteResponse
+from .run_retrieve_response import RunRetrieveResponse as RunRetrieveResponse
+from .create_eval_jsonl_run_data_source import CreateEvalJSONLRunDataSource as CreateEvalJSONLRunDataSource
+from .create_eval_completions_run_data_source import (
+    CreateEvalCompletionsRunDataSource as CreateEvalCompletionsRunDataSource,
+)
+from .create_eval_jsonl_run_data_source_param import (
+    CreateEvalJSONLRunDataSourceParam as CreateEvalJSONLRunDataSourceParam,
+)
+from .create_eval_completions_run_data_source_param import (
+    CreateEvalCompletionsRunDataSourceParam as CreateEvalCompletionsRunDataSourceParam,
+)
diff --git a/src/openai/types/evals/create_eval_completions_run_data_source.py b/src/openai/types/evals/create_eval_completions_run_data_source.py
new file mode 100644
index 0000000000..742c27a775
--- /dev/null
+++ b/src/openai/types/evals/create_eval_completions_run_data_source.py
@@ -0,0 +1,236 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from ..shared.metadata import Metadata
+from ..shared.reasoning_effort import ReasoningEffort
+from ..shared.response_format_text import ResponseFormatText
+from ..responses.easy_input_message import EasyInputMessage
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_audio import ResponseInputAudio
+from ..chat.chat_completion_function_tool import ChatCompletionFunctionTool
+from ..shared.response_format_json_object import ResponseFormatJSONObject
+from ..shared.response_format_json_schema import ResponseFormatJSONSchema
+
+__all__ = [
+    "CreateEvalCompletionsRunDataSource",
+    "Source",
+    "SourceFileContent",
+    "SourceFileContentContent",
+    "SourceFileID",
+    "SourceStoredCompletions",
+    "InputMessages",
+    "InputMessagesTemplate",
+    "InputMessagesTemplateTemplate",
+    "InputMessagesTemplateTemplateEvalItem",
+    "InputMessagesTemplateTemplateEvalItemContent",
+    "InputMessagesTemplateTemplateEvalItemContentOutputText",
+    "InputMessagesTemplateTemplateEvalItemContentInputImage",
+    "InputMessagesItemReference",
+    "SamplingParams",
+    "SamplingParamsResponseFormat",
+]
+
+
+class SourceFileContentContent(BaseModel):
+    item: Dict[str, object]
+
+    sample: Optional[Dict[str, object]] = None
+
+
+class SourceFileContent(BaseModel):
+    content: List[SourceFileContentContent]
+    """The content of the jsonl file."""
+
+    type: Literal["file_content"]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class SourceFileID(BaseModel):
+    id: str
+    """The identifier of the file."""
+
+    type: Literal["file_id"]
+    """The type of jsonl source. Always `file_id`."""
+
+
+class SourceStoredCompletions(BaseModel):
+    type: Literal["stored_completions"]
+    """The type of source. Always `stored_completions`."""
+
+    created_after: Optional[int] = None
+    """An optional Unix timestamp to filter items created after this time."""
+
+    created_before: Optional[int] = None
+    """An optional Unix timestamp to filter items created before this time."""
+
+    limit: Optional[int] = None
+    """An optional maximum number of items to return."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    model: Optional[str] = None
+    """An optional model to filter by (e.g., 'gpt-4o')."""
+
+
+Source: TypeAlias = Annotated[
+    Union[SourceFileContent, SourceFileID, SourceStoredCompletions], PropertyInfo(discriminator="type")
+]
+
+
+class InputMessagesTemplateTemplateEvalItemContentOutputText(BaseModel):
+    text: str
+    """The text output from the model."""
+
+    type: Literal["output_text"]
+    """The type of the output text. Always `output_text`."""
+
+
+class InputMessagesTemplateTemplateEvalItemContentInputImage(BaseModel):
+    image_url: str
+    """The URL of the image input."""
+
+    type: Literal["input_image"]
+    """The type of the image input. Always `input_image`."""
+
+    detail: Optional[str] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+InputMessagesTemplateTemplateEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputText,
+    InputMessagesTemplateTemplateEvalItemContentOutputText,
+    InputMessagesTemplateTemplateEvalItemContentInputImage,
+    ResponseInputAudio,
+    List[object],
+]
+
+
+class InputMessagesTemplateTemplateEvalItem(BaseModel):
+    content: InputMessagesTemplateTemplateEvalItemContent
+    """Inputs to the model - can contain template strings."""
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
+
+
+InputMessagesTemplateTemplate: TypeAlias = Union[EasyInputMessage, InputMessagesTemplateTemplateEvalItem]
+
+
+class InputMessagesTemplate(BaseModel):
+    template: List[InputMessagesTemplateTemplate]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    type: Literal["template"]
+    """The type of input messages. Always `template`."""
+
+
+class InputMessagesItemReference(BaseModel):
+    item_reference: str
+    """A reference to a variable in the `item` namespace. Ie, "item.input_trajectory" """
+
+    type: Literal["item_reference"]
+    """The type of input messages. Always `item_reference`."""
+
+
+InputMessages: TypeAlias = Annotated[
+    Union[InputMessagesTemplate, InputMessagesItemReference], PropertyInfo(discriminator="type")
+]
+
+SamplingParamsResponseFormat: TypeAlias = Union[ResponseFormatText, ResponseFormatJSONSchema, ResponseFormatJSONObject]
+
+
+class SamplingParams(BaseModel):
+    max_completion_tokens: Optional[int] = None
+    """The maximum number of tokens in the generated output."""
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    response_format: Optional[SamplingParamsResponseFormat] = None
+    """An object specifying the format that the model must output.
+
+    Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+    Outputs which ensures the model will match your supplied JSON schema. Learn more
+    in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+    seed: Optional[int] = None
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: Optional[float] = None
+    """A higher temperature increases randomness in the outputs."""
+
+    tools: Optional[List[ChatCompletionFunctionTool]] = None
+    """A list of tools the model may call.
+
+    Currently, only functions are supported as a tool. Use this to provide a list of
+    functions the model may generate JSON inputs for. A max of 128 functions are
+    supported.
+    """
+
+    top_p: Optional[float] = None
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class CreateEvalCompletionsRunDataSource(BaseModel):
+    source: Source
+    """Determines what populates the `item` namespace in this run's data source."""
+
+    type: Literal["completions"]
+    """The type of run data source. Always `completions`."""
+
+    input_messages: Optional[InputMessages] = None
+    """Used when sampling from a model.
+
+    Dictates the structure of the messages passed into the model. Can either be a
+    reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
+    with variable references to the `item` namespace.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to use for generating completions (e.g. "o3-mini")."""
+
+    sampling_params: Optional[SamplingParams] = None
diff --git a/src/openai/types/evals/create_eval_completions_run_data_source_param.py b/src/openai/types/evals/create_eval_completions_run_data_source_param.py
new file mode 100644
index 0000000000..18cd5018b1
--- /dev/null
+++ b/src/openai/types/evals/create_eval_completions_run_data_source_param.py
@@ -0,0 +1,232 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..shared_params.metadata import Metadata
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.easy_input_message_param import EasyInputMessageParam
+from ..shared_params.response_format_text import ResponseFormatText
+from ..responses.response_input_text_param import ResponseInputTextParam
+from ..responses.response_input_audio_param import ResponseInputAudioParam
+from ..chat.chat_completion_function_tool_param import ChatCompletionFunctionToolParam
+from ..shared_params.response_format_json_object import ResponseFormatJSONObject
+from ..shared_params.response_format_json_schema import ResponseFormatJSONSchema
+
+__all__ = [
+    "CreateEvalCompletionsRunDataSourceParam",
+    "Source",
+    "SourceFileContent",
+    "SourceFileContentContent",
+    "SourceFileID",
+    "SourceStoredCompletions",
+    "InputMessages",
+    "InputMessagesTemplate",
+    "InputMessagesTemplateTemplate",
+    "InputMessagesTemplateTemplateEvalItem",
+    "InputMessagesTemplateTemplateEvalItemContent",
+    "InputMessagesTemplateTemplateEvalItemContentOutputText",
+    "InputMessagesTemplateTemplateEvalItemContentInputImage",
+    "InputMessagesItemReference",
+    "SamplingParams",
+    "SamplingParamsResponseFormat",
+]
+
+
+class SourceFileContentContent(TypedDict, total=False):
+    item: Required[Dict[str, object]]
+
+    sample: Dict[str, object]
+
+
+class SourceFileContent(TypedDict, total=False):
+    content: Required[Iterable[SourceFileContentContent]]
+    """The content of the jsonl file."""
+
+    type: Required[Literal["file_content"]]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class SourceFileID(TypedDict, total=False):
+    id: Required[str]
+    """The identifier of the file."""
+
+    type: Required[Literal["file_id"]]
+    """The type of jsonl source. Always `file_id`."""
+
+
+class SourceStoredCompletions(TypedDict, total=False):
+    type: Required[Literal["stored_completions"]]
+    """The type of source. Always `stored_completions`."""
+
+    created_after: Optional[int]
+    """An optional Unix timestamp to filter items created after this time."""
+
+    created_before: Optional[int]
+    """An optional Unix timestamp to filter items created before this time."""
+
+    limit: Optional[int]
+    """An optional maximum number of items to return."""
+
+    metadata: Optional[Metadata]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    model: Optional[str]
+    """An optional model to filter by (e.g., 'gpt-4o')."""
+
+
+Source: TypeAlias = Union[SourceFileContent, SourceFileID, SourceStoredCompletions]
+
+
+class InputMessagesTemplateTemplateEvalItemContentOutputText(TypedDict, total=False):
+    text: Required[str]
+    """The text output from the model."""
+
+    type: Required[Literal["output_text"]]
+    """The type of the output text. Always `output_text`."""
+
+
+class InputMessagesTemplateTemplateEvalItemContentInputImage(TypedDict, total=False):
+    image_url: Required[str]
+    """The URL of the image input."""
+
+    type: Required[Literal["input_image"]]
+    """The type of the image input. Always `input_image`."""
+
+    detail: str
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+InputMessagesTemplateTemplateEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputTextParam,
+    InputMessagesTemplateTemplateEvalItemContentOutputText,
+    InputMessagesTemplateTemplateEvalItemContentInputImage,
+    ResponseInputAudioParam,
+    Iterable[object],
+]
+
+
+class InputMessagesTemplateTemplateEvalItem(TypedDict, total=False):
+    content: Required[InputMessagesTemplateTemplateEvalItemContent]
+    """Inputs to the model - can contain template strings."""
+
+    role: Required[Literal["user", "assistant", "system", "developer"]]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Literal["message"]
+    """The type of the message input. Always `message`."""
+
+
+InputMessagesTemplateTemplate: TypeAlias = Union[EasyInputMessageParam, InputMessagesTemplateTemplateEvalItem]
+
+
+class InputMessagesTemplate(TypedDict, total=False):
+    template: Required[Iterable[InputMessagesTemplateTemplate]]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    type: Required[Literal["template"]]
+    """The type of input messages. Always `template`."""
+
+
+class InputMessagesItemReference(TypedDict, total=False):
+    item_reference: Required[str]
+    """A reference to a variable in the `item` namespace. Ie, "item.input_trajectory" """
+
+    type: Required[Literal["item_reference"]]
+    """The type of input messages. Always `item_reference`."""
+
+
+InputMessages: TypeAlias = Union[InputMessagesTemplate, InputMessagesItemReference]
+
+SamplingParamsResponseFormat: TypeAlias = Union[ResponseFormatText, ResponseFormatJSONSchema, ResponseFormatJSONObject]
+
+
+class SamplingParams(TypedDict, total=False):
+    max_completion_tokens: int
+    """The maximum number of tokens in the generated output."""
+
+    reasoning_effort: Optional[ReasoningEffort]
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    response_format: SamplingParamsResponseFormat
+    """An object specifying the format that the model must output.
+
+    Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
+    Outputs which ensures the model will match your supplied JSON schema. Learn more
+    in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+    seed: int
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: float
+    """A higher temperature increases randomness in the outputs."""
+
+    tools: Iterable[ChatCompletionFunctionToolParam]
+    """A list of tools the model may call.
+
+    Currently, only functions are supported as a tool. Use this to provide a list of
+    functions the model may generate JSON inputs for. A max of 128 functions are
+    supported.
+    """
+
+    top_p: float
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class CreateEvalCompletionsRunDataSourceParam(TypedDict, total=False):
+    source: Required[Source]
+    """Determines what populates the `item` namespace in this run's data source."""
+
+    type: Required[Literal["completions"]]
+    """The type of run data source. Always `completions`."""
+
+    input_messages: InputMessages
+    """Used when sampling from a model.
+
+    Dictates the structure of the messages passed into the model. Can either be a
+    reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
+    with variable references to the `item` namespace.
+    """
+
+    model: str
+    """The name of the model to use for generating completions (e.g. "o3-mini")."""
+
+    sampling_params: SamplingParams
diff --git a/src/openai/types/evals/create_eval_jsonl_run_data_source.py b/src/openai/types/evals/create_eval_jsonl_run_data_source.py
new file mode 100644
index 0000000000..ae36f8c55f
--- /dev/null
+++ b/src/openai/types/evals/create_eval_jsonl_run_data_source.py
@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = ["CreateEvalJSONLRunDataSource", "Source", "SourceFileContent", "SourceFileContentContent", "SourceFileID"]
+
+
+class SourceFileContentContent(BaseModel):
+    item: Dict[str, object]
+
+    sample: Optional[Dict[str, object]] = None
+
+
+class SourceFileContent(BaseModel):
+    content: List[SourceFileContentContent]
+    """The content of the jsonl file."""
+
+    type: Literal["file_content"]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class SourceFileID(BaseModel):
+    id: str
+    """The identifier of the file."""
+
+    type: Literal["file_id"]
+    """The type of jsonl source. Always `file_id`."""
+
+
+Source: TypeAlias = Annotated[Union[SourceFileContent, SourceFileID], PropertyInfo(discriminator="type")]
+
+
+class CreateEvalJSONLRunDataSource(BaseModel):
+    source: Source
+    """Determines what populates the `item` namespace in the data source."""
+
+    type: Literal["jsonl"]
+    """The type of data source. Always `jsonl`."""
diff --git a/src/openai/types/evals/create_eval_jsonl_run_data_source_param.py b/src/openai/types/evals/create_eval_jsonl_run_data_source_param.py
new file mode 100644
index 0000000000..217ee36346
--- /dev/null
+++ b/src/openai/types/evals/create_eval_jsonl_run_data_source_param.py
@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = [
+    "CreateEvalJSONLRunDataSourceParam",
+    "Source",
+    "SourceFileContent",
+    "SourceFileContentContent",
+    "SourceFileID",
+]
+
+
+class SourceFileContentContent(TypedDict, total=False):
+    item: Required[Dict[str, object]]
+
+    sample: Dict[str, object]
+
+
+class SourceFileContent(TypedDict, total=False):
+    content: Required[Iterable[SourceFileContentContent]]
+    """The content of the jsonl file."""
+
+    type: Required[Literal["file_content"]]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class SourceFileID(TypedDict, total=False):
+    id: Required[str]
+    """The identifier of the file."""
+
+    type: Required[Literal["file_id"]]
+    """The type of jsonl source. Always `file_id`."""
+
+
+Source: TypeAlias = Union[SourceFileContent, SourceFileID]
+
+
+class CreateEvalJSONLRunDataSourceParam(TypedDict, total=False):
+    source: Required[Source]
+    """Determines what populates the `item` namespace in the data source."""
+
+    type: Required[Literal["jsonl"]]
+    """The type of data source. Always `jsonl`."""
diff --git a/src/openai/types/evals/eval_api_error.py b/src/openai/types/evals/eval_api_error.py
new file mode 100644
index 0000000000..fe76871024
--- /dev/null
+++ b/src/openai/types/evals/eval_api_error.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["EvalAPIError"]
+
+
+class EvalAPIError(BaseModel):
+    code: str
+    """The error code."""
+
+    message: str
+    """The error message."""
diff --git a/src/openai/types/evals/run_cancel_response.py b/src/openai/types/evals/run_cancel_response.py
new file mode 100644
index 0000000000..b18598b20e
--- /dev/null
+++ b/src/openai/types/evals/run_cancel_response.py
@@ -0,0 +1,417 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .eval_api_error import EvalAPIError
+from ..responses.tool import Tool
+from ..shared.metadata import Metadata
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_audio import ResponseInputAudio
+from .create_eval_jsonl_run_data_source import CreateEvalJSONLRunDataSource
+from ..responses.response_format_text_config import ResponseFormatTextConfig
+from .create_eval_completions_run_data_source import CreateEvalCompletionsRunDataSource
+
+__all__ = [
+    "RunCancelResponse",
+    "DataSource",
+    "DataSourceResponses",
+    "DataSourceResponsesSource",
+    "DataSourceResponsesSourceFileContent",
+    "DataSourceResponsesSourceFileContentContent",
+    "DataSourceResponsesSourceFileID",
+    "DataSourceResponsesSourceResponses",
+    "DataSourceResponsesInputMessages",
+    "DataSourceResponsesInputMessagesTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplateChatMessage",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItem",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage",
+    "DataSourceResponsesInputMessagesItemReference",
+    "DataSourceResponsesSamplingParams",
+    "DataSourceResponsesSamplingParamsText",
+    "PerModelUsage",
+    "PerTestingCriteriaResult",
+    "ResultCounts",
+]
+
+
+class DataSourceResponsesSourceFileContentContent(BaseModel):
+    item: Dict[str, object]
+
+    sample: Optional[Dict[str, object]] = None
+
+
+class DataSourceResponsesSourceFileContent(BaseModel):
+    content: List[DataSourceResponsesSourceFileContentContent]
+    """The content of the jsonl file."""
+
+    type: Literal["file_content"]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class DataSourceResponsesSourceFileID(BaseModel):
+    id: str
+    """The identifier of the file."""
+
+    type: Literal["file_id"]
+    """The type of jsonl source. Always `file_id`."""
+
+
+class DataSourceResponsesSourceResponses(BaseModel):
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    created_after: Optional[int] = None
+    """Only include items created after this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    created_before: Optional[int] = None
+    """Only include items created before this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    instructions_search: Optional[str] = None
+    """Optional string to search the 'instructions' field.
+
+    This is a query parameter used to select responses.
+    """
+
+    metadata: Optional[object] = None
+    """Metadata filter for the responses.
+
+    This is a query parameter used to select responses.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to find responses for.
+
+    This is a query parameter used to select responses.
+    """
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    temperature: Optional[float] = None
+    """Sampling temperature. This is a query parameter used to select responses."""
+
+    tools: Optional[List[str]] = None
+    """List of tool names. This is a query parameter used to select responses."""
+
+    top_p: Optional[float] = None
+    """Nucleus sampling parameter. This is a query parameter used to select responses."""
+
+    users: Optional[List[str]] = None
+    """List of user identifiers. This is a query parameter used to select responses."""
+
+
+DataSourceResponsesSource: TypeAlias = Annotated[
+    Union[DataSourceResponsesSourceFileContent, DataSourceResponsesSourceFileID, DataSourceResponsesSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateChatMessage(BaseModel):
+    content: str
+    """The content of the message."""
+
+    role: str
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText(BaseModel):
+    text: str
+    """The text output from the model."""
+
+    type: Literal["output_text"]
+    """The type of the output text. Always `output_text`."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage(BaseModel):
+    image_url: str
+    """The URL of the image input."""
+
+    type: Literal["input_image"]
+    """The type of the image input. Always `input_image`."""
+
+    detail: Optional[str] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage,
+    ResponseInputAudio,
+    List[object],
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItem(BaseModel):
+    content: DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent
+    """Inputs to the model - can contain template strings."""
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
+
+
+DataSourceResponsesInputMessagesTemplateTemplate: TypeAlias = Union[
+    DataSourceResponsesInputMessagesTemplateTemplateChatMessage,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItem,
+]
+
+
+class DataSourceResponsesInputMessagesTemplate(BaseModel):
+    template: List[DataSourceResponsesInputMessagesTemplateTemplate]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    type: Literal["template"]
+    """The type of input messages. Always `template`."""
+
+
+class DataSourceResponsesInputMessagesItemReference(BaseModel):
+    item_reference: str
+    """A reference to a variable in the `item` namespace. Ie, "item.name" """
+
+    type: Literal["item_reference"]
+    """The type of input messages. Always `item_reference`."""
+
+
+DataSourceResponsesInputMessages: TypeAlias = Annotated[
+    Union[DataSourceResponsesInputMessagesTemplate, DataSourceResponsesInputMessagesItemReference],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesSamplingParamsText(BaseModel):
+    format: Optional[ResponseFormatTextConfig] = None
+    """An object specifying the format that the model must output.
+
+    Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+    ensures the model will match your supplied JSON schema. Learn more in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    The default format is `{ "type": "text" }` with no additional options.
+
+    **Not recommended for gpt-4o and newer models:**
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+
+class DataSourceResponsesSamplingParams(BaseModel):
+    max_completion_tokens: Optional[int] = None
+    """The maximum number of tokens in the generated output."""
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    seed: Optional[int] = None
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: Optional[float] = None
+    """A higher temperature increases randomness in the outputs."""
+
+    text: Optional[DataSourceResponsesSamplingParamsText] = None
+    """Configuration options for a text response from the model.
+
+    Can be plain text or structured JSON data. Learn more:
+
+    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+    - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+    """
+
+    tools: Optional[List[Tool]] = None
+    """An array of tools the model may call while generating a response.
+
+    You can specify which tool to use by setting the `tool_choice` parameter.
+
+    The two categories of tools you can provide the model are:
+
+    - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+      capabilities, like
+      [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+      [file search](https://platform.openai.com/docs/guides/tools-file-search).
+      Learn more about
+      [built-in tools](https://platform.openai.com/docs/guides/tools).
+    - **Function calls (custom tools)**: Functions that are defined by you, enabling
+      the model to call your own code. Learn more about
+      [function calling](https://platform.openai.com/docs/guides/function-calling).
+    """
+
+    top_p: Optional[float] = None
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class DataSourceResponses(BaseModel):
+    source: DataSourceResponsesSource
+    """Determines what populates the `item` namespace in this run's data source."""
+
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    input_messages: Optional[DataSourceResponsesInputMessages] = None
+    """Used when sampling from a model.
+
+    Dictates the structure of the messages passed into the model. Can either be a
+    reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
+    with variable references to the `item` namespace.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to use for generating completions (e.g. "o3-mini")."""
+
+    sampling_params: Optional[DataSourceResponsesSamplingParams] = None
+
+
+DataSource: TypeAlias = Annotated[
+    Union[CreateEvalJSONLRunDataSource, CreateEvalCompletionsRunDataSource, DataSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class PerModelUsage(BaseModel):
+    cached_tokens: int
+    """The number of tokens retrieved from cache."""
+
+    completion_tokens: int
+    """The number of completion tokens generated."""
+
+    invocation_count: int
+    """The number of invocations."""
+
+    run_model_name: str = FieldInfo(alias="model_name")
+    """The name of the model."""
+
+    prompt_tokens: int
+    """The number of prompt tokens used."""
+
+    total_tokens: int
+    """The total number of tokens used."""
+
+
+class PerTestingCriteriaResult(BaseModel):
+    failed: int
+    """Number of tests failed for this criteria."""
+
+    passed: int
+    """Number of tests passed for this criteria."""
+
+    testing_criteria: str
+    """A description of the testing criteria."""
+
+
+class ResultCounts(BaseModel):
+    errored: int
+    """Number of output items that resulted in an error."""
+
+    failed: int
+    """Number of output items that failed to pass the evaluation."""
+
+    passed: int
+    """Number of output items that passed the evaluation."""
+
+    total: int
+    """Total number of executed output items."""
+
+
+class RunCancelResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation run."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the evaluation run was created."""
+
+    data_source: DataSource
+    """Information about the run's data source."""
+
+    error: EvalAPIError
+    """An object representing an error response from the Eval API."""
+
+    eval_id: str
+    """The identifier of the associated evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    model: str
+    """The model that is evaluated, if applicable."""
+
+    name: str
+    """The name of the evaluation run."""
+
+    object: Literal["eval.run"]
+    """The type of the object. Always "eval.run"."""
+
+    per_model_usage: List[PerModelUsage]
+    """Usage statistics for each model during the evaluation run."""
+
+    per_testing_criteria_results: List[PerTestingCriteriaResult]
+    """Results per testing criteria applied during the evaluation run."""
+
+    report_url: str
+    """The URL to the rendered evaluation run report on the UI dashboard."""
+
+    result_counts: ResultCounts
+    """Counters summarizing the outcomes of the evaluation run."""
+
+    status: str
+    """The status of the evaluation run."""
diff --git a/src/openai/types/evals/run_create_params.py b/src/openai/types/evals/run_create_params.py
new file mode 100644
index 0000000000..a50433f06d
--- /dev/null
+++ b/src/openai/types/evals/run_create_params.py
@@ -0,0 +1,340 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..._types import SequenceNotStr
+from ..responses.tool_param import ToolParam
+from ..shared_params.metadata import Metadata
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.response_input_text_param import ResponseInputTextParam
+from ..responses.response_input_audio_param import ResponseInputAudioParam
+from .create_eval_jsonl_run_data_source_param import CreateEvalJSONLRunDataSourceParam
+from ..responses.response_format_text_config_param import ResponseFormatTextConfigParam
+from .create_eval_completions_run_data_source_param import CreateEvalCompletionsRunDataSourceParam
+
+__all__ = [
+    "RunCreateParams",
+    "DataSource",
+    "DataSourceCreateEvalResponsesRunDataSource",
+    "DataSourceCreateEvalResponsesRunDataSourceSource",
+    "DataSourceCreateEvalResponsesRunDataSourceSourceFileContent",
+    "DataSourceCreateEvalResponsesRunDataSourceSourceFileContentContent",
+    "DataSourceCreateEvalResponsesRunDataSourceSourceFileID",
+    "DataSourceCreateEvalResponsesRunDataSourceSourceResponses",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessages",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplate",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplate",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateChatMessage",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItem",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContent",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentOutputText",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentInputImage",
+    "DataSourceCreateEvalResponsesRunDataSourceInputMessagesItemReference",
+    "DataSourceCreateEvalResponsesRunDataSourceSamplingParams",
+    "DataSourceCreateEvalResponsesRunDataSourceSamplingParamsText",
+]
+
+
+class RunCreateParams(TypedDict, total=False):
+    data_source: Required[DataSource]
+    """Details about the run's data source."""
+
+    metadata: Optional[Metadata]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    name: str
+    """The name of the run."""
+
+
+class DataSourceCreateEvalResponsesRunDataSourceSourceFileContentContent(TypedDict, total=False):
+    item: Required[Dict[str, object]]
+
+    sample: Dict[str, object]
+
+
+class DataSourceCreateEvalResponsesRunDataSourceSourceFileContent(TypedDict, total=False):
+    content: Required[Iterable[DataSourceCreateEvalResponsesRunDataSourceSourceFileContentContent]]
+    """The content of the jsonl file."""
+
+    type: Required[Literal["file_content"]]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class DataSourceCreateEvalResponsesRunDataSourceSourceFileID(TypedDict, total=False):
+    id: Required[str]
+    """The identifier of the file."""
+
+    type: Required[Literal["file_id"]]
+    """The type of jsonl source. Always `file_id`."""
+
+
+class DataSourceCreateEvalResponsesRunDataSourceSourceResponses(TypedDict, total=False):
+    type: Required[Literal["responses"]]
+    """The type of run data source. Always `responses`."""
+
+    created_after: Optional[int]
+    """Only include items created after this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    created_before: Optional[int]
+    """Only include items created before this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    instructions_search: Optional[str]
+    """Optional string to search the 'instructions' field.
+
+    This is a query parameter used to select responses.
+    """
+
+    metadata: Optional[object]
+    """Metadata filter for the responses.
+
+    This is a query parameter used to select responses.
+    """
+
+    model: Optional[str]
+    """The name of the model to find responses for.
+
+    This is a query parameter used to select responses.
+    """
+
+    reasoning_effort: Optional[ReasoningEffort]
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    temperature: Optional[float]
+    """Sampling temperature. This is a query parameter used to select responses."""
+
+    tools: Optional[SequenceNotStr[str]]
+    """List of tool names. This is a query parameter used to select responses."""
+
+    top_p: Optional[float]
+    """Nucleus sampling parameter. This is a query parameter used to select responses."""
+
+    users: Optional[SequenceNotStr[str]]
+    """List of user identifiers. This is a query parameter used to select responses."""
+
+
+DataSourceCreateEvalResponsesRunDataSourceSource: TypeAlias = Union[
+    DataSourceCreateEvalResponsesRunDataSourceSourceFileContent,
+    DataSourceCreateEvalResponsesRunDataSourceSourceFileID,
+    DataSourceCreateEvalResponsesRunDataSourceSourceResponses,
+]
+
+
+class DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateChatMessage(TypedDict, total=False):
+    content: Required[str]
+    """The content of the message."""
+
+    role: Required[str]
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentOutputText(
+    TypedDict, total=False
+):
+    text: Required[str]
+    """The text output from the model."""
+
+    type: Required[Literal["output_text"]]
+    """The type of the output text. Always `output_text`."""
+
+
+class DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentInputImage(
+    TypedDict, total=False
+):
+    image_url: Required[str]
+    """The URL of the image input."""
+
+    type: Required[Literal["input_image"]]
+    """The type of the image input. Always `input_image`."""
+
+    detail: str
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputTextParam,
+    DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentOutputText,
+    DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentInputImage,
+    ResponseInputAudioParam,
+    Iterable[object],
+]
+
+
+class DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItem(TypedDict, total=False):
+    content: Required[DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContent]
+    """Inputs to the model - can contain template strings."""
+
+    role: Required[Literal["user", "assistant", "system", "developer"]]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Literal["message"]
+    """The type of the message input. Always `message`."""
+
+
+DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplate: TypeAlias = Union[
+    DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateChatMessage,
+    DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItem,
+]
+
+
+class DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplate(TypedDict, total=False):
+    template: Required[Iterable[DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplate]]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    type: Required[Literal["template"]]
+    """The type of input messages. Always `template`."""
+
+
+class DataSourceCreateEvalResponsesRunDataSourceInputMessagesItemReference(TypedDict, total=False):
+    item_reference: Required[str]
+    """A reference to a variable in the `item` namespace. Ie, "item.name" """
+
+    type: Required[Literal["item_reference"]]
+    """The type of input messages. Always `item_reference`."""
+
+
+DataSourceCreateEvalResponsesRunDataSourceInputMessages: TypeAlias = Union[
+    DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplate,
+    DataSourceCreateEvalResponsesRunDataSourceInputMessagesItemReference,
+]
+
+
+class DataSourceCreateEvalResponsesRunDataSourceSamplingParamsText(TypedDict, total=False):
+    format: ResponseFormatTextConfigParam
+    """An object specifying the format that the model must output.
+
+    Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+    ensures the model will match your supplied JSON schema. Learn more in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    The default format is `{ "type": "text" }` with no additional options.
+
+    **Not recommended for gpt-4o and newer models:**
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+
+class DataSourceCreateEvalResponsesRunDataSourceSamplingParams(TypedDict, total=False):
+    max_completion_tokens: int
+    """The maximum number of tokens in the generated output."""
+
+    reasoning_effort: Optional[ReasoningEffort]
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    seed: int
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: float
+    """A higher temperature increases randomness in the outputs."""
+
+    text: DataSourceCreateEvalResponsesRunDataSourceSamplingParamsText
+    """Configuration options for a text response from the model.
+
+    Can be plain text or structured JSON data. Learn more:
+
+    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+    - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+    """
+
+    tools: Iterable[ToolParam]
+    """An array of tools the model may call while generating a response.
+
+    You can specify which tool to use by setting the `tool_choice` parameter.
+
+    The two categories of tools you can provide the model are:
+
+    - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+      capabilities, like
+      [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+      [file search](https://platform.openai.com/docs/guides/tools-file-search).
+      Learn more about
+      [built-in tools](https://platform.openai.com/docs/guides/tools).
+    - **Function calls (custom tools)**: Functions that are defined by you, enabling
+      the model to call your own code. Learn more about
+      [function calling](https://platform.openai.com/docs/guides/function-calling).
+    """
+
+    top_p: float
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class DataSourceCreateEvalResponsesRunDataSource(TypedDict, total=False):
+    source: Required[DataSourceCreateEvalResponsesRunDataSourceSource]
+    """Determines what populates the `item` namespace in this run's data source."""
+
+    type: Required[Literal["responses"]]
+    """The type of run data source. Always `responses`."""
+
+    input_messages: DataSourceCreateEvalResponsesRunDataSourceInputMessages
+    """Used when sampling from a model.
+
+    Dictates the structure of the messages passed into the model. Can either be a
+    reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
+    with variable references to the `item` namespace.
+    """
+
+    model: str
+    """The name of the model to use for generating completions (e.g. "o3-mini")."""
+
+    sampling_params: DataSourceCreateEvalResponsesRunDataSourceSamplingParams
+
+
+DataSource: TypeAlias = Union[
+    CreateEvalJSONLRunDataSourceParam,
+    CreateEvalCompletionsRunDataSourceParam,
+    DataSourceCreateEvalResponsesRunDataSource,
+]
diff --git a/src/openai/types/evals/run_create_response.py b/src/openai/types/evals/run_create_response.py
new file mode 100644
index 0000000000..41dac615c7
--- /dev/null
+++ b/src/openai/types/evals/run_create_response.py
@@ -0,0 +1,417 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .eval_api_error import EvalAPIError
+from ..responses.tool import Tool
+from ..shared.metadata import Metadata
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_audio import ResponseInputAudio
+from .create_eval_jsonl_run_data_source import CreateEvalJSONLRunDataSource
+from ..responses.response_format_text_config import ResponseFormatTextConfig
+from .create_eval_completions_run_data_source import CreateEvalCompletionsRunDataSource
+
+__all__ = [
+    "RunCreateResponse",
+    "DataSource",
+    "DataSourceResponses",
+    "DataSourceResponsesSource",
+    "DataSourceResponsesSourceFileContent",
+    "DataSourceResponsesSourceFileContentContent",
+    "DataSourceResponsesSourceFileID",
+    "DataSourceResponsesSourceResponses",
+    "DataSourceResponsesInputMessages",
+    "DataSourceResponsesInputMessagesTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplateChatMessage",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItem",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage",
+    "DataSourceResponsesInputMessagesItemReference",
+    "DataSourceResponsesSamplingParams",
+    "DataSourceResponsesSamplingParamsText",
+    "PerModelUsage",
+    "PerTestingCriteriaResult",
+    "ResultCounts",
+]
+
+
+class DataSourceResponsesSourceFileContentContent(BaseModel):
+    item: Dict[str, object]
+
+    sample: Optional[Dict[str, object]] = None
+
+
+class DataSourceResponsesSourceFileContent(BaseModel):
+    content: List[DataSourceResponsesSourceFileContentContent]
+    """The content of the jsonl file."""
+
+    type: Literal["file_content"]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class DataSourceResponsesSourceFileID(BaseModel):
+    id: str
+    """The identifier of the file."""
+
+    type: Literal["file_id"]
+    """The type of jsonl source. Always `file_id`."""
+
+
+class DataSourceResponsesSourceResponses(BaseModel):
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    created_after: Optional[int] = None
+    """Only include items created after this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    created_before: Optional[int] = None
+    """Only include items created before this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    instructions_search: Optional[str] = None
+    """Optional string to search the 'instructions' field.
+
+    This is a query parameter used to select responses.
+    """
+
+    metadata: Optional[object] = None
+    """Metadata filter for the responses.
+
+    This is a query parameter used to select responses.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to find responses for.
+
+    This is a query parameter used to select responses.
+    """
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    temperature: Optional[float] = None
+    """Sampling temperature. This is a query parameter used to select responses."""
+
+    tools: Optional[List[str]] = None
+    """List of tool names. This is a query parameter used to select responses."""
+
+    top_p: Optional[float] = None
+    """Nucleus sampling parameter. This is a query parameter used to select responses."""
+
+    users: Optional[List[str]] = None
+    """List of user identifiers. This is a query parameter used to select responses."""
+
+
+DataSourceResponsesSource: TypeAlias = Annotated[
+    Union[DataSourceResponsesSourceFileContent, DataSourceResponsesSourceFileID, DataSourceResponsesSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateChatMessage(BaseModel):
+    content: str
+    """The content of the message."""
+
+    role: str
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText(BaseModel):
+    text: str
+    """The text output from the model."""
+
+    type: Literal["output_text"]
+    """The type of the output text. Always `output_text`."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage(BaseModel):
+    image_url: str
+    """The URL of the image input."""
+
+    type: Literal["input_image"]
+    """The type of the image input. Always `input_image`."""
+
+    detail: Optional[str] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage,
+    ResponseInputAudio,
+    List[object],
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItem(BaseModel):
+    content: DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent
+    """Inputs to the model - can contain template strings."""
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
+
+
+DataSourceResponsesInputMessagesTemplateTemplate: TypeAlias = Union[
+    DataSourceResponsesInputMessagesTemplateTemplateChatMessage,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItem,
+]
+
+
+class DataSourceResponsesInputMessagesTemplate(BaseModel):
+    template: List[DataSourceResponsesInputMessagesTemplateTemplate]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    type: Literal["template"]
+    """The type of input messages. Always `template`."""
+
+
+class DataSourceResponsesInputMessagesItemReference(BaseModel):
+    item_reference: str
+    """A reference to a variable in the `item` namespace. Ie, "item.name" """
+
+    type: Literal["item_reference"]
+    """The type of input messages. Always `item_reference`."""
+
+
+DataSourceResponsesInputMessages: TypeAlias = Annotated[
+    Union[DataSourceResponsesInputMessagesTemplate, DataSourceResponsesInputMessagesItemReference],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesSamplingParamsText(BaseModel):
+    format: Optional[ResponseFormatTextConfig] = None
+    """An object specifying the format that the model must output.
+
+    Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+    ensures the model will match your supplied JSON schema. Learn more in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    The default format is `{ "type": "text" }` with no additional options.
+
+    **Not recommended for gpt-4o and newer models:**
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+
+class DataSourceResponsesSamplingParams(BaseModel):
+    max_completion_tokens: Optional[int] = None
+    """The maximum number of tokens in the generated output."""
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    seed: Optional[int] = None
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: Optional[float] = None
+    """A higher temperature increases randomness in the outputs."""
+
+    text: Optional[DataSourceResponsesSamplingParamsText] = None
+    """Configuration options for a text response from the model.
+
+    Can be plain text or structured JSON data. Learn more:
+
+    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+    - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+    """
+
+    tools: Optional[List[Tool]] = None
+    """An array of tools the model may call while generating a response.
+
+    You can specify which tool to use by setting the `tool_choice` parameter.
+
+    The two categories of tools you can provide the model are:
+
+    - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+      capabilities, like
+      [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+      [file search](https://platform.openai.com/docs/guides/tools-file-search).
+      Learn more about
+      [built-in tools](https://platform.openai.com/docs/guides/tools).
+    - **Function calls (custom tools)**: Functions that are defined by you, enabling
+      the model to call your own code. Learn more about
+      [function calling](https://platform.openai.com/docs/guides/function-calling).
+    """
+
+    top_p: Optional[float] = None
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class DataSourceResponses(BaseModel):
+    source: DataSourceResponsesSource
+    """Determines what populates the `item` namespace in this run's data source."""
+
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    input_messages: Optional[DataSourceResponsesInputMessages] = None
+    """Used when sampling from a model.
+
+    Dictates the structure of the messages passed into the model. Can either be a
+    reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
+    with variable references to the `item` namespace.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to use for generating completions (e.g. "o3-mini")."""
+
+    sampling_params: Optional[DataSourceResponsesSamplingParams] = None
+
+
+DataSource: TypeAlias = Annotated[
+    Union[CreateEvalJSONLRunDataSource, CreateEvalCompletionsRunDataSource, DataSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class PerModelUsage(BaseModel):
+    cached_tokens: int
+    """The number of tokens retrieved from cache."""
+
+    completion_tokens: int
+    """The number of completion tokens generated."""
+
+    invocation_count: int
+    """The number of invocations."""
+
+    run_model_name: str = FieldInfo(alias="model_name")
+    """The name of the model."""
+
+    prompt_tokens: int
+    """The number of prompt tokens used."""
+
+    total_tokens: int
+    """The total number of tokens used."""
+
+
+class PerTestingCriteriaResult(BaseModel):
+    failed: int
+    """Number of tests failed for this criteria."""
+
+    passed: int
+    """Number of tests passed for this criteria."""
+
+    testing_criteria: str
+    """A description of the testing criteria."""
+
+
+class ResultCounts(BaseModel):
+    errored: int
+    """Number of output items that resulted in an error."""
+
+    failed: int
+    """Number of output items that failed to pass the evaluation."""
+
+    passed: int
+    """Number of output items that passed the evaluation."""
+
+    total: int
+    """Total number of executed output items."""
+
+
+class RunCreateResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation run."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the evaluation run was created."""
+
+    data_source: DataSource
+    """Information about the run's data source."""
+
+    error: EvalAPIError
+    """An object representing an error response from the Eval API."""
+
+    eval_id: str
+    """The identifier of the associated evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    model: str
+    """The model that is evaluated, if applicable."""
+
+    name: str
+    """The name of the evaluation run."""
+
+    object: Literal["eval.run"]
+    """The type of the object. Always "eval.run"."""
+
+    per_model_usage: List[PerModelUsage]
+    """Usage statistics for each model during the evaluation run."""
+
+    per_testing_criteria_results: List[PerTestingCriteriaResult]
+    """Results per testing criteria applied during the evaluation run."""
+
+    report_url: str
+    """The URL to the rendered evaluation run report on the UI dashboard."""
+
+    result_counts: ResultCounts
+    """Counters summarizing the outcomes of the evaluation run."""
+
+    status: str
+    """The status of the evaluation run."""
diff --git a/src/openai/types/evals/run_delete_response.py b/src/openai/types/evals/run_delete_response.py
new file mode 100644
index 0000000000..d48d01f86c
--- /dev/null
+++ b/src/openai/types/evals/run_delete_response.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["RunDeleteResponse"]
+
+
+class RunDeleteResponse(BaseModel):
+    deleted: Optional[bool] = None
+
+    object: Optional[str] = None
+
+    run_id: Optional[str] = None
diff --git a/src/openai/types/evals/run_list_params.py b/src/openai/types/evals/run_list_params.py
new file mode 100644
index 0000000000..383b89d85c
--- /dev/null
+++ b/src/openai/types/evals/run_list_params.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["RunListParams"]
+
+
+class RunListParams(TypedDict, total=False):
+    after: str
+    """Identifier for the last run from the previous pagination request."""
+
+    limit: int
+    """Number of runs to retrieve."""
+
+    order: Literal["asc", "desc"]
+    """Sort order for runs by timestamp.
+
+    Use `asc` for ascending order or `desc` for descending order. Defaults to `asc`.
+    """
+
+    status: Literal["queued", "in_progress", "completed", "canceled", "failed"]
+    """Filter runs by status.
+
+    One of `queued` | `in_progress` | `failed` | `completed` | `canceled`.
+    """
diff --git a/src/openai/types/evals/run_list_response.py b/src/openai/types/evals/run_list_response.py
new file mode 100644
index 0000000000..61bff95447
--- /dev/null
+++ b/src/openai/types/evals/run_list_response.py
@@ -0,0 +1,417 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .eval_api_error import EvalAPIError
+from ..responses.tool import Tool
+from ..shared.metadata import Metadata
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_audio import ResponseInputAudio
+from .create_eval_jsonl_run_data_source import CreateEvalJSONLRunDataSource
+from ..responses.response_format_text_config import ResponseFormatTextConfig
+from .create_eval_completions_run_data_source import CreateEvalCompletionsRunDataSource
+
+__all__ = [
+    "RunListResponse",
+    "DataSource",
+    "DataSourceResponses",
+    "DataSourceResponsesSource",
+    "DataSourceResponsesSourceFileContent",
+    "DataSourceResponsesSourceFileContentContent",
+    "DataSourceResponsesSourceFileID",
+    "DataSourceResponsesSourceResponses",
+    "DataSourceResponsesInputMessages",
+    "DataSourceResponsesInputMessagesTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplateChatMessage",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItem",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage",
+    "DataSourceResponsesInputMessagesItemReference",
+    "DataSourceResponsesSamplingParams",
+    "DataSourceResponsesSamplingParamsText",
+    "PerModelUsage",
+    "PerTestingCriteriaResult",
+    "ResultCounts",
+]
+
+
+class DataSourceResponsesSourceFileContentContent(BaseModel):
+    item: Dict[str, object]
+
+    sample: Optional[Dict[str, object]] = None
+
+
+class DataSourceResponsesSourceFileContent(BaseModel):
+    content: List[DataSourceResponsesSourceFileContentContent]
+    """The content of the jsonl file."""
+
+    type: Literal["file_content"]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class DataSourceResponsesSourceFileID(BaseModel):
+    id: str
+    """The identifier of the file."""
+
+    type: Literal["file_id"]
+    """The type of jsonl source. Always `file_id`."""
+
+
+class DataSourceResponsesSourceResponses(BaseModel):
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    created_after: Optional[int] = None
+    """Only include items created after this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    created_before: Optional[int] = None
+    """Only include items created before this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    instructions_search: Optional[str] = None
+    """Optional string to search the 'instructions' field.
+
+    This is a query parameter used to select responses.
+    """
+
+    metadata: Optional[object] = None
+    """Metadata filter for the responses.
+
+    This is a query parameter used to select responses.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to find responses for.
+
+    This is a query parameter used to select responses.
+    """
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    temperature: Optional[float] = None
+    """Sampling temperature. This is a query parameter used to select responses."""
+
+    tools: Optional[List[str]] = None
+    """List of tool names. This is a query parameter used to select responses."""
+
+    top_p: Optional[float] = None
+    """Nucleus sampling parameter. This is a query parameter used to select responses."""
+
+    users: Optional[List[str]] = None
+    """List of user identifiers. This is a query parameter used to select responses."""
+
+
+DataSourceResponsesSource: TypeAlias = Annotated[
+    Union[DataSourceResponsesSourceFileContent, DataSourceResponsesSourceFileID, DataSourceResponsesSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateChatMessage(BaseModel):
+    content: str
+    """The content of the message."""
+
+    role: str
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText(BaseModel):
+    text: str
+    """The text output from the model."""
+
+    type: Literal["output_text"]
+    """The type of the output text. Always `output_text`."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage(BaseModel):
+    image_url: str
+    """The URL of the image input."""
+
+    type: Literal["input_image"]
+    """The type of the image input. Always `input_image`."""
+
+    detail: Optional[str] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage,
+    ResponseInputAudio,
+    List[object],
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItem(BaseModel):
+    content: DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent
+    """Inputs to the model - can contain template strings."""
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
+
+
+DataSourceResponsesInputMessagesTemplateTemplate: TypeAlias = Union[
+    DataSourceResponsesInputMessagesTemplateTemplateChatMessage,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItem,
+]
+
+
+class DataSourceResponsesInputMessagesTemplate(BaseModel):
+    template: List[DataSourceResponsesInputMessagesTemplateTemplate]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    type: Literal["template"]
+    """The type of input messages. Always `template`."""
+
+
+class DataSourceResponsesInputMessagesItemReference(BaseModel):
+    item_reference: str
+    """A reference to a variable in the `item` namespace. Ie, "item.name" """
+
+    type: Literal["item_reference"]
+    """The type of input messages. Always `item_reference`."""
+
+
+DataSourceResponsesInputMessages: TypeAlias = Annotated[
+    Union[DataSourceResponsesInputMessagesTemplate, DataSourceResponsesInputMessagesItemReference],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesSamplingParamsText(BaseModel):
+    format: Optional[ResponseFormatTextConfig] = None
+    """An object specifying the format that the model must output.
+
+    Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+    ensures the model will match your supplied JSON schema. Learn more in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    The default format is `{ "type": "text" }` with no additional options.
+
+    **Not recommended for gpt-4o and newer models:**
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+
+class DataSourceResponsesSamplingParams(BaseModel):
+    max_completion_tokens: Optional[int] = None
+    """The maximum number of tokens in the generated output."""
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    seed: Optional[int] = None
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: Optional[float] = None
+    """A higher temperature increases randomness in the outputs."""
+
+    text: Optional[DataSourceResponsesSamplingParamsText] = None
+    """Configuration options for a text response from the model.
+
+    Can be plain text or structured JSON data. Learn more:
+
+    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+    - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+    """
+
+    tools: Optional[List[Tool]] = None
+    """An array of tools the model may call while generating a response.
+
+    You can specify which tool to use by setting the `tool_choice` parameter.
+
+    The two categories of tools you can provide the model are:
+
+    - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+      capabilities, like
+      [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+      [file search](https://platform.openai.com/docs/guides/tools-file-search).
+      Learn more about
+      [built-in tools](https://platform.openai.com/docs/guides/tools).
+    - **Function calls (custom tools)**: Functions that are defined by you, enabling
+      the model to call your own code. Learn more about
+      [function calling](https://platform.openai.com/docs/guides/function-calling).
+    """
+
+    top_p: Optional[float] = None
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class DataSourceResponses(BaseModel):
+    source: DataSourceResponsesSource
+    """Determines what populates the `item` namespace in this run's data source."""
+
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    input_messages: Optional[DataSourceResponsesInputMessages] = None
+    """Used when sampling from a model.
+
+    Dictates the structure of the messages passed into the model. Can either be a
+    reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
+    with variable references to the `item` namespace.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to use for generating completions (e.g. "o3-mini")."""
+
+    sampling_params: Optional[DataSourceResponsesSamplingParams] = None
+
+
+DataSource: TypeAlias = Annotated[
+    Union[CreateEvalJSONLRunDataSource, CreateEvalCompletionsRunDataSource, DataSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class PerModelUsage(BaseModel):
+    cached_tokens: int
+    """The number of tokens retrieved from cache."""
+
+    completion_tokens: int
+    """The number of completion tokens generated."""
+
+    invocation_count: int
+    """The number of invocations."""
+
+    run_model_name: str = FieldInfo(alias="model_name")
+    """The name of the model."""
+
+    prompt_tokens: int
+    """The number of prompt tokens used."""
+
+    total_tokens: int
+    """The total number of tokens used."""
+
+
+class PerTestingCriteriaResult(BaseModel):
+    failed: int
+    """Number of tests failed for this criteria."""
+
+    passed: int
+    """Number of tests passed for this criteria."""
+
+    testing_criteria: str
+    """A description of the testing criteria."""
+
+
+class ResultCounts(BaseModel):
+    errored: int
+    """Number of output items that resulted in an error."""
+
+    failed: int
+    """Number of output items that failed to pass the evaluation."""
+
+    passed: int
+    """Number of output items that passed the evaluation."""
+
+    total: int
+    """Total number of executed output items."""
+
+
+class RunListResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation run."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the evaluation run was created."""
+
+    data_source: DataSource
+    """Information about the run's data source."""
+
+    error: EvalAPIError
+    """An object representing an error response from the Eval API."""
+
+    eval_id: str
+    """The identifier of the associated evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    model: str
+    """The model that is evaluated, if applicable."""
+
+    name: str
+    """The name of the evaluation run."""
+
+    object: Literal["eval.run"]
+    """The type of the object. Always "eval.run"."""
+
+    per_model_usage: List[PerModelUsage]
+    """Usage statistics for each model during the evaluation run."""
+
+    per_testing_criteria_results: List[PerTestingCriteriaResult]
+    """Results per testing criteria applied during the evaluation run."""
+
+    report_url: str
+    """The URL to the rendered evaluation run report on the UI dashboard."""
+
+    result_counts: ResultCounts
+    """Counters summarizing the outcomes of the evaluation run."""
+
+    status: str
+    """The status of the evaluation run."""
diff --git a/src/openai/types/evals/run_retrieve_response.py b/src/openai/types/evals/run_retrieve_response.py
new file mode 100644
index 0000000000..651d7423a9
--- /dev/null
+++ b/src/openai/types/evals/run_retrieve_response.py
@@ -0,0 +1,417 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .eval_api_error import EvalAPIError
+from ..responses.tool import Tool
+from ..shared.metadata import Metadata
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_audio import ResponseInputAudio
+from .create_eval_jsonl_run_data_source import CreateEvalJSONLRunDataSource
+from ..responses.response_format_text_config import ResponseFormatTextConfig
+from .create_eval_completions_run_data_source import CreateEvalCompletionsRunDataSource
+
+__all__ = [
+    "RunRetrieveResponse",
+    "DataSource",
+    "DataSourceResponses",
+    "DataSourceResponsesSource",
+    "DataSourceResponsesSourceFileContent",
+    "DataSourceResponsesSourceFileContentContent",
+    "DataSourceResponsesSourceFileID",
+    "DataSourceResponsesSourceResponses",
+    "DataSourceResponsesInputMessages",
+    "DataSourceResponsesInputMessagesTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplate",
+    "DataSourceResponsesInputMessagesTemplateTemplateChatMessage",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItem",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText",
+    "DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage",
+    "DataSourceResponsesInputMessagesItemReference",
+    "DataSourceResponsesSamplingParams",
+    "DataSourceResponsesSamplingParamsText",
+    "PerModelUsage",
+    "PerTestingCriteriaResult",
+    "ResultCounts",
+]
+
+
+class DataSourceResponsesSourceFileContentContent(BaseModel):
+    item: Dict[str, object]
+
+    sample: Optional[Dict[str, object]] = None
+
+
+class DataSourceResponsesSourceFileContent(BaseModel):
+    content: List[DataSourceResponsesSourceFileContentContent]
+    """The content of the jsonl file."""
+
+    type: Literal["file_content"]
+    """The type of jsonl source. Always `file_content`."""
+
+
+class DataSourceResponsesSourceFileID(BaseModel):
+    id: str
+    """The identifier of the file."""
+
+    type: Literal["file_id"]
+    """The type of jsonl source. Always `file_id`."""
+
+
+class DataSourceResponsesSourceResponses(BaseModel):
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    created_after: Optional[int] = None
+    """Only include items created after this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    created_before: Optional[int] = None
+    """Only include items created before this timestamp (inclusive).
+
+    This is a query parameter used to select responses.
+    """
+
+    instructions_search: Optional[str] = None
+    """Optional string to search the 'instructions' field.
+
+    This is a query parameter used to select responses.
+    """
+
+    metadata: Optional[object] = None
+    """Metadata filter for the responses.
+
+    This is a query parameter used to select responses.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to find responses for.
+
+    This is a query parameter used to select responses.
+    """
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    temperature: Optional[float] = None
+    """Sampling temperature. This is a query parameter used to select responses."""
+
+    tools: Optional[List[str]] = None
+    """List of tool names. This is a query parameter used to select responses."""
+
+    top_p: Optional[float] = None
+    """Nucleus sampling parameter. This is a query parameter used to select responses."""
+
+    users: Optional[List[str]] = None
+    """List of user identifiers. This is a query parameter used to select responses."""
+
+
+DataSourceResponsesSource: TypeAlias = Annotated[
+    Union[DataSourceResponsesSourceFileContent, DataSourceResponsesSourceFileID, DataSourceResponsesSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateChatMessage(BaseModel):
+    content: str
+    """The content of the message."""
+
+    role: str
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText(BaseModel):
+    text: str
+    """The text output from the model."""
+
+    type: Literal["output_text"]
+    """The type of the output text. Always `output_text`."""
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage(BaseModel):
+    image_url: str
+    """The URL of the image input."""
+
+    type: Literal["input_image"]
+    """The type of the image input. Always `input_image`."""
+
+    detail: Optional[str] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent: TypeAlias = Union[
+    str,
+    ResponseInputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage,
+    ResponseInputAudio,
+    List[object],
+]
+
+
+class DataSourceResponsesInputMessagesTemplateTemplateEvalItem(BaseModel):
+    content: DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent
+    """Inputs to the model - can contain template strings."""
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
+
+
+DataSourceResponsesInputMessagesTemplateTemplate: TypeAlias = Union[
+    DataSourceResponsesInputMessagesTemplateTemplateChatMessage,
+    DataSourceResponsesInputMessagesTemplateTemplateEvalItem,
+]
+
+
+class DataSourceResponsesInputMessagesTemplate(BaseModel):
+    template: List[DataSourceResponsesInputMessagesTemplateTemplate]
+    """A list of chat messages forming the prompt or context.
+
+    May include variable references to the `item` namespace, ie {{item.name}}.
+    """
+
+    type: Literal["template"]
+    """The type of input messages. Always `template`."""
+
+
+class DataSourceResponsesInputMessagesItemReference(BaseModel):
+    item_reference: str
+    """A reference to a variable in the `item` namespace. Ie, "item.name" """
+
+    type: Literal["item_reference"]
+    """The type of input messages. Always `item_reference`."""
+
+
+DataSourceResponsesInputMessages: TypeAlias = Annotated[
+    Union[DataSourceResponsesInputMessagesTemplate, DataSourceResponsesInputMessagesItemReference],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class DataSourceResponsesSamplingParamsText(BaseModel):
+    format: Optional[ResponseFormatTextConfig] = None
+    """An object specifying the format that the model must output.
+
+    Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+    ensures the model will match your supplied JSON schema. Learn more in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    The default format is `{ "type": "text" }` with no additional options.
+
+    **Not recommended for gpt-4o and newer models:**
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+
+class DataSourceResponsesSamplingParams(BaseModel):
+    max_completion_tokens: Optional[int] = None
+    """The maximum number of tokens in the generated output."""
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    seed: Optional[int] = None
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: Optional[float] = None
+    """A higher temperature increases randomness in the outputs."""
+
+    text: Optional[DataSourceResponsesSamplingParamsText] = None
+    """Configuration options for a text response from the model.
+
+    Can be plain text or structured JSON data. Learn more:
+
+    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+    - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+    """
+
+    tools: Optional[List[Tool]] = None
+    """An array of tools the model may call while generating a response.
+
+    You can specify which tool to use by setting the `tool_choice` parameter.
+
+    The two categories of tools you can provide the model are:
+
+    - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+      capabilities, like
+      [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+      [file search](https://platform.openai.com/docs/guides/tools-file-search).
+      Learn more about
+      [built-in tools](https://platform.openai.com/docs/guides/tools).
+    - **Function calls (custom tools)**: Functions that are defined by you, enabling
+      the model to call your own code. Learn more about
+      [function calling](https://platform.openai.com/docs/guides/function-calling).
+    """
+
+    top_p: Optional[float] = None
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class DataSourceResponses(BaseModel):
+    source: DataSourceResponsesSource
+    """Determines what populates the `item` namespace in this run's data source."""
+
+    type: Literal["responses"]
+    """The type of run data source. Always `responses`."""
+
+    input_messages: Optional[DataSourceResponsesInputMessages] = None
+    """Used when sampling from a model.
+
+    Dictates the structure of the messages passed into the model. Can either be a
+    reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
+    with variable references to the `item` namespace.
+    """
+
+    model: Optional[str] = None
+    """The name of the model to use for generating completions (e.g. "o3-mini")."""
+
+    sampling_params: Optional[DataSourceResponsesSamplingParams] = None
+
+
+DataSource: TypeAlias = Annotated[
+    Union[CreateEvalJSONLRunDataSource, CreateEvalCompletionsRunDataSource, DataSourceResponses],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class PerModelUsage(BaseModel):
+    cached_tokens: int
+    """The number of tokens retrieved from cache."""
+
+    completion_tokens: int
+    """The number of completion tokens generated."""
+
+    invocation_count: int
+    """The number of invocations."""
+
+    run_model_name: str = FieldInfo(alias="model_name")
+    """The name of the model."""
+
+    prompt_tokens: int
+    """The number of prompt tokens used."""
+
+    total_tokens: int
+    """The total number of tokens used."""
+
+
+class PerTestingCriteriaResult(BaseModel):
+    failed: int
+    """Number of tests failed for this criteria."""
+
+    passed: int
+    """Number of tests passed for this criteria."""
+
+    testing_criteria: str
+    """A description of the testing criteria."""
+
+
+class ResultCounts(BaseModel):
+    errored: int
+    """Number of output items that resulted in an error."""
+
+    failed: int
+    """Number of output items that failed to pass the evaluation."""
+
+    passed: int
+    """Number of output items that passed the evaluation."""
+
+    total: int
+    """Total number of executed output items."""
+
+
+class RunRetrieveResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation run."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the evaluation run was created."""
+
+    data_source: DataSource
+    """Information about the run's data source."""
+
+    error: EvalAPIError
+    """An object representing an error response from the Eval API."""
+
+    eval_id: str
+    """The identifier of the associated evaluation."""
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    model: str
+    """The model that is evaluated, if applicable."""
+
+    name: str
+    """The name of the evaluation run."""
+
+    object: Literal["eval.run"]
+    """The type of the object. Always "eval.run"."""
+
+    per_model_usage: List[PerModelUsage]
+    """Usage statistics for each model during the evaluation run."""
+
+    per_testing_criteria_results: List[PerTestingCriteriaResult]
+    """Results per testing criteria applied during the evaluation run."""
+
+    report_url: str
+    """The URL to the rendered evaluation run report on the UI dashboard."""
+
+    result_counts: ResultCounts
+    """Counters summarizing the outcomes of the evaluation run."""
+
+    status: str
+    """The status of the evaluation run."""
diff --git a/src/openai/types/evals/runs/__init__.py b/src/openai/types/evals/runs/__init__.py
new file mode 100644
index 0000000000..b77cbb6acd
--- /dev/null
+++ b/src/openai/types/evals/runs/__init__.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .output_item_list_params import OutputItemListParams as OutputItemListParams
+from .output_item_list_response import OutputItemListResponse as OutputItemListResponse
+from .output_item_retrieve_response import OutputItemRetrieveResponse as OutputItemRetrieveResponse
diff --git a/src/openai/types/evals/runs/output_item_list_params.py b/src/openai/types/evals/runs/output_item_list_params.py
new file mode 100644
index 0000000000..073bfc69a7
--- /dev/null
+++ b/src/openai/types/evals/runs/output_item_list_params.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["OutputItemListParams"]
+
+
+class OutputItemListParams(TypedDict, total=False):
+    eval_id: Required[str]
+
+    after: str
+    """Identifier for the last output item from the previous pagination request."""
+
+    limit: int
+    """Number of output items to retrieve."""
+
+    order: Literal["asc", "desc"]
+    """Sort order for output items by timestamp.
+
+    Use `asc` for ascending order or `desc` for descending order. Defaults to `asc`.
+    """
+
+    status: Literal["fail", "pass"]
+    """Filter output items by status.
+
+    Use `failed` to filter by failed output items or `pass` to filter by passed
+    output items.
+    """
diff --git a/src/openai/types/evals/runs/output_item_list_response.py b/src/openai/types/evals/runs/output_item_list_response.py
new file mode 100644
index 0000000000..e88c21766f
--- /dev/null
+++ b/src/openai/types/evals/runs/output_item_list_response.py
@@ -0,0 +1,134 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import TYPE_CHECKING, Dict, List, Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from ...._models import BaseModel
+from ..eval_api_error import EvalAPIError
+
+__all__ = ["OutputItemListResponse", "Result", "Sample", "SampleInput", "SampleOutput", "SampleUsage"]
+
+
+class Result(BaseModel):
+    name: str
+    """The name of the grader."""
+
+    passed: bool
+    """Whether the grader considered the output a pass."""
+
+    score: float
+    """The numeric score produced by the grader."""
+
+    sample: Optional[Dict[str, object]] = None
+    """Optional sample or intermediate data produced by the grader."""
+
+    type: Optional[str] = None
+    """The grader type (for example, "string-check-grader")."""
+
+    if TYPE_CHECKING:
+        # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a
+        # value to this field, so for compatibility we avoid doing it at runtime.
+        __pydantic_extra__: Dict[str, object] = FieldInfo(init=False)  # pyright: ignore[reportIncompatibleVariableOverride]
+
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+    else:
+        __pydantic_extra__: Dict[str, object]
+
+
+class SampleInput(BaseModel):
+    content: str
+    """The content of the message."""
+
+    role: str
+    """The role of the message sender (e.g., system, user, developer)."""
+
+
+class SampleOutput(BaseModel):
+    content: Optional[str] = None
+    """The content of the message."""
+
+    role: Optional[str] = None
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class SampleUsage(BaseModel):
+    cached_tokens: int
+    """The number of tokens retrieved from cache."""
+
+    completion_tokens: int
+    """The number of completion tokens generated."""
+
+    prompt_tokens: int
+    """The number of prompt tokens used."""
+
+    total_tokens: int
+    """The total number of tokens used."""
+
+
+class Sample(BaseModel):
+    error: EvalAPIError
+    """An object representing an error response from the Eval API."""
+
+    finish_reason: str
+    """The reason why the sample generation was finished."""
+
+    input: List[SampleInput]
+    """An array of input messages."""
+
+    max_completion_tokens: int
+    """The maximum number of tokens allowed for completion."""
+
+    model: str
+    """The model used for generating the sample."""
+
+    output: List[SampleOutput]
+    """An array of output messages."""
+
+    seed: int
+    """The seed used for generating the sample."""
+
+    temperature: float
+    """The sampling temperature used."""
+
+    top_p: float
+    """The top_p value used for sampling."""
+
+    usage: SampleUsage
+    """Token usage details for the sample."""
+
+
+class OutputItemListResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation run output item."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the evaluation run was created."""
+
+    datasource_item: Dict[str, object]
+    """Details of the input data source item."""
+
+    datasource_item_id: int
+    """The identifier for the data source item."""
+
+    eval_id: str
+    """The identifier of the evaluation group."""
+
+    object: Literal["eval.run.output_item"]
+    """The type of the object. Always "eval.run.output_item"."""
+
+    results: List[Result]
+    """A list of grader results for this output item."""
+
+    run_id: str
+    """The identifier of the evaluation run associated with this output item."""
+
+    sample: Sample
+    """A sample containing the input and output of the evaluation run."""
+
+    status: str
+    """The status of the evaluation run."""
diff --git a/src/openai/types/evals/runs/output_item_retrieve_response.py b/src/openai/types/evals/runs/output_item_retrieve_response.py
new file mode 100644
index 0000000000..c728629b41
--- /dev/null
+++ b/src/openai/types/evals/runs/output_item_retrieve_response.py
@@ -0,0 +1,134 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import TYPE_CHECKING, Dict, List, Optional
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from ...._models import BaseModel
+from ..eval_api_error import EvalAPIError
+
+__all__ = ["OutputItemRetrieveResponse", "Result", "Sample", "SampleInput", "SampleOutput", "SampleUsage"]
+
+
+class Result(BaseModel):
+    name: str
+    """The name of the grader."""
+
+    passed: bool
+    """Whether the grader considered the output a pass."""
+
+    score: float
+    """The numeric score produced by the grader."""
+
+    sample: Optional[Dict[str, object]] = None
+    """Optional sample or intermediate data produced by the grader."""
+
+    type: Optional[str] = None
+    """The grader type (for example, "string-check-grader")."""
+
+    if TYPE_CHECKING:
+        # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a
+        # value to this field, so for compatibility we avoid doing it at runtime.
+        __pydantic_extra__: Dict[str, object] = FieldInfo(init=False)  # pyright: ignore[reportIncompatibleVariableOverride]
+
+        # Stub to indicate that arbitrary properties are accepted.
+        # To access properties that are not valid identifiers you can use `getattr`, e.g.
+        # `getattr(obj, '$type')`
+        def __getattr__(self, attr: str) -> object: ...
+    else:
+        __pydantic_extra__: Dict[str, object]
+
+
+class SampleInput(BaseModel):
+    content: str
+    """The content of the message."""
+
+    role: str
+    """The role of the message sender (e.g., system, user, developer)."""
+
+
+class SampleOutput(BaseModel):
+    content: Optional[str] = None
+    """The content of the message."""
+
+    role: Optional[str] = None
+    """The role of the message (e.g. "system", "assistant", "user")."""
+
+
+class SampleUsage(BaseModel):
+    cached_tokens: int
+    """The number of tokens retrieved from cache."""
+
+    completion_tokens: int
+    """The number of completion tokens generated."""
+
+    prompt_tokens: int
+    """The number of prompt tokens used."""
+
+    total_tokens: int
+    """The total number of tokens used."""
+
+
+class Sample(BaseModel):
+    error: EvalAPIError
+    """An object representing an error response from the Eval API."""
+
+    finish_reason: str
+    """The reason why the sample generation was finished."""
+
+    input: List[SampleInput]
+    """An array of input messages."""
+
+    max_completion_tokens: int
+    """The maximum number of tokens allowed for completion."""
+
+    model: str
+    """The model used for generating the sample."""
+
+    output: List[SampleOutput]
+    """An array of output messages."""
+
+    seed: int
+    """The seed used for generating the sample."""
+
+    temperature: float
+    """The sampling temperature used."""
+
+    top_p: float
+    """The top_p value used for sampling."""
+
+    usage: SampleUsage
+    """Token usage details for the sample."""
+
+
+class OutputItemRetrieveResponse(BaseModel):
+    id: str
+    """Unique identifier for the evaluation run output item."""
+
+    created_at: int
+    """Unix timestamp (in seconds) when the evaluation run was created."""
+
+    datasource_item: Dict[str, object]
+    """Details of the input data source item."""
+
+    datasource_item_id: int
+    """The identifier for the data source item."""
+
+    eval_id: str
+    """The identifier of the evaluation group."""
+
+    object: Literal["eval.run.output_item"]
+    """The type of the object. Always "eval.run.output_item"."""
+
+    results: List[Result]
+    """A list of grader results for this output item."""
+
+    run_id: str
+    """The identifier of the evaluation run associated with this output item."""
+
+    sample: Sample
+    """A sample containing the input and output of the evaluation run."""
+
+    status: str
+    """The status of the evaluation run."""
diff --git a/src/openai/types/file_create_params.py b/src/openai/types/file_create_params.py
index 728dfd350f..f4583b16a3 100644
--- a/src/openai/types/file_create_params.py
+++ b/src/openai/types/file_create_params.py
@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-from typing_extensions import Required, TypedDict
+from typing_extensions import Literal, Required, TypedDict
 
 from .._types import FileTypes
 from .file_purpose import FilePurpose
 
-__all__ = ["FileCreateParams"]
+__all__ = ["FileCreateParams", "ExpiresAfter"]
 
 
 class FileCreateParams(TypedDict, total=False):
@@ -22,3 +22,24 @@ class FileCreateParams(TypedDict, total=False):
     fine-tuning - `user_data`: Flexible file type for any purpose - `evals`: Used
     for eval data sets
     """
+
+    expires_after: ExpiresAfter
+    """The expiration policy for a file.
+
+    By default, files with `purpose=batch` expire after 30 days and all other files
+    are persisted until they are manually deleted.
+    """
+
+
+class ExpiresAfter(TypedDict, total=False):
+    anchor: Required[Literal["created_at"]]
+    """Anchor timestamp after which the expiration policy applies.
+
+    Supported anchors: `created_at`.
+    """
+
+    seconds: Required[int]
+    """The number of seconds after the anchor time that the file will expire.
+
+    Must be between 3600 (1 hour) and 2592000 (30 days).
+    """
diff --git a/src/openai/types/file_object.py b/src/openai/types/file_object.py
index 1d65e6987d..883c2de019 100644
--- a/src/openai/types/file_object.py
+++ b/src/openai/types/file_object.py
@@ -25,12 +25,19 @@ class FileObject(BaseModel):
     """The object type, which is always `file`."""
 
     purpose: Literal[
-        "assistants", "assistants_output", "batch", "batch_output", "fine-tune", "fine-tune-results", "vision"
+        "assistants",
+        "assistants_output",
+        "batch",
+        "batch_output",
+        "fine-tune",
+        "fine-tune-results",
+        "vision",
+        "user_data",
     ]
     """The intended purpose of the file.
 
     Supported values are `assistants`, `assistants_output`, `batch`, `batch_output`,
-    `fine-tune`, `fine-tune-results` and `vision`.
+    `fine-tune`, `fine-tune-results`, `vision`, and `user_data`.
     """
 
     status: Literal["uploaded", "processed", "error"]
diff --git a/src/openai/types/fine_tuning/__init__.py b/src/openai/types/fine_tuning/__init__.py
index 92b81329b1..cc664eacea 100644
--- a/src/openai/types/fine_tuning/__init__.py
+++ b/src/openai/types/fine_tuning/__init__.py
@@ -2,13 +2,25 @@
 
 from __future__ import annotations
 
+from .dpo_method import DpoMethod as DpoMethod
 from .fine_tuning_job import FineTuningJob as FineTuningJob
 from .job_list_params import JobListParams as JobListParams
+from .dpo_method_param import DpoMethodParam as DpoMethodParam
 from .job_create_params import JobCreateParams as JobCreateParams
+from .supervised_method import SupervisedMethod as SupervisedMethod
+from .dpo_hyperparameters import DpoHyperparameters as DpoHyperparameters
+from .reinforcement_method import ReinforcementMethod as ReinforcementMethod
 from .fine_tuning_job_event import FineTuningJobEvent as FineTuningJobEvent
 from .job_list_events_params import JobListEventsParams as JobListEventsParams
+from .supervised_method_param import SupervisedMethodParam as SupervisedMethodParam
+from .dpo_hyperparameters_param import DpoHyperparametersParam as DpoHyperparametersParam
+from .reinforcement_method_param import ReinforcementMethodParam as ReinforcementMethodParam
+from .supervised_hyperparameters import SupervisedHyperparameters as SupervisedHyperparameters
 from .fine_tuning_job_integration import FineTuningJobIntegration as FineTuningJobIntegration
+from .reinforcement_hyperparameters import ReinforcementHyperparameters as ReinforcementHyperparameters
+from .supervised_hyperparameters_param import SupervisedHyperparametersParam as SupervisedHyperparametersParam
 from .fine_tuning_job_wandb_integration import FineTuningJobWandbIntegration as FineTuningJobWandbIntegration
+from .reinforcement_hyperparameters_param import ReinforcementHyperparametersParam as ReinforcementHyperparametersParam
 from .fine_tuning_job_wandb_integration_object import (
     FineTuningJobWandbIntegrationObject as FineTuningJobWandbIntegrationObject,
 )
diff --git a/src/openai/types/fine_tuning/alpha/__init__.py b/src/openai/types/fine_tuning/alpha/__init__.py
new file mode 100644
index 0000000000..6394961b0b
--- /dev/null
+++ b/src/openai/types/fine_tuning/alpha/__init__.py
@@ -0,0 +1,8 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .grader_run_params import GraderRunParams as GraderRunParams
+from .grader_run_response import GraderRunResponse as GraderRunResponse
+from .grader_validate_params import GraderValidateParams as GraderValidateParams
+from .grader_validate_response import GraderValidateResponse as GraderValidateResponse
diff --git a/src/openai/types/fine_tuning/alpha/grader_run_params.py b/src/openai/types/fine_tuning/alpha/grader_run_params.py
new file mode 100644
index 0000000000..646407fe09
--- /dev/null
+++ b/src/openai/types/fine_tuning/alpha/grader_run_params.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from ...graders.multi_grader_param import MultiGraderParam
+from ...graders.python_grader_param import PythonGraderParam
+from ...graders.score_model_grader_param import ScoreModelGraderParam
+from ...graders.string_check_grader_param import StringCheckGraderParam
+from ...graders.text_similarity_grader_param import TextSimilarityGraderParam
+
+__all__ = ["GraderRunParams", "Grader"]
+
+
+class GraderRunParams(TypedDict, total=False):
+    grader: Required[Grader]
+    """The grader used for the fine-tuning job."""
+
+    model_sample: Required[str]
+    """The model sample to be evaluated.
+
+    This value will be used to populate the `sample` namespace. See
+    [the guide](https://platform.openai.com/docs/guides/graders) for more details.
+    The `output_json` variable will be populated if the model sample is a valid JSON
+    string.
+    """
+
+    item: object
+    """The dataset item provided to the grader.
+
+    This will be used to populate the `item` namespace. See
+    [the guide](https://platform.openai.com/docs/guides/graders) for more details.
+    """
+
+
+Grader: TypeAlias = Union[
+    StringCheckGraderParam, TextSimilarityGraderParam, PythonGraderParam, ScoreModelGraderParam, MultiGraderParam
+]
diff --git a/src/openai/types/fine_tuning/alpha/grader_run_response.py b/src/openai/types/fine_tuning/alpha/grader_run_response.py
new file mode 100644
index 0000000000..8ef046d133
--- /dev/null
+++ b/src/openai/types/fine_tuning/alpha/grader_run_response.py
@@ -0,0 +1,67 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from pydantic import Field as FieldInfo
+
+from ...._models import BaseModel
+
+__all__ = ["GraderRunResponse", "Metadata", "MetadataErrors"]
+
+
+class MetadataErrors(BaseModel):
+    formula_parse_error: bool
+
+    invalid_variable_error: bool
+
+    api_model_grader_parse_error: bool = FieldInfo(alias="model_grader_parse_error")
+
+    api_model_grader_refusal_error: bool = FieldInfo(alias="model_grader_refusal_error")
+
+    api_model_grader_server_error: bool = FieldInfo(alias="model_grader_server_error")
+
+    api_model_grader_server_error_details: Optional[str] = FieldInfo(
+        alias="model_grader_server_error_details", default=None
+    )
+
+    other_error: bool
+
+    python_grader_runtime_error: bool
+
+    python_grader_runtime_error_details: Optional[str] = None
+
+    python_grader_server_error: bool
+
+    python_grader_server_error_type: Optional[str] = None
+
+    sample_parse_error: bool
+
+    truncated_observation_error: bool
+
+    unresponsive_reward_error: bool
+
+
+class Metadata(BaseModel):
+    errors: MetadataErrors
+
+    execution_time: float
+
+    name: str
+
+    sampled_model_name: Optional[str] = None
+
+    scores: Dict[str, object]
+
+    token_usage: Optional[int] = None
+
+    type: str
+
+
+class GraderRunResponse(BaseModel):
+    metadata: Metadata
+
+    api_model_grader_token_usage_per_model: Dict[str, object] = FieldInfo(alias="model_grader_token_usage_per_model")
+
+    reward: float
+
+    sub_rewards: Dict[str, object]
diff --git a/src/openai/types/fine_tuning/alpha/grader_validate_params.py b/src/openai/types/fine_tuning/alpha/grader_validate_params.py
new file mode 100644
index 0000000000..fe9eb44e32
--- /dev/null
+++ b/src/openai/types/fine_tuning/alpha/grader_validate_params.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from ...graders.multi_grader_param import MultiGraderParam
+from ...graders.python_grader_param import PythonGraderParam
+from ...graders.score_model_grader_param import ScoreModelGraderParam
+from ...graders.string_check_grader_param import StringCheckGraderParam
+from ...graders.text_similarity_grader_param import TextSimilarityGraderParam
+
+__all__ = ["GraderValidateParams", "Grader"]
+
+
+class GraderValidateParams(TypedDict, total=False):
+    grader: Required[Grader]
+    """The grader used for the fine-tuning job."""
+
+
+Grader: TypeAlias = Union[
+    StringCheckGraderParam, TextSimilarityGraderParam, PythonGraderParam, ScoreModelGraderParam, MultiGraderParam
+]
diff --git a/src/openai/types/fine_tuning/alpha/grader_validate_response.py b/src/openai/types/fine_tuning/alpha/grader_validate_response.py
new file mode 100644
index 0000000000..b373292d80
--- /dev/null
+++ b/src/openai/types/fine_tuning/alpha/grader_validate_response.py
@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import TypeAlias
+
+from ...._models import BaseModel
+from ...graders.multi_grader import MultiGrader
+from ...graders.python_grader import PythonGrader
+from ...graders.score_model_grader import ScoreModelGrader
+from ...graders.string_check_grader import StringCheckGrader
+from ...graders.text_similarity_grader import TextSimilarityGrader
+
+__all__ = ["GraderValidateResponse", "Grader"]
+
+Grader: TypeAlias = Union[StringCheckGrader, TextSimilarityGrader, PythonGrader, ScoreModelGrader, MultiGrader]
+
+
+class GraderValidateResponse(BaseModel):
+    grader: Optional[Grader] = None
+    """The grader used for the fine-tuning job."""
diff --git a/src/openai/types/fine_tuning/checkpoints/__init__.py b/src/openai/types/fine_tuning/checkpoints/__init__.py
new file mode 100644
index 0000000000..2947b33145
--- /dev/null
+++ b/src/openai/types/fine_tuning/checkpoints/__init__.py
@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .permission_create_params import PermissionCreateParams as PermissionCreateParams
+from .permission_create_response import PermissionCreateResponse as PermissionCreateResponse
+from .permission_delete_response import PermissionDeleteResponse as PermissionDeleteResponse
+from .permission_retrieve_params import PermissionRetrieveParams as PermissionRetrieveParams
+from .permission_retrieve_response import PermissionRetrieveResponse as PermissionRetrieveResponse
diff --git a/src/openai/types/fine_tuning/checkpoints/permission_create_params.py b/src/openai/types/fine_tuning/checkpoints/permission_create_params.py
new file mode 100644
index 0000000000..e7cf4e4ee4
--- /dev/null
+++ b/src/openai/types/fine_tuning/checkpoints/permission_create_params.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from ...._types import SequenceNotStr
+
+__all__ = ["PermissionCreateParams"]
+
+
+class PermissionCreateParams(TypedDict, total=False):
+    project_ids: Required[SequenceNotStr[str]]
+    """The project identifiers to grant access to."""
diff --git a/src/openai/types/fine_tuning/checkpoints/permission_create_response.py b/src/openai/types/fine_tuning/checkpoints/permission_create_response.py
new file mode 100644
index 0000000000..9bc14c00cc
--- /dev/null
+++ b/src/openai/types/fine_tuning/checkpoints/permission_create_response.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["PermissionCreateResponse"]
+
+
+class PermissionCreateResponse(BaseModel):
+    id: str
+    """The permission identifier, which can be referenced in the API endpoints."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the permission was created."""
+
+    object: Literal["checkpoint.permission"]
+    """The object type, which is always "checkpoint.permission"."""
+
+    project_id: str
+    """The project identifier that the permission is for."""
diff --git a/src/openai/types/fine_tuning/checkpoints/permission_delete_response.py b/src/openai/types/fine_tuning/checkpoints/permission_delete_response.py
new file mode 100644
index 0000000000..1a92d912fa
--- /dev/null
+++ b/src/openai/types/fine_tuning/checkpoints/permission_delete_response.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["PermissionDeleteResponse"]
+
+
+class PermissionDeleteResponse(BaseModel):
+    id: str
+    """The ID of the fine-tuned model checkpoint permission that was deleted."""
+
+    deleted: bool
+    """Whether the fine-tuned model checkpoint permission was successfully deleted."""
+
+    object: Literal["checkpoint.permission"]
+    """The object type, which is always "checkpoint.permission"."""
diff --git a/src/openai/types/fine_tuning/checkpoints/permission_retrieve_params.py b/src/openai/types/fine_tuning/checkpoints/permission_retrieve_params.py
new file mode 100644
index 0000000000..6e66a867ca
--- /dev/null
+++ b/src/openai/types/fine_tuning/checkpoints/permission_retrieve_params.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["PermissionRetrieveParams"]
+
+
+class PermissionRetrieveParams(TypedDict, total=False):
+    after: str
+    """Identifier for the last permission ID from the previous pagination request."""
+
+    limit: int
+    """Number of permissions to retrieve."""
+
+    order: Literal["ascending", "descending"]
+    """The order in which to retrieve permissions."""
+
+    project_id: str
+    """The ID of the project to get permissions for."""
diff --git a/src/openai/types/fine_tuning/checkpoints/permission_retrieve_response.py b/src/openai/types/fine_tuning/checkpoints/permission_retrieve_response.py
new file mode 100644
index 0000000000..14c73b55d0
--- /dev/null
+++ b/src/openai/types/fine_tuning/checkpoints/permission_retrieve_response.py
@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["PermissionRetrieveResponse", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The permission identifier, which can be referenced in the API endpoints."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the permission was created."""
+
+    object: Literal["checkpoint.permission"]
+    """The object type, which is always "checkpoint.permission"."""
+
+    project_id: str
+    """The project identifier that the permission is for."""
+
+
+class PermissionRetrieveResponse(BaseModel):
+    data: List[Data]
+
+    has_more: bool
+
+    object: Literal["list"]
+
+    first_id: Optional[str] = None
+
+    last_id: Optional[str] = None
diff --git a/src/openai/types/fine_tuning/dpo_hyperparameters.py b/src/openai/types/fine_tuning/dpo_hyperparameters.py
new file mode 100644
index 0000000000..b0b3f0581b
--- /dev/null
+++ b/src/openai/types/fine_tuning/dpo_hyperparameters.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["DpoHyperparameters"]
+
+
+class DpoHyperparameters(BaseModel):
+    batch_size: Union[Literal["auto"], int, None] = None
+    """Number of examples in each batch.
+
+    A larger batch size means that model parameters are updated less frequently, but
+    with lower variance.
+    """
+
+    beta: Union[Literal["auto"], float, None] = None
+    """The beta value for the DPO method.
+
+    A higher beta value will increase the weight of the penalty between the policy
+    and reference model.
+    """
+
+    learning_rate_multiplier: Union[Literal["auto"], float, None] = None
+    """Scaling factor for the learning rate.
+
+    A smaller learning rate may be useful to avoid overfitting.
+    """
+
+    n_epochs: Union[Literal["auto"], int, None] = None
+    """The number of epochs to train the model for.
+
+    An epoch refers to one full cycle through the training dataset.
+    """
diff --git a/src/openai/types/fine_tuning/dpo_hyperparameters_param.py b/src/openai/types/fine_tuning/dpo_hyperparameters_param.py
new file mode 100644
index 0000000000..87c6ee80a5
--- /dev/null
+++ b/src/openai/types/fine_tuning/dpo_hyperparameters_param.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["DpoHyperparametersParam"]
+
+
+class DpoHyperparametersParam(TypedDict, total=False):
+    batch_size: Union[Literal["auto"], int]
+    """Number of examples in each batch.
+
+    A larger batch size means that model parameters are updated less frequently, but
+    with lower variance.
+    """
+
+    beta: Union[Literal["auto"], float]
+    """The beta value for the DPO method.
+
+    A higher beta value will increase the weight of the penalty between the policy
+    and reference model.
+    """
+
+    learning_rate_multiplier: Union[Literal["auto"], float]
+    """Scaling factor for the learning rate.
+
+    A smaller learning rate may be useful to avoid overfitting.
+    """
+
+    n_epochs: Union[Literal["auto"], int]
+    """The number of epochs to train the model for.
+
+    An epoch refers to one full cycle through the training dataset.
+    """
diff --git a/src/openai/types/fine_tuning/dpo_method.py b/src/openai/types/fine_tuning/dpo_method.py
new file mode 100644
index 0000000000..3e20f360dd
--- /dev/null
+++ b/src/openai/types/fine_tuning/dpo_method.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .dpo_hyperparameters import DpoHyperparameters
+
+__all__ = ["DpoMethod"]
+
+
+class DpoMethod(BaseModel):
+    hyperparameters: Optional[DpoHyperparameters] = None
+    """The hyperparameters used for the DPO fine-tuning job."""
diff --git a/src/openai/types/fine_tuning/dpo_method_param.py b/src/openai/types/fine_tuning/dpo_method_param.py
new file mode 100644
index 0000000000..ce6b6510f6
--- /dev/null
+++ b/src/openai/types/fine_tuning/dpo_method_param.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+from .dpo_hyperparameters_param import DpoHyperparametersParam
+
+__all__ = ["DpoMethodParam"]
+
+
+class DpoMethodParam(TypedDict, total=False):
+    hyperparameters: DpoHyperparametersParam
+    """The hyperparameters used for the DPO fine-tuning job."""
diff --git a/src/openai/types/fine_tuning/fine_tuning_job.py b/src/openai/types/fine_tuning/fine_tuning_job.py
index c7fff2b7b1..f626fbba64 100644
--- a/src/openai/types/fine_tuning/fine_tuning_job.py
+++ b/src/openai/types/fine_tuning/fine_tuning_job.py
@@ -4,19 +4,13 @@
 from typing_extensions import Literal
 
 from ..._models import BaseModel
+from .dpo_method import DpoMethod
 from ..shared.metadata import Metadata
+from .supervised_method import SupervisedMethod
+from .reinforcement_method import ReinforcementMethod
 from .fine_tuning_job_wandb_integration_object import FineTuningJobWandbIntegrationObject
 
-__all__ = [
-    "FineTuningJob",
-    "Error",
-    "Hyperparameters",
-    "Method",
-    "MethodDpo",
-    "MethodDpoHyperparameters",
-    "MethodSupervised",
-    "MethodSupervisedHyperparameters",
-]
+__all__ = ["FineTuningJob", "Error", "Hyperparameters", "Method"]
 
 
 class Error(BaseModel):
@@ -54,74 +48,18 @@ class Hyperparameters(BaseModel):
     """
 
 
-class MethodDpoHyperparameters(BaseModel):
-    batch_size: Union[Literal["auto"], int, None] = None
-    """Number of examples in each batch.
-
-    A larger batch size means that model parameters are updated less frequently, but
-    with lower variance.
-    """
-
-    beta: Union[Literal["auto"], float, None] = None
-    """The beta value for the DPO method.
-
-    A higher beta value will increase the weight of the penalty between the policy
-    and reference model.
-    """
-
-    learning_rate_multiplier: Union[Literal["auto"], float, None] = None
-    """Scaling factor for the learning rate.
-
-    A smaller learning rate may be useful to avoid overfitting.
-    """
-
-    n_epochs: Union[Literal["auto"], int, None] = None
-    """The number of epochs to train the model for.
-
-    An epoch refers to one full cycle through the training dataset.
-    """
-
-
-class MethodDpo(BaseModel):
-    hyperparameters: Optional[MethodDpoHyperparameters] = None
-    """The hyperparameters used for the fine-tuning job."""
-
-
-class MethodSupervisedHyperparameters(BaseModel):
-    batch_size: Union[Literal["auto"], int, None] = None
-    """Number of examples in each batch.
-
-    A larger batch size means that model parameters are updated less frequently, but
-    with lower variance.
-    """
-
-    learning_rate_multiplier: Union[Literal["auto"], float, None] = None
-    """Scaling factor for the learning rate.
-
-    A smaller learning rate may be useful to avoid overfitting.
-    """
-
-    n_epochs: Union[Literal["auto"], int, None] = None
-    """The number of epochs to train the model for.
-
-    An epoch refers to one full cycle through the training dataset.
-    """
-
-
-class MethodSupervised(BaseModel):
-    hyperparameters: Optional[MethodSupervisedHyperparameters] = None
-    """The hyperparameters used for the fine-tuning job."""
-
-
 class Method(BaseModel):
-    dpo: Optional[MethodDpo] = None
+    type: Literal["supervised", "dpo", "reinforcement"]
+    """The type of method. Is either `supervised`, `dpo`, or `reinforcement`."""
+
+    dpo: Optional[DpoMethod] = None
     """Configuration for the DPO fine-tuning method."""
 
-    supervised: Optional[MethodSupervised] = None
-    """Configuration for the supervised fine-tuning method."""
+    reinforcement: Optional[ReinforcementMethod] = None
+    """Configuration for the reinforcement fine-tuning method."""
 
-    type: Optional[Literal["supervised", "dpo"]] = None
-    """The type of method. Is either `supervised` or `dpo`."""
+    supervised: Optional[SupervisedMethod] = None
+    """Configuration for the supervised fine-tuning method."""
 
 
 class FineTuningJob(BaseModel):
diff --git a/src/openai/types/fine_tuning/fine_tuning_job_integration.py b/src/openai/types/fine_tuning/fine_tuning_job_integration.py
index 9a66aa4f17..2af73fbffb 100644
--- a/src/openai/types/fine_tuning/fine_tuning_job_integration.py
+++ b/src/openai/types/fine_tuning/fine_tuning_job_integration.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from .fine_tuning_job_wandb_integration_object import FineTuningJobWandbIntegrationObject
 
 FineTuningJobIntegration = FineTuningJobWandbIntegrationObject
diff --git a/src/openai/types/fine_tuning/job_create_params.py b/src/openai/types/fine_tuning/job_create_params.py
index f4cf980b08..351d4e0e1b 100644
--- a/src/openai/types/fine_tuning/job_create_params.py
+++ b/src/openai/types/fine_tuning/job_create_params.py
@@ -2,22 +2,16 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable, Optional
+from typing import Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypedDict
 
+from ..._types import SequenceNotStr
+from .dpo_method_param import DpoMethodParam
 from ..shared_params.metadata import Metadata
+from .supervised_method_param import SupervisedMethodParam
+from .reinforcement_method_param import ReinforcementMethodParam
 
-__all__ = [
-    "JobCreateParams",
-    "Hyperparameters",
-    "Integration",
-    "IntegrationWandb",
-    "Method",
-    "MethodDpo",
-    "MethodDpoHyperparameters",
-    "MethodSupervised",
-    "MethodSupervisedHyperparameters",
-]
+__all__ = ["JobCreateParams", "Hyperparameters", "Integration", "IntegrationWandb", "Method"]
 
 
 class JobCreateParams(TypedDict, total=False):
@@ -44,7 +38,8 @@ class JobCreateParams(TypedDict, total=False):
     [preference](https://platform.openai.com/docs/api-reference/fine-tuning/preference-input)
     format.
 
-    See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
+    See the
+    [fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
     for more details.
     """
 
@@ -98,7 +93,8 @@ class JobCreateParams(TypedDict, total=False):
     Your dataset must be formatted as a JSONL file. You must upload your file with
     the purpose `fine-tune`.
 
-    See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
+    See the
+    [fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
     for more details.
     """
 
@@ -142,7 +138,7 @@ class IntegrationWandb(TypedDict, total=False):
     If not set, we will use the Job ID as the name.
     """
 
-    tags: List[str]
+    tags: SequenceNotStr[str]
     """A list of tags to be attached to the newly created run.
 
     These tags are passed through directly to WandB. Some default tags are generated
@@ -166,71 +162,15 @@ class Integration(TypedDict, total=False):
     """
 
 
-class MethodDpoHyperparameters(TypedDict, total=False):
-    batch_size: Union[Literal["auto"], int]
-    """Number of examples in each batch.
-
-    A larger batch size means that model parameters are updated less frequently, but
-    with lower variance.
-    """
-
-    beta: Union[Literal["auto"], float]
-    """The beta value for the DPO method.
-
-    A higher beta value will increase the weight of the penalty between the policy
-    and reference model.
-    """
-
-    learning_rate_multiplier: Union[Literal["auto"], float]
-    """Scaling factor for the learning rate.
-
-    A smaller learning rate may be useful to avoid overfitting.
-    """
-
-    n_epochs: Union[Literal["auto"], int]
-    """The number of epochs to train the model for.
-
-    An epoch refers to one full cycle through the training dataset.
-    """
-
-
-class MethodDpo(TypedDict, total=False):
-    hyperparameters: MethodDpoHyperparameters
-    """The hyperparameters used for the fine-tuning job."""
-
-
-class MethodSupervisedHyperparameters(TypedDict, total=False):
-    batch_size: Union[Literal["auto"], int]
-    """Number of examples in each batch.
-
-    A larger batch size means that model parameters are updated less frequently, but
-    with lower variance.
-    """
-
-    learning_rate_multiplier: Union[Literal["auto"], float]
-    """Scaling factor for the learning rate.
-
-    A smaller learning rate may be useful to avoid overfitting.
-    """
-
-    n_epochs: Union[Literal["auto"], int]
-    """The number of epochs to train the model for.
-
-    An epoch refers to one full cycle through the training dataset.
-    """
-
-
-class MethodSupervised(TypedDict, total=False):
-    hyperparameters: MethodSupervisedHyperparameters
-    """The hyperparameters used for the fine-tuning job."""
-
-
 class Method(TypedDict, total=False):
-    dpo: MethodDpo
+    type: Required[Literal["supervised", "dpo", "reinforcement"]]
+    """The type of method. Is either `supervised`, `dpo`, or `reinforcement`."""
+
+    dpo: DpoMethodParam
     """Configuration for the DPO fine-tuning method."""
 
-    supervised: MethodSupervised
-    """Configuration for the supervised fine-tuning method."""
+    reinforcement: ReinforcementMethodParam
+    """Configuration for the reinforcement fine-tuning method."""
 
-    type: Literal["supervised", "dpo"]
-    """The type of method. Is either `supervised` or `dpo`."""
+    supervised: SupervisedMethodParam
+    """Configuration for the supervised fine-tuning method."""
diff --git a/src/openai/types/fine_tuning/reinforcement_hyperparameters.py b/src/openai/types/fine_tuning/reinforcement_hyperparameters.py
new file mode 100644
index 0000000000..7c1762d38c
--- /dev/null
+++ b/src/openai/types/fine_tuning/reinforcement_hyperparameters.py
@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ReinforcementHyperparameters"]
+
+
+class ReinforcementHyperparameters(BaseModel):
+    batch_size: Union[Literal["auto"], int, None] = None
+    """Number of examples in each batch.
+
+    A larger batch size means that model parameters are updated less frequently, but
+    with lower variance.
+    """
+
+    compute_multiplier: Union[Literal["auto"], float, None] = None
+    """
+    Multiplier on amount of compute used for exploring search space during training.
+    """
+
+    eval_interval: Union[Literal["auto"], int, None] = None
+    """The number of training steps between evaluation runs."""
+
+    eval_samples: Union[Literal["auto"], int, None] = None
+    """Number of evaluation samples to generate per training step."""
+
+    learning_rate_multiplier: Union[Literal["auto"], float, None] = None
+    """Scaling factor for the learning rate.
+
+    A smaller learning rate may be useful to avoid overfitting.
+    """
+
+    n_epochs: Union[Literal["auto"], int, None] = None
+    """The number of epochs to train the model for.
+
+    An epoch refers to one full cycle through the training dataset.
+    """
+
+    reasoning_effort: Optional[Literal["default", "low", "medium", "high"]] = None
+    """Level of reasoning effort."""
diff --git a/src/openai/types/fine_tuning/reinforcement_hyperparameters_param.py b/src/openai/types/fine_tuning/reinforcement_hyperparameters_param.py
new file mode 100644
index 0000000000..0cc12fcb17
--- /dev/null
+++ b/src/openai/types/fine_tuning/reinforcement_hyperparameters_param.py
@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["ReinforcementHyperparametersParam"]
+
+
+class ReinforcementHyperparametersParam(TypedDict, total=False):
+    batch_size: Union[Literal["auto"], int]
+    """Number of examples in each batch.
+
+    A larger batch size means that model parameters are updated less frequently, but
+    with lower variance.
+    """
+
+    compute_multiplier: Union[Literal["auto"], float]
+    """
+    Multiplier on amount of compute used for exploring search space during training.
+    """
+
+    eval_interval: Union[Literal["auto"], int]
+    """The number of training steps between evaluation runs."""
+
+    eval_samples: Union[Literal["auto"], int]
+    """Number of evaluation samples to generate per training step."""
+
+    learning_rate_multiplier: Union[Literal["auto"], float]
+    """Scaling factor for the learning rate.
+
+    A smaller learning rate may be useful to avoid overfitting.
+    """
+
+    n_epochs: Union[Literal["auto"], int]
+    """The number of epochs to train the model for.
+
+    An epoch refers to one full cycle through the training dataset.
+    """
+
+    reasoning_effort: Literal["default", "low", "medium", "high"]
+    """Level of reasoning effort."""
diff --git a/src/openai/types/fine_tuning/reinforcement_method.py b/src/openai/types/fine_tuning/reinforcement_method.py
new file mode 100644
index 0000000000..9b65c41033
--- /dev/null
+++ b/src/openai/types/fine_tuning/reinforcement_method.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import TypeAlias
+
+from ..._models import BaseModel
+from ..graders.multi_grader import MultiGrader
+from ..graders.python_grader import PythonGrader
+from ..graders.score_model_grader import ScoreModelGrader
+from ..graders.string_check_grader import StringCheckGrader
+from .reinforcement_hyperparameters import ReinforcementHyperparameters
+from ..graders.text_similarity_grader import TextSimilarityGrader
+
+__all__ = ["ReinforcementMethod", "Grader"]
+
+Grader: TypeAlias = Union[StringCheckGrader, TextSimilarityGrader, PythonGrader, ScoreModelGrader, MultiGrader]
+
+
+class ReinforcementMethod(BaseModel):
+    grader: Grader
+    """The grader used for the fine-tuning job."""
+
+    hyperparameters: Optional[ReinforcementHyperparameters] = None
+    """The hyperparameters used for the reinforcement fine-tuning job."""
diff --git a/src/openai/types/fine_tuning/reinforcement_method_param.py b/src/openai/types/fine_tuning/reinforcement_method_param.py
new file mode 100644
index 0000000000..00d5060536
--- /dev/null
+++ b/src/openai/types/fine_tuning/reinforcement_method_param.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from ..graders.multi_grader_param import MultiGraderParam
+from ..graders.python_grader_param import PythonGraderParam
+from ..graders.score_model_grader_param import ScoreModelGraderParam
+from ..graders.string_check_grader_param import StringCheckGraderParam
+from .reinforcement_hyperparameters_param import ReinforcementHyperparametersParam
+from ..graders.text_similarity_grader_param import TextSimilarityGraderParam
+
+__all__ = ["ReinforcementMethodParam", "Grader"]
+
+Grader: TypeAlias = Union[
+    StringCheckGraderParam, TextSimilarityGraderParam, PythonGraderParam, ScoreModelGraderParam, MultiGraderParam
+]
+
+
+class ReinforcementMethodParam(TypedDict, total=False):
+    grader: Required[Grader]
+    """The grader used for the fine-tuning job."""
+
+    hyperparameters: ReinforcementHyperparametersParam
+    """The hyperparameters used for the reinforcement fine-tuning job."""
diff --git a/src/openai/types/fine_tuning/supervised_hyperparameters.py b/src/openai/types/fine_tuning/supervised_hyperparameters.py
new file mode 100644
index 0000000000..3955ecf437
--- /dev/null
+++ b/src/openai/types/fine_tuning/supervised_hyperparameters.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["SupervisedHyperparameters"]
+
+
+class SupervisedHyperparameters(BaseModel):
+    batch_size: Union[Literal["auto"], int, None] = None
+    """Number of examples in each batch.
+
+    A larger batch size means that model parameters are updated less frequently, but
+    with lower variance.
+    """
+
+    learning_rate_multiplier: Union[Literal["auto"], float, None] = None
+    """Scaling factor for the learning rate.
+
+    A smaller learning rate may be useful to avoid overfitting.
+    """
+
+    n_epochs: Union[Literal["auto"], int, None] = None
+    """The number of epochs to train the model for.
+
+    An epoch refers to one full cycle through the training dataset.
+    """
diff --git a/src/openai/types/fine_tuning/supervised_hyperparameters_param.py b/src/openai/types/fine_tuning/supervised_hyperparameters_param.py
new file mode 100644
index 0000000000..bd37d9b239
--- /dev/null
+++ b/src/openai/types/fine_tuning/supervised_hyperparameters_param.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["SupervisedHyperparametersParam"]
+
+
+class SupervisedHyperparametersParam(TypedDict, total=False):
+    batch_size: Union[Literal["auto"], int]
+    """Number of examples in each batch.
+
+    A larger batch size means that model parameters are updated less frequently, but
+    with lower variance.
+    """
+
+    learning_rate_multiplier: Union[Literal["auto"], float]
+    """Scaling factor for the learning rate.
+
+    A smaller learning rate may be useful to avoid overfitting.
+    """
+
+    n_epochs: Union[Literal["auto"], int]
+    """The number of epochs to train the model for.
+
+    An epoch refers to one full cycle through the training dataset.
+    """
diff --git a/src/openai/types/fine_tuning/supervised_method.py b/src/openai/types/fine_tuning/supervised_method.py
new file mode 100644
index 0000000000..3a32bf27a0
--- /dev/null
+++ b/src/openai/types/fine_tuning/supervised_method.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .supervised_hyperparameters import SupervisedHyperparameters
+
+__all__ = ["SupervisedMethod"]
+
+
+class SupervisedMethod(BaseModel):
+    hyperparameters: Optional[SupervisedHyperparameters] = None
+    """The hyperparameters used for the fine-tuning job."""
diff --git a/src/openai/types/fine_tuning/supervised_method_param.py b/src/openai/types/fine_tuning/supervised_method_param.py
new file mode 100644
index 0000000000..ba277853d7
--- /dev/null
+++ b/src/openai/types/fine_tuning/supervised_method_param.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+from .supervised_hyperparameters_param import SupervisedHyperparametersParam
+
+__all__ = ["SupervisedMethodParam"]
+
+
+class SupervisedMethodParam(TypedDict, total=False):
+    hyperparameters: SupervisedHyperparametersParam
+    """The hyperparameters used for the fine-tuning job."""
diff --git a/src/openai/types/graders/__init__.py b/src/openai/types/graders/__init__.py
new file mode 100644
index 0000000000..e0a909125e
--- /dev/null
+++ b/src/openai/types/graders/__init__.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .multi_grader import MultiGrader as MultiGrader
+from .python_grader import PythonGrader as PythonGrader
+from .label_model_grader import LabelModelGrader as LabelModelGrader
+from .multi_grader_param import MultiGraderParam as MultiGraderParam
+from .score_model_grader import ScoreModelGrader as ScoreModelGrader
+from .python_grader_param import PythonGraderParam as PythonGraderParam
+from .string_check_grader import StringCheckGrader as StringCheckGrader
+from .text_similarity_grader import TextSimilarityGrader as TextSimilarityGrader
+from .label_model_grader_param import LabelModelGraderParam as LabelModelGraderParam
+from .score_model_grader_param import ScoreModelGraderParam as ScoreModelGraderParam
+from .string_check_grader_param import StringCheckGraderParam as StringCheckGraderParam
+from .text_similarity_grader_param import TextSimilarityGraderParam as TextSimilarityGraderParam
diff --git a/src/openai/types/graders/label_model_grader.py b/src/openai/types/graders/label_model_grader.py
new file mode 100644
index 0000000000..0929349c24
--- /dev/null
+++ b/src/openai/types/graders/label_model_grader.py
@@ -0,0 +1,70 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_audio import ResponseInputAudio
+
+__all__ = ["LabelModelGrader", "Input", "InputContent", "InputContentOutputText", "InputContentInputImage"]
+
+
+class InputContentOutputText(BaseModel):
+    text: str
+    """The text output from the model."""
+
+    type: Literal["output_text"]
+    """The type of the output text. Always `output_text`."""
+
+
+class InputContentInputImage(BaseModel):
+    image_url: str
+    """The URL of the image input."""
+
+    type: Literal["input_image"]
+    """The type of the image input. Always `input_image`."""
+
+    detail: Optional[str] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+InputContent: TypeAlias = Union[
+    str, ResponseInputText, InputContentOutputText, InputContentInputImage, ResponseInputAudio, List[object]
+]
+
+
+class Input(BaseModel):
+    content: InputContent
+    """Inputs to the model - can contain template strings."""
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
+
+
+class LabelModelGrader(BaseModel):
+    input: List[Input]
+
+    labels: List[str]
+    """The labels to assign to each item in the evaluation."""
+
+    model: str
+    """The model to use for the evaluation. Must support structured outputs."""
+
+    name: str
+    """The name of the grader."""
+
+    passing_labels: List[str]
+    """The labels that indicate a passing result. Must be a subset of labels."""
+
+    type: Literal["label_model"]
+    """The object type, which is always `label_model`."""
diff --git a/src/openai/types/graders/label_model_grader_param.py b/src/openai/types/graders/label_model_grader_param.py
new file mode 100644
index 0000000000..7bd6fdb4a7
--- /dev/null
+++ b/src/openai/types/graders/label_model_grader_param.py
@@ -0,0 +1,77 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..._types import SequenceNotStr
+from ..responses.response_input_text_param import ResponseInputTextParam
+from ..responses.response_input_audio_param import ResponseInputAudioParam
+
+__all__ = ["LabelModelGraderParam", "Input", "InputContent", "InputContentOutputText", "InputContentInputImage"]
+
+
+class InputContentOutputText(TypedDict, total=False):
+    text: Required[str]
+    """The text output from the model."""
+
+    type: Required[Literal["output_text"]]
+    """The type of the output text. Always `output_text`."""
+
+
+class InputContentInputImage(TypedDict, total=False):
+    image_url: Required[str]
+    """The URL of the image input."""
+
+    type: Required[Literal["input_image"]]
+    """The type of the image input. Always `input_image`."""
+
+    detail: str
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+InputContent: TypeAlias = Union[
+    str,
+    ResponseInputTextParam,
+    InputContentOutputText,
+    InputContentInputImage,
+    ResponseInputAudioParam,
+    Iterable[object],
+]
+
+
+class Input(TypedDict, total=False):
+    content: Required[InputContent]
+    """Inputs to the model - can contain template strings."""
+
+    role: Required[Literal["user", "assistant", "system", "developer"]]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Literal["message"]
+    """The type of the message input. Always `message`."""
+
+
+class LabelModelGraderParam(TypedDict, total=False):
+    input: Required[Iterable[Input]]
+
+    labels: Required[SequenceNotStr[str]]
+    """The labels to assign to each item in the evaluation."""
+
+    model: Required[str]
+    """The model to use for the evaluation. Must support structured outputs."""
+
+    name: Required[str]
+    """The name of the grader."""
+
+    passing_labels: Required[SequenceNotStr[str]]
+    """The labels that indicate a passing result. Must be a subset of labels."""
+
+    type: Required[Literal["label_model"]]
+    """The object type, which is always `label_model`."""
diff --git a/src/openai/types/graders/multi_grader.py b/src/openai/types/graders/multi_grader.py
new file mode 100644
index 0000000000..7539c68ef5
--- /dev/null
+++ b/src/openai/types/graders/multi_grader.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from .python_grader import PythonGrader
+from .label_model_grader import LabelModelGrader
+from .score_model_grader import ScoreModelGrader
+from .string_check_grader import StringCheckGrader
+from .text_similarity_grader import TextSimilarityGrader
+
+__all__ = ["MultiGrader", "Graders"]
+
+Graders: TypeAlias = Union[StringCheckGrader, TextSimilarityGrader, PythonGrader, ScoreModelGrader, LabelModelGrader]
+
+
+class MultiGrader(BaseModel):
+    calculate_output: str
+    """A formula to calculate the output based on grader results."""
+
+    graders: Graders
+    """
+    A StringCheckGrader object that performs a string comparison between input and
+    reference using a specified operation.
+    """
+
+    name: str
+    """The name of the grader."""
+
+    type: Literal["multi"]
+    """The object type, which is always `multi`."""
diff --git a/src/openai/types/graders/multi_grader_param.py b/src/openai/types/graders/multi_grader_param.py
new file mode 100644
index 0000000000..28a6705b81
--- /dev/null
+++ b/src/openai/types/graders/multi_grader_param.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .python_grader_param import PythonGraderParam
+from .label_model_grader_param import LabelModelGraderParam
+from .score_model_grader_param import ScoreModelGraderParam
+from .string_check_grader_param import StringCheckGraderParam
+from .text_similarity_grader_param import TextSimilarityGraderParam
+
+__all__ = ["MultiGraderParam", "Graders"]
+
+Graders: TypeAlias = Union[
+    StringCheckGraderParam, TextSimilarityGraderParam, PythonGraderParam, ScoreModelGraderParam, LabelModelGraderParam
+]
+
+
+class MultiGraderParam(TypedDict, total=False):
+    calculate_output: Required[str]
+    """A formula to calculate the output based on grader results."""
+
+    graders: Required[Graders]
+    """
+    A StringCheckGrader object that performs a string comparison between input and
+    reference using a specified operation.
+    """
+
+    name: Required[str]
+    """The name of the grader."""
+
+    type: Required[Literal["multi"]]
+    """The object type, which is always `multi`."""
diff --git a/src/openai/types/graders/python_grader.py b/src/openai/types/graders/python_grader.py
new file mode 100644
index 0000000000..faa10b1ef9
--- /dev/null
+++ b/src/openai/types/graders/python_grader.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["PythonGrader"]
+
+
+class PythonGrader(BaseModel):
+    name: str
+    """The name of the grader."""
+
+    source: str
+    """The source code of the python script."""
+
+    type: Literal["python"]
+    """The object type, which is always `python`."""
+
+    image_tag: Optional[str] = None
+    """The image tag to use for the python script."""
diff --git a/src/openai/types/graders/python_grader_param.py b/src/openai/types/graders/python_grader_param.py
new file mode 100644
index 0000000000..efb923751e
--- /dev/null
+++ b/src/openai/types/graders/python_grader_param.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["PythonGraderParam"]
+
+
+class PythonGraderParam(TypedDict, total=False):
+    name: Required[str]
+    """The name of the grader."""
+
+    source: Required[str]
+    """The source code of the python script."""
+
+    type: Required[Literal["python"]]
+    """The object type, which is always `python`."""
+
+    image_tag: str
+    """The image tag to use for the python script."""
diff --git a/src/openai/types/graders/score_model_grader.py b/src/openai/types/graders/score_model_grader.py
new file mode 100644
index 0000000000..84686a9642
--- /dev/null
+++ b/src/openai/types/graders/score_model_grader.py
@@ -0,0 +1,109 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.response_input_text import ResponseInputText
+from ..responses.response_input_audio import ResponseInputAudio
+
+__all__ = [
+    "ScoreModelGrader",
+    "Input",
+    "InputContent",
+    "InputContentOutputText",
+    "InputContentInputImage",
+    "SamplingParams",
+]
+
+
+class InputContentOutputText(BaseModel):
+    text: str
+    """The text output from the model."""
+
+    type: Literal["output_text"]
+    """The type of the output text. Always `output_text`."""
+
+
+class InputContentInputImage(BaseModel):
+    image_url: str
+    """The URL of the image input."""
+
+    type: Literal["input_image"]
+    """The type of the image input. Always `input_image`."""
+
+    detail: Optional[str] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+InputContent: TypeAlias = Union[
+    str, ResponseInputText, InputContentOutputText, InputContentInputImage, ResponseInputAudio, List[object]
+]
+
+
+class Input(BaseModel):
+    content: InputContent
+    """Inputs to the model - can contain template strings."""
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
+
+
+class SamplingParams(BaseModel):
+    max_completions_tokens: Optional[int] = None
+    """The maximum number of tokens the grader model may generate in its response."""
+
+    reasoning_effort: Optional[ReasoningEffort] = None
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    seed: Optional[int] = None
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: Optional[float] = None
+    """A higher temperature increases randomness in the outputs."""
+
+    top_p: Optional[float] = None
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class ScoreModelGrader(BaseModel):
+    input: List[Input]
+    """The input text. This may include template strings."""
+
+    model: str
+    """The model to use for the evaluation."""
+
+    name: str
+    """The name of the grader."""
+
+    type: Literal["score_model"]
+    """The object type, which is always `score_model`."""
+
+    range: Optional[List[float]] = None
+    """The range of the score. Defaults to `[0, 1]`."""
+
+    sampling_params: Optional[SamplingParams] = None
+    """The sampling parameters for the model."""
diff --git a/src/openai/types/graders/score_model_grader_param.py b/src/openai/types/graders/score_model_grader_param.py
new file mode 100644
index 0000000000..aec7a95ad4
--- /dev/null
+++ b/src/openai/types/graders/score_model_grader_param.py
@@ -0,0 +1,115 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..shared.reasoning_effort import ReasoningEffort
+from ..responses.response_input_text_param import ResponseInputTextParam
+from ..responses.response_input_audio_param import ResponseInputAudioParam
+
+__all__ = [
+    "ScoreModelGraderParam",
+    "Input",
+    "InputContent",
+    "InputContentOutputText",
+    "InputContentInputImage",
+    "SamplingParams",
+]
+
+
+class InputContentOutputText(TypedDict, total=False):
+    text: Required[str]
+    """The text output from the model."""
+
+    type: Required[Literal["output_text"]]
+    """The type of the output text. Always `output_text`."""
+
+
+class InputContentInputImage(TypedDict, total=False):
+    image_url: Required[str]
+    """The URL of the image input."""
+
+    type: Required[Literal["input_image"]]
+    """The type of the image input. Always `input_image`."""
+
+    detail: str
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+
+InputContent: TypeAlias = Union[
+    str,
+    ResponseInputTextParam,
+    InputContentOutputText,
+    InputContentInputImage,
+    ResponseInputAudioParam,
+    Iterable[object],
+]
+
+
+class Input(TypedDict, total=False):
+    content: Required[InputContent]
+    """Inputs to the model - can contain template strings."""
+
+    role: Required[Literal["user", "assistant", "system", "developer"]]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Literal["message"]
+    """The type of the message input. Always `message`."""
+
+
+class SamplingParams(TypedDict, total=False):
+    max_completions_tokens: Optional[int]
+    """The maximum number of tokens the grader model may generate in its response."""
+
+    reasoning_effort: Optional[ReasoningEffort]
+    """
+    Constrains effort on reasoning for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    """
+
+    seed: Optional[int]
+    """A seed value to initialize the randomness, during sampling."""
+
+    temperature: Optional[float]
+    """A higher temperature increases randomness in the outputs."""
+
+    top_p: Optional[float]
+    """An alternative to temperature for nucleus sampling; 1.0 includes all tokens."""
+
+
+class ScoreModelGraderParam(TypedDict, total=False):
+    input: Required[Iterable[Input]]
+    """The input text. This may include template strings."""
+
+    model: Required[str]
+    """The model to use for the evaluation."""
+
+    name: Required[str]
+    """The name of the grader."""
+
+    type: Required[Literal["score_model"]]
+    """The object type, which is always `score_model`."""
+
+    range: Iterable[float]
+    """The range of the score. Defaults to `[0, 1]`."""
+
+    sampling_params: SamplingParams
+    """The sampling parameters for the model."""
diff --git a/src/openai/types/graders/string_check_grader.py b/src/openai/types/graders/string_check_grader.py
new file mode 100644
index 0000000000..3bf0b8c868
--- /dev/null
+++ b/src/openai/types/graders/string_check_grader.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["StringCheckGrader"]
+
+
+class StringCheckGrader(BaseModel):
+    input: str
+    """The input text. This may include template strings."""
+
+    name: str
+    """The name of the grader."""
+
+    operation: Literal["eq", "ne", "like", "ilike"]
+    """The string check operation to perform. One of `eq`, `ne`, `like`, or `ilike`."""
+
+    reference: str
+    """The reference text. This may include template strings."""
+
+    type: Literal["string_check"]
+    """The object type, which is always `string_check`."""
diff --git a/src/openai/types/graders/string_check_grader_param.py b/src/openai/types/graders/string_check_grader_param.py
new file mode 100644
index 0000000000..27b204cec0
--- /dev/null
+++ b/src/openai/types/graders/string_check_grader_param.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["StringCheckGraderParam"]
+
+
+class StringCheckGraderParam(TypedDict, total=False):
+    input: Required[str]
+    """The input text. This may include template strings."""
+
+    name: Required[str]
+    """The name of the grader."""
+
+    operation: Required[Literal["eq", "ne", "like", "ilike"]]
+    """The string check operation to perform. One of `eq`, `ne`, `like`, or `ilike`."""
+
+    reference: Required[str]
+    """The reference text. This may include template strings."""
+
+    type: Required[Literal["string_check"]]
+    """The object type, which is always `string_check`."""
diff --git a/src/openai/types/graders/text_similarity_grader.py b/src/openai/types/graders/text_similarity_grader.py
new file mode 100644
index 0000000000..9082ac8969
--- /dev/null
+++ b/src/openai/types/graders/text_similarity_grader.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TextSimilarityGrader"]
+
+
+class TextSimilarityGrader(BaseModel):
+    evaluation_metric: Literal[
+        "cosine",
+        "fuzzy_match",
+        "bleu",
+        "gleu",
+        "meteor",
+        "rouge_1",
+        "rouge_2",
+        "rouge_3",
+        "rouge_4",
+        "rouge_5",
+        "rouge_l",
+    ]
+    """The evaluation metric to use.
+
+    One of `cosine`, `fuzzy_match`, `bleu`, `gleu`, `meteor`, `rouge_1`, `rouge_2`,
+    `rouge_3`, `rouge_4`, `rouge_5`, or `rouge_l`.
+    """
+
+    input: str
+    """The text being graded."""
+
+    name: str
+    """The name of the grader."""
+
+    reference: str
+    """The text being graded against."""
+
+    type: Literal["text_similarity"]
+    """The type of grader."""
diff --git a/src/openai/types/graders/text_similarity_grader_param.py b/src/openai/types/graders/text_similarity_grader_param.py
new file mode 100644
index 0000000000..1646afc84b
--- /dev/null
+++ b/src/openai/types/graders/text_similarity_grader_param.py
@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["TextSimilarityGraderParam"]
+
+
+class TextSimilarityGraderParam(TypedDict, total=False):
+    evaluation_metric: Required[
+        Literal[
+            "cosine",
+            "fuzzy_match",
+            "bleu",
+            "gleu",
+            "meteor",
+            "rouge_1",
+            "rouge_2",
+            "rouge_3",
+            "rouge_4",
+            "rouge_5",
+            "rouge_l",
+        ]
+    ]
+    """The evaluation metric to use.
+
+    One of `cosine`, `fuzzy_match`, `bleu`, `gleu`, `meteor`, `rouge_1`, `rouge_2`,
+    `rouge_3`, `rouge_4`, `rouge_5`, or `rouge_l`.
+    """
+
+    input: Required[str]
+    """The text being graded."""
+
+    name: Required[str]
+    """The name of the grader."""
+
+    reference: Required[str]
+    """The text being graded against."""
+
+    type: Required[Literal["text_similarity"]]
+    """The type of grader."""
diff --git a/src/openai/types/image.py b/src/openai/types/image.py
index f48aa2c702..ecaef3fd58 100644
--- a/src/openai/types/image.py
+++ b/src/openai/types/image.py
@@ -9,16 +9,18 @@
 
 class Image(BaseModel):
     b64_json: Optional[str] = None
-    """
-    The base64-encoded JSON of the generated image, if `response_format` is
-    `b64_json`.
+    """The base64-encoded JSON of the generated image.
+
+    Default value for `gpt-image-1`, and only present if `response_format` is set to
+    `b64_json` for `dall-e-2` and `dall-e-3`.
     """
 
     revised_prompt: Optional[str] = None
-    """
-    The prompt that was used to generate the image, if there was any revision to the
-    prompt.
-    """
+    """For `dall-e-3` only, the revised prompt that was used to generate the image."""
 
     url: Optional[str] = None
-    """The URL of the generated image, if `response_format` is `url` (default)."""
+    """
+    When using `dall-e-2` or `dall-e-3`, the URL of the generated image if
+    `response_format` is set to `url` (default value). Unsupported for
+    `gpt-image-1`.
+    """
diff --git a/src/openai/types/image_create_variation_params.py b/src/openai/types/image_create_variation_params.py
index d20f672912..d10b74b2c2 100644
--- a/src/openai/types/image_create_variation_params.py
+++ b/src/openai/types/image_create_variation_params.py
@@ -25,10 +25,7 @@ class ImageCreateVariationParams(TypedDict, total=False):
     """
 
     n: Optional[int]
-    """The number of images to generate.
-
-    Must be between 1 and 10. For `dall-e-3`, only `n=1` is supported.
-    """
+    """The number of images to generate. Must be between 1 and 10."""
 
     response_format: Optional[Literal["url", "b64_json"]]
     """The format in which the generated images are returned.
diff --git a/src/openai/types/image_edit_completed_event.py b/src/openai/types/image_edit_completed_event.py
new file mode 100644
index 0000000000..a40682da6a
--- /dev/null
+++ b/src/openai/types/image_edit_completed_event.py
@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageEditCompletedEvent", "Usage", "UsageInputTokensDetails"]
+
+
+class UsageInputTokensDetails(BaseModel):
+    image_tokens: int
+    """The number of image tokens in the input prompt."""
+
+    text_tokens: int
+    """The number of text tokens in the input prompt."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens (images and text) in the input prompt."""
+
+    input_tokens_details: UsageInputTokensDetails
+    """The input tokens detailed information for the image generation."""
+
+    output_tokens: int
+    """The number of image tokens in the output image."""
+
+    total_tokens: int
+    """The total number of tokens (images and text) used for the image generation."""
+
+
+class ImageEditCompletedEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded final edited image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the edited image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the edited image."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the edited image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the edited image."""
+
+    type: Literal["image_edit.completed"]
+    """The type of the event. Always `image_edit.completed`."""
+
+    usage: Usage
+    """For `gpt-image-1` only, the token usage information for the image generation."""
diff --git a/src/openai/types/image_edit_params.py b/src/openai/types/image_edit_params.py
index 1cb10611f3..2a8fab0f20 100644
--- a/src/openai/types/image_edit_params.py
+++ b/src/openai/types/image_edit_params.py
@@ -5,53 +5,113 @@
 from typing import Union, Optional
 from typing_extensions import Literal, Required, TypedDict
 
-from .._types import FileTypes
+from .._types import FileTypes, SequenceNotStr
 from .image_model import ImageModel
 
-__all__ = ["ImageEditParams"]
+__all__ = ["ImageEditParamsBase", "ImageEditParamsNonStreaming", "ImageEditParamsStreaming"]
 
 
-class ImageEditParams(TypedDict, total=False):
-    image: Required[FileTypes]
-    """The image to edit.
+class ImageEditParamsBase(TypedDict, total=False):
+    image: Required[Union[FileTypes, SequenceNotStr[FileTypes]]]
+    """The image(s) to edit. Must be a supported image file or an array of images.
 
-    Must be a valid PNG file, less than 4MB, and square. If mask is not provided,
-    image must have transparency, which will be used as the mask.
+    For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+    50MB. You can provide up to 16 images.
+
+    For `dall-e-2`, you can only provide one image, and it should be a square `png`
+    file less than 4MB.
     """
 
     prompt: Required[str]
     """A text description of the desired image(s).
 
-    The maximum length is 1000 characters.
+    The maximum length is 1000 characters for `dall-e-2`, and 32000 characters for
+    `gpt-image-1`.
+    """
+
+    background: Optional[Literal["transparent", "opaque", "auto"]]
+    """
+    Allows to set transparency for the background of the generated image(s). This
+    parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+    `opaque` or `auto` (default value). When `auto` is used, the model will
+    automatically determine the best background for the image.
+
+    If `transparent`, the output format needs to support transparency, so it should
+    be set to either `png` (default value) or `webp`.
+    """
+
+    input_fidelity: Optional[Literal["high", "low"]]
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+    `low`. Defaults to `low`.
     """
 
     mask: FileTypes
     """An additional image whose fully transparent areas (e.g.
 
-    where alpha is zero) indicate where `image` should be edited. Must be a valid
-    PNG file, less than 4MB, and have the same dimensions as `image`.
+    where alpha is zero) indicate where `image` should be edited. If there are
+    multiple images provided, the mask will be applied on the first image. Must be a
+    valid PNG file, less than 4MB, and have the same dimensions as `image`.
     """
 
     model: Union[str, ImageModel, None]
     """The model to use for image generation.
 
-    Only `dall-e-2` is supported at this time.
+    Only `dall-e-2` and `gpt-image-1` are supported. Defaults to `dall-e-2` unless a
+    parameter specific to `gpt-image-1` is used.
     """
 
     n: Optional[int]
     """The number of images to generate. Must be between 1 and 10."""
 
+    output_compression: Optional[int]
+    """The compression level (0-100%) for the generated images.
+
+    This parameter is only supported for `gpt-image-1` with the `webp` or `jpeg`
+    output formats, and defaults to 100.
+    """
+
+    output_format: Optional[Literal["png", "jpeg", "webp"]]
+    """The format in which the generated images are returned.
+
+    This parameter is only supported for `gpt-image-1`. Must be one of `png`,
+    `jpeg`, or `webp`. The default value is `png`.
+    """
+
+    partial_images: Optional[int]
+    """The number of partial images to generate.
+
+    This parameter is used for streaming responses that return partial images. Value
+    must be between 0 and 3. When set to 0, the response will be a single image sent
+    in one streaming event.
+
+    Note that the final image may be sent before the full number of partial images
+    are generated if the full image is generated more quickly.
+    """
+
+    quality: Optional[Literal["standard", "low", "medium", "high", "auto"]]
+    """The quality of the image that will be generated.
+
+    `high`, `medium` and `low` are only supported for `gpt-image-1`. `dall-e-2` only
+    supports `standard` quality. Defaults to `auto`.
+    """
+
     response_format: Optional[Literal["url", "b64_json"]]
     """The format in which the generated images are returned.
 
     Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes after the
-    image has been generated.
+    image has been generated. This parameter is only supported for `dall-e-2`, as
+    `gpt-image-1` will always return base64-encoded images.
     """
 
-    size: Optional[Literal["256x256", "512x512", "1024x1024"]]
+    size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
     """The size of the generated images.
 
-    Must be one of `256x256`, `512x512`, or `1024x1024`.
+    Must be one of `1024x1024`, `1536x1024` (landscape), `1024x1536` (portrait), or
+    `auto` (default value) for `gpt-image-1`, and one of `256x256`, `512x512`, or
+    `1024x1024` for `dall-e-2`.
     """
 
     user: str
@@ -60,3 +120,26 @@ class ImageEditParams(TypedDict, total=False):
     and detect abuse.
     [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
     """
+
+
+class ImageEditParamsNonStreaming(ImageEditParamsBase, total=False):
+    stream: Optional[Literal[False]]
+    """Edit the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information.
+    """
+
+
+class ImageEditParamsStreaming(ImageEditParamsBase):
+    stream: Required[Literal[True]]
+    """Edit the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information.
+    """
+
+
+ImageEditParams = Union[ImageEditParamsNonStreaming, ImageEditParamsStreaming]
diff --git a/src/openai/types/image_edit_partial_image_event.py b/src/openai/types/image_edit_partial_image_event.py
new file mode 100644
index 0000000000..20da45efc3
--- /dev/null
+++ b/src/openai/types/image_edit_partial_image_event.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageEditPartialImageEvent"]
+
+
+class ImageEditPartialImageEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded partial image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the requested edited image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the requested edited image."""
+
+    partial_image_index: int
+    """0-based index for the partial image (streaming)."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the requested edited image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the requested edited image."""
+
+    type: Literal["image_edit.partial_image"]
+    """The type of the event. Always `image_edit.partial_image`."""
diff --git a/src/openai/types/image_edit_stream_event.py b/src/openai/types/image_edit_stream_event.py
new file mode 100644
index 0000000000..759f6c6db5
--- /dev/null
+++ b/src/openai/types/image_edit_stream_event.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .image_edit_completed_event import ImageEditCompletedEvent
+from .image_edit_partial_image_event import ImageEditPartialImageEvent
+
+__all__ = ["ImageEditStreamEvent"]
+
+ImageEditStreamEvent: TypeAlias = Annotated[
+    Union[ImageEditPartialImageEvent, ImageEditCompletedEvent], PropertyInfo(discriminator="type")
+]
diff --git a/src/openai/types/image_gen_completed_event.py b/src/openai/types/image_gen_completed_event.py
new file mode 100644
index 0000000000..e78da842d4
--- /dev/null
+++ b/src/openai/types/image_gen_completed_event.py
@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageGenCompletedEvent", "Usage", "UsageInputTokensDetails"]
+
+
+class UsageInputTokensDetails(BaseModel):
+    image_tokens: int
+    """The number of image tokens in the input prompt."""
+
+    text_tokens: int
+    """The number of text tokens in the input prompt."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens (images and text) in the input prompt."""
+
+    input_tokens_details: UsageInputTokensDetails
+    """The input tokens detailed information for the image generation."""
+
+    output_tokens: int
+    """The number of image tokens in the output image."""
+
+    total_tokens: int
+    """The total number of tokens (images and text) used for the image generation."""
+
+
+class ImageGenCompletedEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the generated image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the generated image."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the generated image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the generated image."""
+
+    type: Literal["image_generation.completed"]
+    """The type of the event. Always `image_generation.completed`."""
+
+    usage: Usage
+    """For `gpt-image-1` only, the token usage information for the image generation."""
diff --git a/src/openai/types/image_gen_partial_image_event.py b/src/openai/types/image_gen_partial_image_event.py
new file mode 100644
index 0000000000..965d450604
--- /dev/null
+++ b/src/openai/types/image_gen_partial_image_event.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageGenPartialImageEvent"]
+
+
+class ImageGenPartialImageEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded partial image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the requested image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the requested image."""
+
+    partial_image_index: int
+    """0-based index for the partial image (streaming)."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the requested image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the requested image."""
+
+    type: Literal["image_generation.partial_image"]
+    """The type of the event. Always `image_generation.partial_image`."""
diff --git a/src/openai/types/image_gen_stream_event.py b/src/openai/types/image_gen_stream_event.py
new file mode 100644
index 0000000000..7dde5d5245
--- /dev/null
+++ b/src/openai/types/image_gen_stream_event.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .image_gen_completed_event import ImageGenCompletedEvent
+from .image_gen_partial_image_event import ImageGenPartialImageEvent
+
+__all__ = ["ImageGenStreamEvent"]
+
+ImageGenStreamEvent: TypeAlias = Annotated[
+    Union[ImageGenPartialImageEvent, ImageGenCompletedEvent], PropertyInfo(discriminator="type")
+]
diff --git a/src/openai/types/image_generate_params.py b/src/openai/types/image_generate_params.py
index c88c45f518..3270ca1d6e 100644
--- a/src/openai/types/image_generate_params.py
+++ b/src/openai/types/image_generate_params.py
@@ -7,19 +7,40 @@
 
 from .image_model import ImageModel
 
-__all__ = ["ImageGenerateParams"]
+__all__ = ["ImageGenerateParamsBase", "ImageGenerateParamsNonStreaming", "ImageGenerateParamsStreaming"]
 
 
-class ImageGenerateParams(TypedDict, total=False):
+class ImageGenerateParamsBase(TypedDict, total=False):
     prompt: Required[str]
     """A text description of the desired image(s).
 
-    The maximum length is 1000 characters for `dall-e-2` and 4000 characters for
-    `dall-e-3`.
+    The maximum length is 32000 characters for `gpt-image-1`, 1000 characters for
+    `dall-e-2` and 4000 characters for `dall-e-3`.
+    """
+
+    background: Optional[Literal["transparent", "opaque", "auto"]]
+    """
+    Allows to set transparency for the background of the generated image(s). This
+    parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+    `opaque` or `auto` (default value). When `auto` is used, the model will
+    automatically determine the best background for the image.
+
+    If `transparent`, the output format needs to support transparency, so it should
+    be set to either `png` (default value) or `webp`.
     """
 
     model: Union[str, ImageModel, None]
-    """The model to use for image generation."""
+    """The model to use for image generation.
+
+    One of `dall-e-2`, `dall-e-3`, or `gpt-image-1`. Defaults to `dall-e-2` unless a
+    parameter specific to `gpt-image-1` is used.
+    """
+
+    moderation: Optional[Literal["low", "auto"]]
+    """Control the content-moderation level for images generated by `gpt-image-1`.
+
+    Must be either `low` for less restrictive filtering or `auto` (default value).
+    """
 
     n: Optional[int]
     """The number of images to generate.
@@ -27,34 +48,68 @@ class ImageGenerateParams(TypedDict, total=False):
     Must be between 1 and 10. For `dall-e-3`, only `n=1` is supported.
     """
 
-    quality: Literal["standard", "hd"]
+    output_compression: Optional[int]
+    """The compression level (0-100%) for the generated images.
+
+    This parameter is only supported for `gpt-image-1` with the `webp` or `jpeg`
+    output formats, and defaults to 100.
+    """
+
+    output_format: Optional[Literal["png", "jpeg", "webp"]]
+    """The format in which the generated images are returned.
+
+    This parameter is only supported for `gpt-image-1`. Must be one of `png`,
+    `jpeg`, or `webp`.
+    """
+
+    partial_images: Optional[int]
+    """The number of partial images to generate.
+
+    This parameter is used for streaming responses that return partial images. Value
+    must be between 0 and 3. When set to 0, the response will be a single image sent
+    in one streaming event.
+
+    Note that the final image may be sent before the full number of partial images
+    are generated if the full image is generated more quickly.
+    """
+
+    quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]]
     """The quality of the image that will be generated.
 
-    `hd` creates images with finer details and greater consistency across the image.
-    This param is only supported for `dall-e-3`.
+    - `auto` (default value) will automatically select the best quality for the
+      given model.
+    - `high`, `medium` and `low` are supported for `gpt-image-1`.
+    - `hd` and `standard` are supported for `dall-e-3`.
+    - `standard` is the only option for `dall-e-2`.
     """
 
     response_format: Optional[Literal["url", "b64_json"]]
-    """The format in which the generated images are returned.
+    """The format in which generated images with `dall-e-2` and `dall-e-3` are
+    returned.
 
     Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes after the
-    image has been generated.
+    image has been generated. This parameter isn't supported for `gpt-image-1` which
+    will always return base64-encoded images.
     """
 
-    size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]]
+    size: Optional[
+        Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+    ]
     """The size of the generated images.
 
-    Must be one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`. Must be one
-    of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3` models.
+    Must be one of `1024x1024`, `1536x1024` (landscape), `1024x1536` (portrait), or
+    `auto` (default value) for `gpt-image-1`, one of `256x256`, `512x512`, or
+    `1024x1024` for `dall-e-2`, and one of `1024x1024`, `1792x1024`, or `1024x1792`
+    for `dall-e-3`.
     """
 
     style: Optional[Literal["vivid", "natural"]]
     """The style of the generated images.
 
-    Must be one of `vivid` or `natural`. Vivid causes the model to lean towards
-    generating hyper-real and dramatic images. Natural causes the model to produce
-    more natural, less hyper-real looking images. This param is only supported for
-    `dall-e-3`.
+    This parameter is only supported for `dall-e-3`. Must be one of `vivid` or
+    `natural`. Vivid causes the model to lean towards generating hyper-real and
+    dramatic images. Natural causes the model to produce more natural, less
+    hyper-real looking images.
     """
 
     user: str
@@ -63,3 +118,26 @@ class ImageGenerateParams(TypedDict, total=False):
     and detect abuse.
     [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
     """
+
+
+class ImageGenerateParamsNonStreaming(ImageGenerateParamsBase, total=False):
+    stream: Optional[Literal[False]]
+    """Generate the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information. This parameter is only supported for `gpt-image-1`.
+    """
+
+
+class ImageGenerateParamsStreaming(ImageGenerateParamsBase):
+    stream: Required[Literal[True]]
+    """Generate the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information. This parameter is only supported for `gpt-image-1`.
+    """
+
+
+ImageGenerateParams = Union[ImageGenerateParamsNonStreaming, ImageGenerateParamsStreaming]
diff --git a/src/openai/types/image_model.py b/src/openai/types/image_model.py
index 1672369bea..22b1281fa9 100644
--- a/src/openai/types/image_model.py
+++ b/src/openai/types/image_model.py
@@ -4,4 +4,4 @@
 
 __all__ = ["ImageModel"]
 
-ImageModel: TypeAlias = Literal["dall-e-2", "dall-e-3"]
+ImageModel: TypeAlias = Literal["dall-e-2", "dall-e-3", "gpt-image-1", "gpt-image-1-mini"]
diff --git a/src/openai/types/images_response.py b/src/openai/types/images_response.py
index 7cee813184..89cc71df24 100644
--- a/src/openai/types/images_response.py
+++ b/src/openai/types/images_response.py
@@ -1,14 +1,60 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List
+from typing import List, Optional
+from typing_extensions import Literal
 
 from .image import Image
 from .._models import BaseModel
 
-__all__ = ["ImagesResponse"]
+__all__ = ["ImagesResponse", "Usage", "UsageInputTokensDetails"]
+
+
+class UsageInputTokensDetails(BaseModel):
+    image_tokens: int
+    """The number of image tokens in the input prompt."""
+
+    text_tokens: int
+    """The number of text tokens in the input prompt."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens (images and text) in the input prompt."""
+
+    input_tokens_details: UsageInputTokensDetails
+    """The input tokens detailed information for the image generation."""
+
+    output_tokens: int
+    """The number of output tokens generated by the model."""
+
+    total_tokens: int
+    """The total number of tokens (images and text) used for the image generation."""
 
 
 class ImagesResponse(BaseModel):
     created: int
+    """The Unix timestamp (in seconds) of when the image was created."""
+
+    background: Optional[Literal["transparent", "opaque"]] = None
+    """The background parameter used for the image generation.
+
+    Either `transparent` or `opaque`.
+    """
+
+    data: Optional[List[Image]] = None
+    """The list of generated images."""
+
+    output_format: Optional[Literal["png", "webp", "jpeg"]] = None
+    """The output format of the image generation. Either `png`, `webp`, or `jpeg`."""
+
+    quality: Optional[Literal["low", "medium", "high"]] = None
+    """The quality of the image generated. Either `low`, `medium`, or `high`."""
+
+    size: Optional[Literal["1024x1024", "1024x1536", "1536x1024"]] = None
+    """The size of the image generated.
+
+    Either `1024x1024`, `1024x1536`, or `1536x1024`.
+    """
 
-    data: List[Image]
+    usage: Optional[Usage] = None
+    """For `gpt-image-1` only, the token usage information for the image generation."""
diff --git a/src/openai/types/model_deleted.py b/src/openai/types/model_deleted.py
index 7f81e1b380..e7601f74e4 100644
--- a/src/openai/types/model_deleted.py
+++ b/src/openai/types/model_deleted.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from .._models import BaseModel
 
 __all__ = ["ModelDeleted"]
diff --git a/src/openai/types/moderation_create_params.py b/src/openai/types/moderation_create_params.py
index 3ea2f3cd88..65d9b7e561 100644
--- a/src/openai/types/moderation_create_params.py
+++ b/src/openai/types/moderation_create_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable
+from typing import Union, Iterable
 from typing_extensions import Required, TypedDict
 
+from .._types import SequenceNotStr
 from .moderation_model import ModerationModel
 from .moderation_multi_modal_input_param import ModerationMultiModalInputParam
 
@@ -12,7 +13,7 @@
 
 
 class ModerationCreateParams(TypedDict, total=False):
-    input: Required[Union[str, List[str], Iterable[ModerationMultiModalInputParam]]]
+    input: Required[Union[str, SequenceNotStr[str], Iterable[ModerationMultiModalInputParam]]]
     """Input (or inputs) to classify.
 
     Can be a single string, an array of strings, or an array of multi-modal input
diff --git a/src/openai/types/realtime/__init__.py b/src/openai/types/realtime/__init__.py
new file mode 100644
index 0000000000..83e81a034a
--- /dev/null
+++ b/src/openai/types/realtime/__init__.py
@@ -0,0 +1,237 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .realtime_error import RealtimeError as RealtimeError
+from .call_refer_params import CallReferParams as CallReferParams
+from .conversation_item import ConversationItem as ConversationItem
+from .realtime_response import RealtimeResponse as RealtimeResponse
+from .call_accept_params import CallAcceptParams as CallAcceptParams
+from .call_create_params import CallCreateParams as CallCreateParams
+from .call_reject_params import CallRejectParams as CallRejectParams
+from .audio_transcription import AudioTranscription as AudioTranscription
+from .log_prob_properties import LogProbProperties as LogProbProperties
+from .realtime_truncation import RealtimeTruncation as RealtimeTruncation
+from .response_done_event import ResponseDoneEvent as ResponseDoneEvent
+from .noise_reduction_type import NoiseReductionType as NoiseReductionType
+from .realtime_error_event import RealtimeErrorEvent as RealtimeErrorEvent
+from .session_update_event import SessionUpdateEvent as SessionUpdateEvent
+from .mcp_list_tools_failed import McpListToolsFailed as McpListToolsFailed
+from .realtime_audio_config import RealtimeAudioConfig as RealtimeAudioConfig
+from .realtime_client_event import RealtimeClientEvent as RealtimeClientEvent
+from .realtime_server_event import RealtimeServerEvent as RealtimeServerEvent
+from .realtime_tools_config import RealtimeToolsConfig as RealtimeToolsConfig
+from .response_cancel_event import ResponseCancelEvent as ResponseCancelEvent
+from .response_create_event import ResponseCreateEvent as ResponseCreateEvent
+from .session_created_event import SessionCreatedEvent as SessionCreatedEvent
+from .session_updated_event import SessionUpdatedEvent as SessionUpdatedEvent
+from .conversation_item_done import ConversationItemDone as ConversationItemDone
+from .realtime_audio_formats import RealtimeAudioFormats as RealtimeAudioFormats
+from .realtime_function_tool import RealtimeFunctionTool as RealtimeFunctionTool
+from .realtime_mcp_tool_call import RealtimeMcpToolCall as RealtimeMcpToolCall
+from .realtime_mcphttp_error import RealtimeMcphttpError as RealtimeMcphttpError
+from .response_created_event import ResponseCreatedEvent as ResponseCreatedEvent
+from .conversation_item_added import ConversationItemAdded as ConversationItemAdded
+from .conversation_item_param import ConversationItemParam as ConversationItemParam
+from .realtime_connect_params import RealtimeConnectParams as RealtimeConnectParams
+from .realtime_mcp_list_tools import RealtimeMcpListTools as RealtimeMcpListTools
+from .realtime_response_usage import RealtimeResponseUsage as RealtimeResponseUsage
+from .realtime_tracing_config import RealtimeTracingConfig as RealtimeTracingConfig
+from .mcp_list_tools_completed import McpListToolsCompleted as McpListToolsCompleted
+from .realtime_response_status import RealtimeResponseStatus as RealtimeResponseStatus
+from .response_mcp_call_failed import ResponseMcpCallFailed as ResponseMcpCallFailed
+from .response_text_done_event import ResponseTextDoneEvent as ResponseTextDoneEvent
+from .audio_transcription_param import AudioTranscriptionParam as AudioTranscriptionParam
+from .rate_limits_updated_event import RateLimitsUpdatedEvent as RateLimitsUpdatedEvent
+from .realtime_truncation_param import RealtimeTruncationParam as RealtimeTruncationParam
+from .response_audio_done_event import ResponseAudioDoneEvent as ResponseAudioDoneEvent
+from .response_text_delta_event import ResponseTextDeltaEvent as ResponseTextDeltaEvent
+from .conversation_created_event import ConversationCreatedEvent as ConversationCreatedEvent
+from .mcp_list_tools_in_progress import McpListToolsInProgress as McpListToolsInProgress
+from .response_audio_delta_event import ResponseAudioDeltaEvent as ResponseAudioDeltaEvent
+from .session_update_event_param import SessionUpdateEventParam as SessionUpdateEventParam
+from .client_secret_create_params import ClientSecretCreateParams as ClientSecretCreateParams
+from .realtime_audio_config_input import RealtimeAudioConfigInput as RealtimeAudioConfigInput
+from .realtime_audio_config_param import RealtimeAudioConfigParam as RealtimeAudioConfigParam
+from .realtime_client_event_param import RealtimeClientEventParam as RealtimeClientEventParam
+from .realtime_mcp_protocol_error import RealtimeMcpProtocolError as RealtimeMcpProtocolError
+from .realtime_tool_choice_config import RealtimeToolChoiceConfig as RealtimeToolChoiceConfig
+from .realtime_tools_config_param import RealtimeToolsConfigParam as RealtimeToolsConfigParam
+from .realtime_tools_config_union import RealtimeToolsConfigUnion as RealtimeToolsConfigUnion
+from .response_cancel_event_param import ResponseCancelEventParam as ResponseCancelEventParam
+from .response_create_event_param import ResponseCreateEventParam as ResponseCreateEventParam
+from .response_mcp_call_completed import ResponseMcpCallCompleted as ResponseMcpCallCompleted
+from .realtime_audio_config_output import RealtimeAudioConfigOutput as RealtimeAudioConfigOutput
+from .realtime_audio_formats_param import RealtimeAudioFormatsParam as RealtimeAudioFormatsParam
+from .realtime_function_tool_param import RealtimeFunctionToolParam as RealtimeFunctionToolParam
+from .realtime_mcp_tool_call_param import RealtimeMcpToolCallParam as RealtimeMcpToolCallParam
+from .realtime_mcphttp_error_param import RealtimeMcphttpErrorParam as RealtimeMcphttpErrorParam
+from .client_secret_create_response import ClientSecretCreateResponse as ClientSecretCreateResponse
+from .realtime_mcp_approval_request import RealtimeMcpApprovalRequest as RealtimeMcpApprovalRequest
+from .realtime_mcp_list_tools_param import RealtimeMcpListToolsParam as RealtimeMcpListToolsParam
+from .realtime_tracing_config_param import RealtimeTracingConfigParam as RealtimeTracingConfigParam
+from .response_mcp_call_in_progress import ResponseMcpCallInProgress as ResponseMcpCallInProgress
+from .conversation_item_create_event import ConversationItemCreateEvent as ConversationItemCreateEvent
+from .conversation_item_delete_event import ConversationItemDeleteEvent as ConversationItemDeleteEvent
+from .input_audio_buffer_clear_event import InputAudioBufferClearEvent as InputAudioBufferClearEvent
+from .realtime_mcp_approval_response import RealtimeMcpApprovalResponse as RealtimeMcpApprovalResponse
+from .realtime_session_client_secret import RealtimeSessionClientSecret as RealtimeSessionClientSecret
+from .conversation_item_created_event import ConversationItemCreatedEvent as ConversationItemCreatedEvent
+from .conversation_item_deleted_event import ConversationItemDeletedEvent as ConversationItemDeletedEvent
+from .input_audio_buffer_append_event import InputAudioBufferAppendEvent as InputAudioBufferAppendEvent
+from .input_audio_buffer_commit_event import InputAudioBufferCommitEvent as InputAudioBufferCommitEvent
+from .output_audio_buffer_clear_event import OutputAudioBufferClearEvent as OutputAudioBufferClearEvent
+from .realtime_response_create_params import RealtimeResponseCreateParams as RealtimeResponseCreateParams
+from .realtime_session_create_request import RealtimeSessionCreateRequest as RealtimeSessionCreateRequest
+from .response_output_item_done_event import ResponseOutputItemDoneEvent as ResponseOutputItemDoneEvent
+from .conversation_item_retrieve_event import ConversationItemRetrieveEvent as ConversationItemRetrieveEvent
+from .conversation_item_truncate_event import ConversationItemTruncateEvent as ConversationItemTruncateEvent
+from .input_audio_buffer_cleared_event import InputAudioBufferClearedEvent as InputAudioBufferClearedEvent
+from .realtime_session_create_response import RealtimeSessionCreateResponse as RealtimeSessionCreateResponse
+from .response_content_part_done_event import ResponseContentPartDoneEvent as ResponseContentPartDoneEvent
+from .response_mcp_call_arguments_done import ResponseMcpCallArgumentsDone as ResponseMcpCallArgumentsDone
+from .response_output_item_added_event import ResponseOutputItemAddedEvent as ResponseOutputItemAddedEvent
+from .conversation_item_truncated_event import ConversationItemTruncatedEvent as ConversationItemTruncatedEvent
+from .realtime_audio_config_input_param import RealtimeAudioConfigInputParam as RealtimeAudioConfigInputParam
+from .realtime_mcp_protocol_error_param import RealtimeMcpProtocolErrorParam as RealtimeMcpProtocolErrorParam
+from .realtime_mcp_tool_execution_error import RealtimeMcpToolExecutionError as RealtimeMcpToolExecutionError
+from .realtime_response_create_mcp_tool import RealtimeResponseCreateMcpTool as RealtimeResponseCreateMcpTool
+from .realtime_tool_choice_config_param import RealtimeToolChoiceConfigParam as RealtimeToolChoiceConfigParam
+from .realtime_tools_config_union_param import RealtimeToolsConfigUnionParam as RealtimeToolsConfigUnionParam
+from .response_content_part_added_event import ResponseContentPartAddedEvent as ResponseContentPartAddedEvent
+from .response_mcp_call_arguments_delta import ResponseMcpCallArgumentsDelta as ResponseMcpCallArgumentsDelta
+from .input_audio_buffer_committed_event import InputAudioBufferCommittedEvent as InputAudioBufferCommittedEvent
+from .realtime_audio_config_output_param import RealtimeAudioConfigOutputParam as RealtimeAudioConfigOutputParam
+from .realtime_audio_input_turn_detection import RealtimeAudioInputTurnDetection as RealtimeAudioInputTurnDetection
+from .realtime_mcp_approval_request_param import RealtimeMcpApprovalRequestParam as RealtimeMcpApprovalRequestParam
+from .realtime_truncation_retention_ratio import RealtimeTruncationRetentionRatio as RealtimeTruncationRetentionRatio
+from .conversation_item_create_event_param import ConversationItemCreateEventParam as ConversationItemCreateEventParam
+from .conversation_item_delete_event_param import ConversationItemDeleteEventParam as ConversationItemDeleteEventParam
+from .input_audio_buffer_clear_event_param import InputAudioBufferClearEventParam as InputAudioBufferClearEventParam
+from .input_audio_buffer_timeout_triggered import InputAudioBufferTimeoutTriggered as InputAudioBufferTimeoutTriggered
+from .realtime_mcp_approval_response_param import RealtimeMcpApprovalResponseParam as RealtimeMcpApprovalResponseParam
+from .realtime_transcription_session_audio import RealtimeTranscriptionSessionAudio as RealtimeTranscriptionSessionAudio
+from .response_audio_transcript_done_event import ResponseAudioTranscriptDoneEvent as ResponseAudioTranscriptDoneEvent
+from .input_audio_buffer_append_event_param import InputAudioBufferAppendEventParam as InputAudioBufferAppendEventParam
+from .input_audio_buffer_commit_event_param import InputAudioBufferCommitEventParam as InputAudioBufferCommitEventParam
+from .output_audio_buffer_clear_event_param import OutputAudioBufferClearEventParam as OutputAudioBufferClearEventParam
+from .realtime_response_create_audio_output import (
+    RealtimeResponseCreateAudioOutput as RealtimeResponseCreateAudioOutput,
+)
+from .realtime_response_create_params_param import (
+    RealtimeResponseCreateParamsParam as RealtimeResponseCreateParamsParam,
+)
+from .realtime_session_create_request_param import (
+    RealtimeSessionCreateRequestParam as RealtimeSessionCreateRequestParam,
+)
+from .response_audio_transcript_delta_event import (
+    ResponseAudioTranscriptDeltaEvent as ResponseAudioTranscriptDeltaEvent,
+)
+from .conversation_item_retrieve_event_param import (
+    ConversationItemRetrieveEventParam as ConversationItemRetrieveEventParam,
+)
+from .conversation_item_truncate_event_param import (
+    ConversationItemTruncateEventParam as ConversationItemTruncateEventParam,
+)
+from .input_audio_buffer_speech_started_event import (
+    InputAudioBufferSpeechStartedEvent as InputAudioBufferSpeechStartedEvent,
+)
+from .input_audio_buffer_speech_stopped_event import (
+    InputAudioBufferSpeechStoppedEvent as InputAudioBufferSpeechStoppedEvent,
+)
+from .realtime_conversation_item_user_message import (
+    RealtimeConversationItemUserMessage as RealtimeConversationItemUserMessage,
+)
+from .realtime_mcp_tool_execution_error_param import (
+    RealtimeMcpToolExecutionErrorParam as RealtimeMcpToolExecutionErrorParam,
+)
+from .realtime_response_create_mcp_tool_param import (
+    RealtimeResponseCreateMcpToolParam as RealtimeResponseCreateMcpToolParam,
+)
+from .realtime_conversation_item_function_call import (
+    RealtimeConversationItemFunctionCall as RealtimeConversationItemFunctionCall,
+)
+from .realtime_audio_input_turn_detection_param import (
+    RealtimeAudioInputTurnDetectionParam as RealtimeAudioInputTurnDetectionParam,
+)
+from .realtime_conversation_item_system_message import (
+    RealtimeConversationItemSystemMessage as RealtimeConversationItemSystemMessage,
+)
+from .realtime_truncation_retention_ratio_param import (
+    RealtimeTruncationRetentionRatioParam as RealtimeTruncationRetentionRatioParam,
+)
+from .realtime_transcription_session_audio_input import (
+    RealtimeTranscriptionSessionAudioInput as RealtimeTranscriptionSessionAudioInput,
+)
+from .realtime_transcription_session_audio_param import (
+    RealtimeTranscriptionSessionAudioParam as RealtimeTranscriptionSessionAudioParam,
+)
+from .realtime_response_create_audio_output_param import (
+    RealtimeResponseCreateAudioOutputParam as RealtimeResponseCreateAudioOutputParam,
+)
+from .realtime_response_usage_input_token_details import (
+    RealtimeResponseUsageInputTokenDetails as RealtimeResponseUsageInputTokenDetails,
+)
+from .response_function_call_arguments_done_event import (
+    ResponseFunctionCallArgumentsDoneEvent as ResponseFunctionCallArgumentsDoneEvent,
+)
+from .realtime_conversation_item_assistant_message import (
+    RealtimeConversationItemAssistantMessage as RealtimeConversationItemAssistantMessage,
+)
+from .realtime_response_usage_output_token_details import (
+    RealtimeResponseUsageOutputTokenDetails as RealtimeResponseUsageOutputTokenDetails,
+)
+from .response_function_call_arguments_delta_event import (
+    ResponseFunctionCallArgumentsDeltaEvent as ResponseFunctionCallArgumentsDeltaEvent,
+)
+from .realtime_conversation_item_user_message_param import (
+    RealtimeConversationItemUserMessageParam as RealtimeConversationItemUserMessageParam,
+)
+from .realtime_transcription_session_create_request import (
+    RealtimeTranscriptionSessionCreateRequest as RealtimeTranscriptionSessionCreateRequest,
+)
+from .realtime_transcription_session_turn_detection import (
+    RealtimeTranscriptionSessionTurnDetection as RealtimeTranscriptionSessionTurnDetection,
+)
+from .realtime_conversation_item_function_call_param import (
+    RealtimeConversationItemFunctionCallParam as RealtimeConversationItemFunctionCallParam,
+)
+from .realtime_transcription_session_create_response import (
+    RealtimeTranscriptionSessionCreateResponse as RealtimeTranscriptionSessionCreateResponse,
+)
+from .realtime_conversation_item_function_call_output import (
+    RealtimeConversationItemFunctionCallOutput as RealtimeConversationItemFunctionCallOutput,
+)
+from .realtime_conversation_item_system_message_param import (
+    RealtimeConversationItemSystemMessageParam as RealtimeConversationItemSystemMessageParam,
+)
+from .realtime_transcription_session_audio_input_param import (
+    RealtimeTranscriptionSessionAudioInputParam as RealtimeTranscriptionSessionAudioInputParam,
+)
+from .realtime_conversation_item_assistant_message_param import (
+    RealtimeConversationItemAssistantMessageParam as RealtimeConversationItemAssistantMessageParam,
+)
+from .conversation_item_input_audio_transcription_segment import (
+    ConversationItemInputAudioTranscriptionSegment as ConversationItemInputAudioTranscriptionSegment,
+)
+from .realtime_transcription_session_create_request_param import (
+    RealtimeTranscriptionSessionCreateRequestParam as RealtimeTranscriptionSessionCreateRequestParam,
+)
+from .realtime_conversation_item_function_call_output_param import (
+    RealtimeConversationItemFunctionCallOutputParam as RealtimeConversationItemFunctionCallOutputParam,
+)
+from .conversation_item_input_audio_transcription_delta_event import (
+    ConversationItemInputAudioTranscriptionDeltaEvent as ConversationItemInputAudioTranscriptionDeltaEvent,
+)
+from .conversation_item_input_audio_transcription_failed_event import (
+    ConversationItemInputAudioTranscriptionFailedEvent as ConversationItemInputAudioTranscriptionFailedEvent,
+)
+from .realtime_transcription_session_audio_input_turn_detection import (
+    RealtimeTranscriptionSessionAudioInputTurnDetection as RealtimeTranscriptionSessionAudioInputTurnDetection,
+)
+from .conversation_item_input_audio_transcription_completed_event import (
+    ConversationItemInputAudioTranscriptionCompletedEvent as ConversationItemInputAudioTranscriptionCompletedEvent,
+)
+from .realtime_transcription_session_audio_input_turn_detection_param import (
+    RealtimeTranscriptionSessionAudioInputTurnDetectionParam as RealtimeTranscriptionSessionAudioInputTurnDetectionParam,
+)
diff --git a/src/openai/types/realtime/audio_transcription.py b/src/openai/types/realtime/audio_transcription.py
new file mode 100644
index 0000000000..3e5c8e0cb4
--- /dev/null
+++ b/src/openai/types/realtime/audio_transcription.py
@@ -0,0 +1,37 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["AudioTranscription"]
+
+
+class AudioTranscription(BaseModel):
+    language: Optional[str] = None
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Optional[
+        Literal["whisper-1", "gpt-4o-mini-transcribe", "gpt-4o-transcribe", "gpt-4o-transcribe-diarize"]
+    ] = None
+    """The model to use for transcription.
+
+    Current options are `whisper-1`, `gpt-4o-mini-transcribe`, `gpt-4o-transcribe`,
+    and `gpt-4o-transcribe-diarize`. Use `gpt-4o-transcribe-diarize` when you need
+    diarization with speaker labels.
+    """
+
+    prompt: Optional[str] = None
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models (excluding `gpt-4o-transcribe-diarize`), the
+    prompt is a free text string, for example "expect words related to technology".
+    """
diff --git a/src/openai/types/realtime/audio_transcription_param.py b/src/openai/types/realtime/audio_transcription_param.py
new file mode 100644
index 0000000000..3b65e42c8f
--- /dev/null
+++ b/src/openai/types/realtime/audio_transcription_param.py
@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["AudioTranscriptionParam"]
+
+
+class AudioTranscriptionParam(TypedDict, total=False):
+    language: str
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Literal["whisper-1", "gpt-4o-mini-transcribe", "gpt-4o-transcribe", "gpt-4o-transcribe-diarize"]
+    """The model to use for transcription.
+
+    Current options are `whisper-1`, `gpt-4o-mini-transcribe`, `gpt-4o-transcribe`,
+    and `gpt-4o-transcribe-diarize`. Use `gpt-4o-transcribe-diarize` when you need
+    diarization with speaker labels.
+    """
+
+    prompt: str
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models (excluding `gpt-4o-transcribe-diarize`), the
+    prompt is a free text string, for example "expect words related to technology".
+    """
diff --git a/src/openai/types/realtime/call_accept_params.py b/src/openai/types/realtime/call_accept_params.py
new file mode 100644
index 0000000000..d6fc92b8e5
--- /dev/null
+++ b/src/openai/types/realtime/call_accept_params.py
@@ -0,0 +1,122 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from .realtime_truncation_param import RealtimeTruncationParam
+from .realtime_audio_config_param import RealtimeAudioConfigParam
+from .realtime_tools_config_param import RealtimeToolsConfigParam
+from .realtime_tracing_config_param import RealtimeTracingConfigParam
+from ..responses.response_prompt_param import ResponsePromptParam
+from .realtime_tool_choice_config_param import RealtimeToolChoiceConfigParam
+
+__all__ = ["CallAcceptParams"]
+
+
+class CallAcceptParams(TypedDict, total=False):
+    type: Required[Literal["realtime"]]
+    """The type of session to create. Always `realtime` for the Realtime API."""
+
+    audio: RealtimeAudioConfigParam
+    """Configuration for input and output audio."""
+
+    include: List[Literal["item.input_audio_transcription.logprobs"]]
+    """Additional fields to include in server outputs.
+
+    `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+    transcription.
+    """
+
+    instructions: str
+    """The default system instructions (i.e.
+
+    system message) prepended to model calls. This field allows the client to guide
+    the model on desired responses. The model can be instructed on response content
+    and format, (e.g. "be extremely succinct", "act friendly", "here are examples of
+    good responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+    into your voice", "laugh frequently"). The instructions are not guaranteed to be
+    followed by the model, but they provide guidance to the model on the desired
+    behavior.
+
+    Note that the server sets default instructions which will be used if this field
+    is not set and are visible in the `session.created` event at the start of the
+    session.
+    """
+
+    max_output_tokens: Union[int, Literal["inf"]]
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+    `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+    """
+
+    model: Union[
+        str,
+        Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
+            "gpt-4o-realtime-preview",
+            "gpt-4o-realtime-preview-2024-10-01",
+            "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
+            "gpt-4o-mini-realtime-preview",
+            "gpt-4o-mini-realtime-preview-2024-12-17",
+            "gpt-realtime-mini",
+            "gpt-realtime-mini-2025-10-06",
+            "gpt-audio-mini",
+            "gpt-audio-mini-2025-10-06",
+        ],
+    ]
+    """The Realtime model used for this session."""
+
+    output_modalities: List[Literal["text", "audio"]]
+    """The set of modalities the model can respond with.
+
+    It defaults to `["audio"]`, indicating that the model will respond with audio
+    plus a transcript. `["text"]` can be used to make the model respond with text
+    only. It is not possible to request both `text` and `audio` at the same time.
+    """
+
+    prompt: Optional[ResponsePromptParam]
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    tool_choice: RealtimeToolChoiceConfigParam
+    """How the model chooses tools.
+
+    Provide one of the string modes or force a specific function/MCP tool.
+    """
+
+    tools: RealtimeToolsConfigParam
+    """Tools available to the model."""
+
+    tracing: Optional[RealtimeTracingConfigParam]
+    """
+    Realtime API can write session traces to the
+    [Traces Dashboard](/logs?api=traces). Set to null to disable tracing. Once
+    tracing is enabled for a session, the configuration cannot be modified.
+
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    truncation: RealtimeTruncationParam
+    """
+    When the number of tokens in a conversation exceeds the model's input token
+    limit, the conversation be truncated, meaning messages (starting from the
+    oldest) will not be included in the model's context. A 32k context model with
+    4,096 max output tokens can only include 28,224 tokens in the context before
+    truncation occurs. Clients can configure truncation behavior to truncate with a
+    lower max token limit, which is an effective way to control token usage and
+    cost. Truncation will reduce the number of cached tokens on the next turn
+    (busting the cache), since messages are dropped from the beginning of the
+    context. However, clients can also configure truncation to retain messages up to
+    a fraction of the maximum context size, which will reduce the need for future
+    truncations and thus improve the cache rate. Truncation can be disabled
+    entirely, which means the server will never truncate but would instead return an
+    error if the conversation exceeds the model's input token limit.
+    """
diff --git a/src/openai/types/realtime/call_create_params.py b/src/openai/types/realtime/call_create_params.py
new file mode 100644
index 0000000000..a378092a66
--- /dev/null
+++ b/src/openai/types/realtime/call_create_params.py
@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from .realtime_session_create_request_param import RealtimeSessionCreateRequestParam
+
+__all__ = ["CallCreateParams"]
+
+
+class CallCreateParams(TypedDict, total=False):
+    sdp: Required[str]
+    """WebRTC Session Description Protocol (SDP) offer generated by the caller."""
+
+    session: RealtimeSessionCreateRequestParam
+    """Realtime session object configuration."""
diff --git a/src/openai/types/realtime/call_refer_params.py b/src/openai/types/realtime/call_refer_params.py
new file mode 100644
index 0000000000..3d8623855b
--- /dev/null
+++ b/src/openai/types/realtime/call_refer_params.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["CallReferParams"]
+
+
+class CallReferParams(TypedDict, total=False):
+    target_uri: Required[str]
+    """URI that should appear in the SIP Refer-To header.
+
+    Supports values like `tel:+14155550123` or `sip:agent@example.com`.
+    """
diff --git a/src/openai/types/realtime/call_reject_params.py b/src/openai/types/realtime/call_reject_params.py
new file mode 100644
index 0000000000..f12222cded
--- /dev/null
+++ b/src/openai/types/realtime/call_reject_params.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["CallRejectParams"]
+
+
+class CallRejectParams(TypedDict, total=False):
+    status_code: int
+    """SIP response code to send back to the caller.
+
+    Defaults to `603` (Decline) when omitted.
+    """
diff --git a/src/openai/types/realtime/client_secret_create_params.py b/src/openai/types/realtime/client_secret_create_params.py
new file mode 100644
index 0000000000..5f0b0d796f
--- /dev/null
+++ b/src/openai/types/realtime/client_secret_create_params.py
@@ -0,0 +1,46 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+from .realtime_session_create_request_param import RealtimeSessionCreateRequestParam
+from .realtime_transcription_session_create_request_param import RealtimeTranscriptionSessionCreateRequestParam
+
+__all__ = ["ClientSecretCreateParams", "ExpiresAfter", "Session"]
+
+
+class ClientSecretCreateParams(TypedDict, total=False):
+    expires_after: ExpiresAfter
+    """Configuration for the client secret expiration.
+
+    Expiration refers to the time after which a client secret will no longer be
+    valid for creating sessions. The session itself may continue after that time
+    once started. A secret can be used to create multiple sessions until it expires.
+    """
+
+    session: Session
+    """Session configuration to use for the client secret.
+
+    Choose either a realtime session or a transcription session.
+    """
+
+
+class ExpiresAfter(TypedDict, total=False):
+    anchor: Literal["created_at"]
+    """
+    The anchor point for the client secret expiration, meaning that `seconds` will
+    be added to the `created_at` time of the client secret to produce an expiration
+    timestamp. Only `created_at` is currently supported.
+    """
+
+    seconds: int
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200` (2 hours). This default to 600 seconds
+    (10 minutes) if not specified.
+    """
+
+
+Session: TypeAlias = Union[RealtimeSessionCreateRequestParam, RealtimeTranscriptionSessionCreateRequestParam]
diff --git a/src/openai/types/realtime/client_secret_create_response.py b/src/openai/types/realtime/client_secret_create_response.py
new file mode 100644
index 0000000000..2aed66a25b
--- /dev/null
+++ b/src/openai/types/realtime/client_secret_create_response.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .realtime_session_create_response import RealtimeSessionCreateResponse
+from .realtime_transcription_session_create_response import RealtimeTranscriptionSessionCreateResponse
+
+__all__ = ["ClientSecretCreateResponse", "Session"]
+
+Session: TypeAlias = Annotated[
+    Union[RealtimeSessionCreateResponse, RealtimeTranscriptionSessionCreateResponse], PropertyInfo(discriminator="type")
+]
+
+
+class ClientSecretCreateResponse(BaseModel):
+    expires_at: int
+    """Expiration timestamp for the client secret, in seconds since epoch."""
+
+    session: Session
+    """The session configuration for either a realtime or transcription session."""
+
+    value: str
+    """The generated client secret value."""
diff --git a/src/openai/types/realtime/conversation_created_event.py b/src/openai/types/realtime/conversation_created_event.py
new file mode 100644
index 0000000000..6ec1dc8c85
--- /dev/null
+++ b/src/openai/types/realtime/conversation_created_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationCreatedEvent", "Conversation"]
+
+
+class Conversation(BaseModel):
+    id: Optional[str] = None
+    """The unique ID of the conversation."""
+
+    object: Optional[Literal["realtime.conversation"]] = None
+    """The object type, must be `realtime.conversation`."""
+
+
+class ConversationCreatedEvent(BaseModel):
+    conversation: Conversation
+    """The conversation resource."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    type: Literal["conversation.created"]
+    """The event type, must be `conversation.created`."""
diff --git a/src/openai/types/realtime/conversation_item.py b/src/openai/types/realtime/conversation_item.py
new file mode 100644
index 0000000000..be021520a2
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .realtime_mcp_tool_call import RealtimeMcpToolCall
+from .realtime_mcp_list_tools import RealtimeMcpListTools
+from .realtime_mcp_approval_request import RealtimeMcpApprovalRequest
+from .realtime_mcp_approval_response import RealtimeMcpApprovalResponse
+from .realtime_conversation_item_user_message import RealtimeConversationItemUserMessage
+from .realtime_conversation_item_function_call import RealtimeConversationItemFunctionCall
+from .realtime_conversation_item_system_message import RealtimeConversationItemSystemMessage
+from .realtime_conversation_item_assistant_message import RealtimeConversationItemAssistantMessage
+from .realtime_conversation_item_function_call_output import RealtimeConversationItemFunctionCallOutput
+
+__all__ = ["ConversationItem"]
+
+ConversationItem: TypeAlias = Annotated[
+    Union[
+        RealtimeConversationItemSystemMessage,
+        RealtimeConversationItemUserMessage,
+        RealtimeConversationItemAssistantMessage,
+        RealtimeConversationItemFunctionCall,
+        RealtimeConversationItemFunctionCallOutput,
+        RealtimeMcpApprovalResponse,
+        RealtimeMcpListTools,
+        RealtimeMcpToolCall,
+        RealtimeMcpApprovalRequest,
+    ],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/realtime/conversation_item_added.py b/src/openai/types/realtime/conversation_item_added.py
new file mode 100644
index 0000000000..ae9f6803e4
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_added.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ConversationItemAdded"]
+
+
+class ConversationItemAdded(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    type: Literal["conversation.item.added"]
+    """The event type, must be `conversation.item.added`."""
+
+    previous_item_id: Optional[str] = None
+    """The ID of the item that precedes this one, if any.
+
+    This is used to maintain ordering when items are inserted.
+    """
diff --git a/src/openai/types/realtime/conversation_item_create_event.py b/src/openai/types/realtime/conversation_item_create_event.py
new file mode 100644
index 0000000000..8fa2dfe08c
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_create_event.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ConversationItemCreateEvent"]
+
+
+class ConversationItemCreateEvent(BaseModel):
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    type: Literal["conversation.item.create"]
+    """The event type, must be `conversation.item.create`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
+
+    previous_item_id: Optional[str] = None
+    """The ID of the preceding item after which the new item will be inserted.
+
+    If not set, the new item will be appended to the end of the conversation. If set
+    to `root`, the new item will be added to the beginning of the conversation. If
+    set to an existing ID, it allows an item to be inserted mid-conversation. If the
+    ID cannot be found, an error will be returned and the item will not be added.
+    """
diff --git a/src/openai/types/realtime/conversation_item_create_event_param.py b/src/openai/types/realtime/conversation_item_create_event_param.py
new file mode 100644
index 0000000000..8530dc72cd
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_create_event_param.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .conversation_item_param import ConversationItemParam
+
+__all__ = ["ConversationItemCreateEventParam"]
+
+
+class ConversationItemCreateEventParam(TypedDict, total=False):
+    item: Required[ConversationItemParam]
+    """A single item within a Realtime conversation."""
+
+    type: Required[Literal["conversation.item.create"]]
+    """The event type, must be `conversation.item.create`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
+
+    previous_item_id: str
+    """The ID of the preceding item after which the new item will be inserted.
+
+    If not set, the new item will be appended to the end of the conversation. If set
+    to `root`, the new item will be added to the beginning of the conversation. If
+    set to an existing ID, it allows an item to be inserted mid-conversation. If the
+    ID cannot be found, an error will be returned and the item will not be added.
+    """
diff --git a/src/openai/types/realtime/conversation_item_created_event.py b/src/openai/types/realtime/conversation_item_created_event.py
new file mode 100644
index 0000000000..13f24ad31a
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_created_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ConversationItemCreatedEvent"]
+
+
+class ConversationItemCreatedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    type: Literal["conversation.item.created"]
+    """The event type, must be `conversation.item.created`."""
+
+    previous_item_id: Optional[str] = None
+    """
+    The ID of the preceding item in the Conversation context, allows the client to
+    understand the order of the conversation. Can be `null` if the item has no
+    predecessor.
+    """
diff --git a/src/openai/types/realtime/conversation_item_delete_event.py b/src/openai/types/realtime/conversation_item_delete_event.py
new file mode 100644
index 0000000000..3734f72e9d
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_delete_event.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationItemDeleteEvent"]
+
+
+class ConversationItemDeleteEvent(BaseModel):
+    item_id: str
+    """The ID of the item to delete."""
+
+    type: Literal["conversation.item.delete"]
+    """The event type, must be `conversation.item.delete`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/conversation_item_delete_event_param.py b/src/openai/types/realtime/conversation_item_delete_event_param.py
new file mode 100644
index 0000000000..c3f88d6627
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_delete_event_param.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ConversationItemDeleteEventParam"]
+
+
+class ConversationItemDeleteEventParam(TypedDict, total=False):
+    item_id: Required[str]
+    """The ID of the item to delete."""
+
+    type: Required[Literal["conversation.item.delete"]]
+    """The event type, must be `conversation.item.delete`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/conversation_item_deleted_event.py b/src/openai/types/realtime/conversation_item_deleted_event.py
new file mode 100644
index 0000000000..cfe6fe85fc
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_deleted_event.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationItemDeletedEvent"]
+
+
+class ConversationItemDeletedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item that was deleted."""
+
+    type: Literal["conversation.item.deleted"]
+    """The event type, must be `conversation.item.deleted`."""
diff --git a/src/openai/types/realtime/conversation_item_done.py b/src/openai/types/realtime/conversation_item_done.py
new file mode 100644
index 0000000000..a4c9b8a840
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_done.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ConversationItemDone"]
+
+
+class ConversationItemDone(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    type: Literal["conversation.item.done"]
+    """The event type, must be `conversation.item.done`."""
+
+    previous_item_id: Optional[str] = None
+    """The ID of the item that precedes this one, if any.
+
+    This is used to maintain ordering when items are inserted.
+    """
diff --git a/src/openai/types/realtime/conversation_item_input_audio_transcription_completed_event.py b/src/openai/types/realtime/conversation_item_input_audio_transcription_completed_event.py
new file mode 100644
index 0000000000..09b20aa184
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_input_audio_transcription_completed_event.py
@@ -0,0 +1,79 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from .log_prob_properties import LogProbProperties
+
+__all__ = [
+    "ConversationItemInputAudioTranscriptionCompletedEvent",
+    "Usage",
+    "UsageTranscriptTextUsageTokens",
+    "UsageTranscriptTextUsageTokensInputTokenDetails",
+    "UsageTranscriptTextUsageDuration",
+]
+
+
+class UsageTranscriptTextUsageTokensInputTokenDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """Number of audio tokens billed for this request."""
+
+    text_tokens: Optional[int] = None
+    """Number of text tokens billed for this request."""
+
+
+class UsageTranscriptTextUsageTokens(BaseModel):
+    input_tokens: int
+    """Number of input tokens billed for this request."""
+
+    output_tokens: int
+    """Number of output tokens generated."""
+
+    total_tokens: int
+    """Total number of tokens used (input + output)."""
+
+    type: Literal["tokens"]
+    """The type of the usage object. Always `tokens` for this variant."""
+
+    input_token_details: Optional[UsageTranscriptTextUsageTokensInputTokenDetails] = None
+    """Details about the input tokens billed for this request."""
+
+
+class UsageTranscriptTextUsageDuration(BaseModel):
+    seconds: float
+    """Duration of the input audio in seconds."""
+
+    type: Literal["duration"]
+    """The type of the usage object. Always `duration` for this variant."""
+
+
+Usage: TypeAlias = Union[UsageTranscriptTextUsageTokens, UsageTranscriptTextUsageDuration]
+
+
+class ConversationItemInputAudioTranscriptionCompletedEvent(BaseModel):
+    content_index: int
+    """The index of the content part containing the audio."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item containing the audio that is being transcribed."""
+
+    transcript: str
+    """The transcribed text."""
+
+    type: Literal["conversation.item.input_audio_transcription.completed"]
+    """
+    The event type, must be `conversation.item.input_audio_transcription.completed`.
+    """
+
+    usage: Usage
+    """
+    Usage statistics for the transcription, this is billed according to the ASR
+    model's pricing rather than the realtime model's pricing.
+    """
+
+    logprobs: Optional[List[LogProbProperties]] = None
+    """The log probabilities of the transcription."""
diff --git a/src/openai/types/realtime/conversation_item_input_audio_transcription_delta_event.py b/src/openai/types/realtime/conversation_item_input_audio_transcription_delta_event.py
new file mode 100644
index 0000000000..f49e6f636f
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_input_audio_transcription_delta_event.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .log_prob_properties import LogProbProperties
+
+__all__ = ["ConversationItemInputAudioTranscriptionDeltaEvent"]
+
+
+class ConversationItemInputAudioTranscriptionDeltaEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item containing the audio that is being transcribed."""
+
+    type: Literal["conversation.item.input_audio_transcription.delta"]
+    """The event type, must be `conversation.item.input_audio_transcription.delta`."""
+
+    content_index: Optional[int] = None
+    """The index of the content part in the item's content array."""
+
+    delta: Optional[str] = None
+    """The text delta."""
+
+    logprobs: Optional[List[LogProbProperties]] = None
+    """The log probabilities of the transcription.
+
+    These can be enabled by configurating the session with
+    `"include": ["item.input_audio_transcription.logprobs"]`. Each entry in the
+    array corresponds a log probability of which token would be selected for this
+    chunk of transcription. This can help to identify if it was possible there were
+    multiple valid options for a given chunk of transcription.
+    """
diff --git a/src/openai/types/realtime/conversation_item_input_audio_transcription_failed_event.py b/src/openai/types/realtime/conversation_item_input_audio_transcription_failed_event.py
new file mode 100644
index 0000000000..edb97bbf6f
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_input_audio_transcription_failed_event.py
@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationItemInputAudioTranscriptionFailedEvent", "Error"]
+
+
+class Error(BaseModel):
+    code: Optional[str] = None
+    """Error code, if any."""
+
+    message: Optional[str] = None
+    """A human-readable error message."""
+
+    param: Optional[str] = None
+    """Parameter related to the error, if any."""
+
+    type: Optional[str] = None
+    """The type of error."""
+
+
+class ConversationItemInputAudioTranscriptionFailedEvent(BaseModel):
+    content_index: int
+    """The index of the content part containing the audio."""
+
+    error: Error
+    """Details of the transcription error."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the user message item."""
+
+    type: Literal["conversation.item.input_audio_transcription.failed"]
+    """The event type, must be `conversation.item.input_audio_transcription.failed`."""
diff --git a/src/openai/types/realtime/conversation_item_input_audio_transcription_segment.py b/src/openai/types/realtime/conversation_item_input_audio_transcription_segment.py
new file mode 100644
index 0000000000..e2cbc9d299
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_input_audio_transcription_segment.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationItemInputAudioTranscriptionSegment"]
+
+
+class ConversationItemInputAudioTranscriptionSegment(BaseModel):
+    id: str
+    """The segment identifier."""
+
+    content_index: int
+    """The index of the input audio content part within the item."""
+
+    end: float
+    """End time of the segment in seconds."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item containing the input audio content."""
+
+    speaker: str
+    """The detected speaker label for this segment."""
+
+    start: float
+    """Start time of the segment in seconds."""
+
+    text: str
+    """The text for this segment."""
+
+    type: Literal["conversation.item.input_audio_transcription.segment"]
+    """The event type, must be `conversation.item.input_audio_transcription.segment`."""
diff --git a/src/openai/types/realtime/conversation_item_param.py b/src/openai/types/realtime/conversation_item_param.py
new file mode 100644
index 0000000000..c8b442ecad
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_param.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .realtime_mcp_tool_call_param import RealtimeMcpToolCallParam
+from .realtime_mcp_list_tools_param import RealtimeMcpListToolsParam
+from .realtime_mcp_approval_request_param import RealtimeMcpApprovalRequestParam
+from .realtime_mcp_approval_response_param import RealtimeMcpApprovalResponseParam
+from .realtime_conversation_item_user_message_param import RealtimeConversationItemUserMessageParam
+from .realtime_conversation_item_function_call_param import RealtimeConversationItemFunctionCallParam
+from .realtime_conversation_item_system_message_param import RealtimeConversationItemSystemMessageParam
+from .realtime_conversation_item_assistant_message_param import RealtimeConversationItemAssistantMessageParam
+from .realtime_conversation_item_function_call_output_param import RealtimeConversationItemFunctionCallOutputParam
+
+__all__ = ["ConversationItemParam"]
+
+ConversationItemParam: TypeAlias = Union[
+    RealtimeConversationItemSystemMessageParam,
+    RealtimeConversationItemUserMessageParam,
+    RealtimeConversationItemAssistantMessageParam,
+    RealtimeConversationItemFunctionCallParam,
+    RealtimeConversationItemFunctionCallOutputParam,
+    RealtimeMcpApprovalResponseParam,
+    RealtimeMcpListToolsParam,
+    RealtimeMcpToolCallParam,
+    RealtimeMcpApprovalRequestParam,
+]
diff --git a/src/openai/types/realtime/conversation_item_retrieve_event.py b/src/openai/types/realtime/conversation_item_retrieve_event.py
new file mode 100644
index 0000000000..018c2ccc59
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_retrieve_event.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationItemRetrieveEvent"]
+
+
+class ConversationItemRetrieveEvent(BaseModel):
+    item_id: str
+    """The ID of the item to retrieve."""
+
+    type: Literal["conversation.item.retrieve"]
+    """The event type, must be `conversation.item.retrieve`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/conversation_item_retrieve_event_param.py b/src/openai/types/realtime/conversation_item_retrieve_event_param.py
new file mode 100644
index 0000000000..71b3ffa499
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_retrieve_event_param.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ConversationItemRetrieveEventParam"]
+
+
+class ConversationItemRetrieveEventParam(TypedDict, total=False):
+    item_id: Required[str]
+    """The ID of the item to retrieve."""
+
+    type: Required[Literal["conversation.item.retrieve"]]
+    """The event type, must be `conversation.item.retrieve`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/conversation_item_truncate_event.py b/src/openai/types/realtime/conversation_item_truncate_event.py
new file mode 100644
index 0000000000..d6c6779cc8
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_truncate_event.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationItemTruncateEvent"]
+
+
+class ConversationItemTruncateEvent(BaseModel):
+    audio_end_ms: int
+    """Inclusive duration up to which audio is truncated, in milliseconds.
+
+    If the audio_end_ms is greater than the actual audio duration, the server will
+    respond with an error.
+    """
+
+    content_index: int
+    """The index of the content part to truncate. Set this to `0`."""
+
+    item_id: str
+    """The ID of the assistant message item to truncate.
+
+    Only assistant message items can be truncated.
+    """
+
+    type: Literal["conversation.item.truncate"]
+    """The event type, must be `conversation.item.truncate`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/conversation_item_truncate_event_param.py b/src/openai/types/realtime/conversation_item_truncate_event_param.py
new file mode 100644
index 0000000000..f5ab13a419
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_truncate_event_param.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ConversationItemTruncateEventParam"]
+
+
+class ConversationItemTruncateEventParam(TypedDict, total=False):
+    audio_end_ms: Required[int]
+    """Inclusive duration up to which audio is truncated, in milliseconds.
+
+    If the audio_end_ms is greater than the actual audio duration, the server will
+    respond with an error.
+    """
+
+    content_index: Required[int]
+    """The index of the content part to truncate. Set this to `0`."""
+
+    item_id: Required[str]
+    """The ID of the assistant message item to truncate.
+
+    Only assistant message items can be truncated.
+    """
+
+    type: Required[Literal["conversation.item.truncate"]]
+    """The event type, must be `conversation.item.truncate`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/conversation_item_truncated_event.py b/src/openai/types/realtime/conversation_item_truncated_event.py
new file mode 100644
index 0000000000..f56cabc3d9
--- /dev/null
+++ b/src/openai/types/realtime/conversation_item_truncated_event.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationItemTruncatedEvent"]
+
+
+class ConversationItemTruncatedEvent(BaseModel):
+    audio_end_ms: int
+    """The duration up to which the audio was truncated, in milliseconds."""
+
+    content_index: int
+    """The index of the content part that was truncated."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the assistant message item that was truncated."""
+
+    type: Literal["conversation.item.truncated"]
+    """The event type, must be `conversation.item.truncated`."""
diff --git a/src/openai/types/realtime/input_audio_buffer_append_event.py b/src/openai/types/realtime/input_audio_buffer_append_event.py
new file mode 100644
index 0000000000..8562cf0af4
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_append_event.py
@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferAppendEvent"]
+
+
+class InputAudioBufferAppendEvent(BaseModel):
+    audio: str
+    """Base64-encoded audio bytes.
+
+    This must be in the format specified by the `input_audio_format` field in the
+    session configuration.
+    """
+
+    type: Literal["input_audio_buffer.append"]
+    """The event type, must be `input_audio_buffer.append`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/input_audio_buffer_append_event_param.py b/src/openai/types/realtime/input_audio_buffer_append_event_param.py
new file mode 100644
index 0000000000..3ad0bc737d
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_append_event_param.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["InputAudioBufferAppendEventParam"]
+
+
+class InputAudioBufferAppendEventParam(TypedDict, total=False):
+    audio: Required[str]
+    """Base64-encoded audio bytes.
+
+    This must be in the format specified by the `input_audio_format` field in the
+    session configuration.
+    """
+
+    type: Required[Literal["input_audio_buffer.append"]]
+    """The event type, must be `input_audio_buffer.append`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/input_audio_buffer_clear_event.py b/src/openai/types/realtime/input_audio_buffer_clear_event.py
new file mode 100644
index 0000000000..9922ff3b32
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_clear_event.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferClearEvent"]
+
+
+class InputAudioBufferClearEvent(BaseModel):
+    type: Literal["input_audio_buffer.clear"]
+    """The event type, must be `input_audio_buffer.clear`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/input_audio_buffer_clear_event_param.py b/src/openai/types/realtime/input_audio_buffer_clear_event_param.py
new file mode 100644
index 0000000000..2bd6bc5a02
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_clear_event_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["InputAudioBufferClearEventParam"]
+
+
+class InputAudioBufferClearEventParam(TypedDict, total=False):
+    type: Required[Literal["input_audio_buffer.clear"]]
+    """The event type, must be `input_audio_buffer.clear`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/input_audio_buffer_cleared_event.py b/src/openai/types/realtime/input_audio_buffer_cleared_event.py
new file mode 100644
index 0000000000..af71844f2f
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_cleared_event.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferClearedEvent"]
+
+
+class InputAudioBufferClearedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    type: Literal["input_audio_buffer.cleared"]
+    """The event type, must be `input_audio_buffer.cleared`."""
diff --git a/src/openai/types/realtime/input_audio_buffer_commit_event.py b/src/openai/types/realtime/input_audio_buffer_commit_event.py
new file mode 100644
index 0000000000..125c3ba1e8
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_commit_event.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferCommitEvent"]
+
+
+class InputAudioBufferCommitEvent(BaseModel):
+    type: Literal["input_audio_buffer.commit"]
+    """The event type, must be `input_audio_buffer.commit`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/input_audio_buffer_commit_event_param.py b/src/openai/types/realtime/input_audio_buffer_commit_event_param.py
new file mode 100644
index 0000000000..c9c927ab98
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_commit_event_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["InputAudioBufferCommitEventParam"]
+
+
+class InputAudioBufferCommitEventParam(TypedDict, total=False):
+    type: Required[Literal["input_audio_buffer.commit"]]
+    """The event type, must be `input_audio_buffer.commit`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
diff --git a/src/openai/types/realtime/input_audio_buffer_committed_event.py b/src/openai/types/realtime/input_audio_buffer_committed_event.py
new file mode 100644
index 0000000000..5ed1b4ccc7
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_committed_event.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferCommittedEvent"]
+
+
+class InputAudioBufferCommittedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the user message item that will be created."""
+
+    type: Literal["input_audio_buffer.committed"]
+    """The event type, must be `input_audio_buffer.committed`."""
+
+    previous_item_id: Optional[str] = None
+    """
+    The ID of the preceding item after which the new item will be inserted. Can be
+    `null` if the item has no predecessor.
+    """
diff --git a/src/openai/types/realtime/input_audio_buffer_speech_started_event.py b/src/openai/types/realtime/input_audio_buffer_speech_started_event.py
new file mode 100644
index 0000000000..865205d786
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_speech_started_event.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferSpeechStartedEvent"]
+
+
+class InputAudioBufferSpeechStartedEvent(BaseModel):
+    audio_start_ms: int
+    """
+    Milliseconds from the start of all audio written to the buffer during the
+    session when speech was first detected. This will correspond to the beginning of
+    audio sent to the model, and thus includes the `prefix_padding_ms` configured in
+    the Session.
+    """
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the user message item that will be created when speech stops."""
+
+    type: Literal["input_audio_buffer.speech_started"]
+    """The event type, must be `input_audio_buffer.speech_started`."""
diff --git a/src/openai/types/realtime/input_audio_buffer_speech_stopped_event.py b/src/openai/types/realtime/input_audio_buffer_speech_stopped_event.py
new file mode 100644
index 0000000000..6cb7845ff4
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_speech_stopped_event.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferSpeechStoppedEvent"]
+
+
+class InputAudioBufferSpeechStoppedEvent(BaseModel):
+    audio_end_ms: int
+    """Milliseconds since the session started when speech stopped.
+
+    This will correspond to the end of audio sent to the model, and thus includes
+    the `min_silence_duration_ms` configured in the Session.
+    """
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the user message item that will be created."""
+
+    type: Literal["input_audio_buffer.speech_stopped"]
+    """The event type, must be `input_audio_buffer.speech_stopped`."""
diff --git a/src/openai/types/realtime/input_audio_buffer_timeout_triggered.py b/src/openai/types/realtime/input_audio_buffer_timeout_triggered.py
new file mode 100644
index 0000000000..5c5dc5cfa6
--- /dev/null
+++ b/src/openai/types/realtime/input_audio_buffer_timeout_triggered.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputAudioBufferTimeoutTriggered"]
+
+
+class InputAudioBufferTimeoutTriggered(BaseModel):
+    audio_end_ms: int
+    """
+    Millisecond offset of audio written to the input audio buffer at the time the
+    timeout was triggered.
+    """
+
+    audio_start_ms: int
+    """
+    Millisecond offset of audio written to the input audio buffer that was after the
+    playback time of the last model response.
+    """
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item associated with this segment."""
+
+    type: Literal["input_audio_buffer.timeout_triggered"]
+    """The event type, must be `input_audio_buffer.timeout_triggered`."""
diff --git a/src/openai/types/realtime/log_prob_properties.py b/src/openai/types/realtime/log_prob_properties.py
new file mode 100644
index 0000000000..92477d67d0
--- /dev/null
+++ b/src/openai/types/realtime/log_prob_properties.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+
+__all__ = ["LogProbProperties"]
+
+
+class LogProbProperties(BaseModel):
+    token: str
+    """The token that was used to generate the log probability."""
+
+    bytes: List[int]
+    """The bytes that were used to generate the log probability."""
+
+    logprob: float
+    """The log probability of the token."""
diff --git a/src/openai/types/realtime/mcp_list_tools_completed.py b/src/openai/types/realtime/mcp_list_tools_completed.py
new file mode 100644
index 0000000000..941280f01a
--- /dev/null
+++ b/src/openai/types/realtime/mcp_list_tools_completed.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["McpListToolsCompleted"]
+
+
+class McpListToolsCompleted(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP list tools item."""
+
+    type: Literal["mcp_list_tools.completed"]
+    """The event type, must be `mcp_list_tools.completed`."""
diff --git a/src/openai/types/realtime/mcp_list_tools_failed.py b/src/openai/types/realtime/mcp_list_tools_failed.py
new file mode 100644
index 0000000000..892eda21bd
--- /dev/null
+++ b/src/openai/types/realtime/mcp_list_tools_failed.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["McpListToolsFailed"]
+
+
+class McpListToolsFailed(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP list tools item."""
+
+    type: Literal["mcp_list_tools.failed"]
+    """The event type, must be `mcp_list_tools.failed`."""
diff --git a/src/openai/types/realtime/mcp_list_tools_in_progress.py b/src/openai/types/realtime/mcp_list_tools_in_progress.py
new file mode 100644
index 0000000000..4254b5fd33
--- /dev/null
+++ b/src/openai/types/realtime/mcp_list_tools_in_progress.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["McpListToolsInProgress"]
+
+
+class McpListToolsInProgress(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP list tools item."""
+
+    type: Literal["mcp_list_tools.in_progress"]
+    """The event type, must be `mcp_list_tools.in_progress`."""
diff --git a/src/openai/types/realtime/noise_reduction_type.py b/src/openai/types/realtime/noise_reduction_type.py
new file mode 100644
index 0000000000..f4338991bb
--- /dev/null
+++ b/src/openai/types/realtime/noise_reduction_type.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["NoiseReductionType"]
+
+NoiseReductionType: TypeAlias = Literal["near_field", "far_field"]
diff --git a/src/openai/types/realtime/output_audio_buffer_clear_event.py b/src/openai/types/realtime/output_audio_buffer_clear_event.py
new file mode 100644
index 0000000000..b4c95039f3
--- /dev/null
+++ b/src/openai/types/realtime/output_audio_buffer_clear_event.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["OutputAudioBufferClearEvent"]
+
+
+class OutputAudioBufferClearEvent(BaseModel):
+    type: Literal["output_audio_buffer.clear"]
+    """The event type, must be `output_audio_buffer.clear`."""
+
+    event_id: Optional[str] = None
+    """The unique ID of the client event used for error handling."""
diff --git a/src/openai/types/realtime/output_audio_buffer_clear_event_param.py b/src/openai/types/realtime/output_audio_buffer_clear_event_param.py
new file mode 100644
index 0000000000..a3205ebc6c
--- /dev/null
+++ b/src/openai/types/realtime/output_audio_buffer_clear_event_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["OutputAudioBufferClearEventParam"]
+
+
+class OutputAudioBufferClearEventParam(TypedDict, total=False):
+    type: Required[Literal["output_audio_buffer.clear"]]
+    """The event type, must be `output_audio_buffer.clear`."""
+
+    event_id: str
+    """The unique ID of the client event used for error handling."""
diff --git a/src/openai/types/realtime/rate_limits_updated_event.py b/src/openai/types/realtime/rate_limits_updated_event.py
new file mode 100644
index 0000000000..048a4028a1
--- /dev/null
+++ b/src/openai/types/realtime/rate_limits_updated_event.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RateLimitsUpdatedEvent", "RateLimit"]
+
+
+class RateLimit(BaseModel):
+    limit: Optional[int] = None
+    """The maximum allowed value for the rate limit."""
+
+    name: Optional[Literal["requests", "tokens"]] = None
+    """The name of the rate limit (`requests`, `tokens`)."""
+
+    remaining: Optional[int] = None
+    """The remaining value before the limit is reached."""
+
+    reset_seconds: Optional[float] = None
+    """Seconds until the rate limit resets."""
+
+
+class RateLimitsUpdatedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    rate_limits: List[RateLimit]
+    """List of rate limit information."""
+
+    type: Literal["rate_limits.updated"]
+    """The event type, must be `rate_limits.updated`."""
diff --git a/src/openai/types/realtime/realtime_audio_config.py b/src/openai/types/realtime/realtime_audio_config.py
new file mode 100644
index 0000000000..72d7cc59cc
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_config.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .realtime_audio_config_input import RealtimeAudioConfigInput
+from .realtime_audio_config_output import RealtimeAudioConfigOutput
+
+__all__ = ["RealtimeAudioConfig"]
+
+
+class RealtimeAudioConfig(BaseModel):
+    input: Optional[RealtimeAudioConfigInput] = None
+
+    output: Optional[RealtimeAudioConfigOutput] = None
diff --git a/src/openai/types/realtime/realtime_audio_config_input.py b/src/openai/types/realtime/realtime_audio_config_input.py
new file mode 100644
index 0000000000..cfcb7f22d4
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_config_input.py
@@ -0,0 +1,63 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .audio_transcription import AudioTranscription
+from .noise_reduction_type import NoiseReductionType
+from .realtime_audio_formats import RealtimeAudioFormats
+from .realtime_audio_input_turn_detection import RealtimeAudioInputTurnDetection
+
+__all__ = ["RealtimeAudioConfigInput", "NoiseReduction"]
+
+
+class NoiseReduction(BaseModel):
+    type: Optional[NoiseReductionType] = None
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class RealtimeAudioConfigInput(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The format of the input audio."""
+
+    noise_reduction: Optional[NoiseReduction] = None
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    transcription: Optional[AudioTranscription] = None
+    """
+    Configuration for input audio transcription, defaults to off and can be set to
+    `null` to turn off once on. Input audio transcription is not native to the
+    model, since the model consumes audio directly. Transcription runs
+    asynchronously through
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
+    """
+
+    turn_detection: Optional[RealtimeAudioInputTurnDetection] = None
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response.
+
+    Server VAD means that the model will detect the start and end of speech based on
+    audio volume and respond at the end of user speech.
+
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
diff --git a/src/openai/types/realtime/realtime_audio_config_input_param.py b/src/openai/types/realtime/realtime_audio_config_input_param.py
new file mode 100644
index 0000000000..730f46cfec
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_config_input_param.py
@@ -0,0 +1,65 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+from .noise_reduction_type import NoiseReductionType
+from .audio_transcription_param import AudioTranscriptionParam
+from .realtime_audio_formats_param import RealtimeAudioFormatsParam
+from .realtime_audio_input_turn_detection_param import RealtimeAudioInputTurnDetectionParam
+
+__all__ = ["RealtimeAudioConfigInputParam", "NoiseReduction"]
+
+
+class NoiseReduction(TypedDict, total=False):
+    type: NoiseReductionType
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class RealtimeAudioConfigInputParam(TypedDict, total=False):
+    format: RealtimeAudioFormatsParam
+    """The format of the input audio."""
+
+    noise_reduction: NoiseReduction
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    transcription: AudioTranscriptionParam
+    """
+    Configuration for input audio transcription, defaults to off and can be set to
+    `null` to turn off once on. Input audio transcription is not native to the
+    model, since the model consumes audio directly. Transcription runs
+    asynchronously through
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
+    """
+
+    turn_detection: Optional[RealtimeAudioInputTurnDetectionParam]
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response.
+
+    Server VAD means that the model will detect the start and end of speech based on
+    audio volume and respond at the end of user speech.
+
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
diff --git a/src/openai/types/realtime/realtime_audio_config_output.py b/src/openai/types/realtime/realtime_audio_config_output.py
new file mode 100644
index 0000000000..a8af237c1d
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_config_output.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_audio_formats import RealtimeAudioFormats
+
+__all__ = ["RealtimeAudioConfigOutput"]
+
+
+class RealtimeAudioConfigOutput(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The format of the output audio."""
+
+    speed: Optional[float] = None
+    """
+    The speed of the model's spoken response as a multiple of the original speed.
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+
+    This parameter is a post-processing adjustment to the audio after it is
+    generated, it's also possible to prompt the model to speak faster or slower.
+    """
+
+    voice: Union[
+        str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"], None
+    ] = None
+    """The voice the model uses to respond.
+
+    Voice cannot be changed during the session once the model has responded with
+    audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
+    `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and `cedar`. We recommend
+    `marin` and `cedar` for best quality.
+    """
diff --git a/src/openai/types/realtime/realtime_audio_config_output_param.py b/src/openai/types/realtime/realtime_audio_config_output_param.py
new file mode 100644
index 0000000000..8e887d3464
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_config_output_param.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypedDict
+
+from .realtime_audio_formats_param import RealtimeAudioFormatsParam
+
+__all__ = ["RealtimeAudioConfigOutputParam"]
+
+
+class RealtimeAudioConfigOutputParam(TypedDict, total=False):
+    format: RealtimeAudioFormatsParam
+    """The format of the output audio."""
+
+    speed: float
+    """
+    The speed of the model's spoken response as a multiple of the original speed.
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+
+    This parameter is a post-processing adjustment to the audio after it is
+    generated, it's also possible to prompt the model to speak faster or slower.
+    """
+
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"]]
+    """The voice the model uses to respond.
+
+    Voice cannot be changed during the session once the model has responded with
+    audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
+    `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and `cedar`. We recommend
+    `marin` and `cedar` for best quality.
+    """
diff --git a/src/openai/types/realtime/realtime_audio_config_param.py b/src/openai/types/realtime/realtime_audio_config_param.py
new file mode 100644
index 0000000000..2c41de35ae
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_config_param.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+from .realtime_audio_config_input_param import RealtimeAudioConfigInputParam
+from .realtime_audio_config_output_param import RealtimeAudioConfigOutputParam
+
+__all__ = ["RealtimeAudioConfigParam"]
+
+
+class RealtimeAudioConfigParam(TypedDict, total=False):
+    input: RealtimeAudioConfigInputParam
+
+    output: RealtimeAudioConfigOutputParam
diff --git a/src/openai/types/realtime/realtime_audio_formats.py b/src/openai/types/realtime/realtime_audio_formats.py
new file mode 100644
index 0000000000..10f91883b6
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_formats.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = ["RealtimeAudioFormats", "AudioPCM", "AudioPCMU", "AudioPCMA"]
+
+
+class AudioPCM(BaseModel):
+    rate: Optional[Literal[24000]] = None
+    """The sample rate of the audio. Always `24000`."""
+
+    type: Optional[Literal["audio/pcm"]] = None
+    """The audio format. Always `audio/pcm`."""
+
+
+class AudioPCMU(BaseModel):
+    type: Optional[Literal["audio/pcmu"]] = None
+    """The audio format. Always `audio/pcmu`."""
+
+
+class AudioPCMA(BaseModel):
+    type: Optional[Literal["audio/pcma"]] = None
+    """The audio format. Always `audio/pcma`."""
+
+
+RealtimeAudioFormats: TypeAlias = Annotated[Union[AudioPCM, AudioPCMU, AudioPCMA], PropertyInfo(discriminator="type")]
diff --git a/src/openai/types/realtime/realtime_audio_formats_param.py b/src/openai/types/realtime/realtime_audio_formats_param.py
new file mode 100644
index 0000000000..cf58577f38
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_formats_param.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+__all__ = ["RealtimeAudioFormatsParam", "AudioPCM", "AudioPCMU", "AudioPCMA"]
+
+
+class AudioPCM(TypedDict, total=False):
+    rate: Literal[24000]
+    """The sample rate of the audio. Always `24000`."""
+
+    type: Literal["audio/pcm"]
+    """The audio format. Always `audio/pcm`."""
+
+
+class AudioPCMU(TypedDict, total=False):
+    type: Literal["audio/pcmu"]
+    """The audio format. Always `audio/pcmu`."""
+
+
+class AudioPCMA(TypedDict, total=False):
+    type: Literal["audio/pcma"]
+    """The audio format. Always `audio/pcma`."""
+
+
+RealtimeAudioFormatsParam: TypeAlias = Union[AudioPCM, AudioPCMU, AudioPCMA]
diff --git a/src/openai/types/realtime/realtime_audio_input_turn_detection.py b/src/openai/types/realtime/realtime_audio_input_turn_detection.py
new file mode 100644
index 0000000000..d3f4e00316
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_input_turn_detection.py
@@ -0,0 +1,98 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = ["RealtimeAudioInputTurnDetection", "ServerVad", "SemanticVad"]
+
+
+class ServerVad(BaseModel):
+    type: Literal["server_vad"]
+    """Type of turn detection, `server_vad` to turn on simple Server VAD."""
+
+    create_response: Optional[bool] = None
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    idle_timeout_ms: Optional[int] = None
+    """Optional timeout after which a model response will be triggered automatically.
+
+    This is useful for situations in which a long pause from the user is unexpected,
+    such as a phone call. The model will effectively prompt the user to continue the
+    conversation based on the current context.
+
+    The timeout value will be applied after the last model response's audio has
+    finished playing, i.e. it's set to the `response.done` time plus audio playback
+    duration.
+
+    An `input_audio_buffer.timeout_triggered` event (plus events associated with the
+    Response) will be emitted when the timeout is reached. Idle timeout is currently
+    only supported for `server_vad` mode.
+    """
+
+    interrupt_response: Optional[bool] = None
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+    prefix_padding_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: Optional[float] = None
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+
+class SemanticVad(BaseModel):
+    type: Literal["semantic_vad"]
+    """Type of turn detection, `semantic_vad` to turn on Semantic VAD."""
+
+    create_response: Optional[bool] = None
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    eagerness: Optional[Literal["low", "medium", "high", "auto"]] = None
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`. `low`, `medium`, and `high` have max timeouts of 8s,
+    4s, and 2s respectively.
+    """
+
+    interrupt_response: Optional[bool] = None
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+
+RealtimeAudioInputTurnDetection: TypeAlias = Annotated[
+    Union[ServerVad, SemanticVad, None], PropertyInfo(discriminator="type")
+]
diff --git a/src/openai/types/realtime/realtime_audio_input_turn_detection_param.py b/src/openai/types/realtime/realtime_audio_input_turn_detection_param.py
new file mode 100644
index 0000000000..09b8cfd159
--- /dev/null
+++ b/src/openai/types/realtime/realtime_audio_input_turn_detection_param.py
@@ -0,0 +1,95 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["RealtimeAudioInputTurnDetectionParam", "ServerVad", "SemanticVad"]
+
+
+class ServerVad(TypedDict, total=False):
+    type: Required[Literal["server_vad"]]
+    """Type of turn detection, `server_vad` to turn on simple Server VAD."""
+
+    create_response: bool
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    idle_timeout_ms: Optional[int]
+    """Optional timeout after which a model response will be triggered automatically.
+
+    This is useful for situations in which a long pause from the user is unexpected,
+    such as a phone call. The model will effectively prompt the user to continue the
+    conversation based on the current context.
+
+    The timeout value will be applied after the last model response's audio has
+    finished playing, i.e. it's set to the `response.done` time plus audio playback
+    duration.
+
+    An `input_audio_buffer.timeout_triggered` event (plus events associated with the
+    Response) will be emitted when the timeout is reached. Idle timeout is currently
+    only supported for `server_vad` mode.
+    """
+
+    interrupt_response: bool
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+    prefix_padding_ms: int
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: int
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: float
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+
+class SemanticVad(TypedDict, total=False):
+    type: Required[Literal["semantic_vad"]]
+    """Type of turn detection, `semantic_vad` to turn on Semantic VAD."""
+
+    create_response: bool
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    eagerness: Literal["low", "medium", "high", "auto"]
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`. `low`, `medium`, and `high` have max timeouts of 8s,
+    4s, and 2s respectively.
+    """
+
+    interrupt_response: bool
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+
+RealtimeAudioInputTurnDetectionParam: TypeAlias = Union[ServerVad, SemanticVad]
diff --git a/src/openai/types/realtime/realtime_client_event.py b/src/openai/types/realtime/realtime_client_event.py
new file mode 100644
index 0000000000..3b1c348daa
--- /dev/null
+++ b/src/openai/types/realtime/realtime_client_event.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .session_update_event import SessionUpdateEvent
+from .response_cancel_event import ResponseCancelEvent
+from .response_create_event import ResponseCreateEvent
+from .conversation_item_create_event import ConversationItemCreateEvent
+from .conversation_item_delete_event import ConversationItemDeleteEvent
+from .input_audio_buffer_clear_event import InputAudioBufferClearEvent
+from .input_audio_buffer_append_event import InputAudioBufferAppendEvent
+from .input_audio_buffer_commit_event import InputAudioBufferCommitEvent
+from .output_audio_buffer_clear_event import OutputAudioBufferClearEvent
+from .conversation_item_retrieve_event import ConversationItemRetrieveEvent
+from .conversation_item_truncate_event import ConversationItemTruncateEvent
+
+__all__ = ["RealtimeClientEvent"]
+
+RealtimeClientEvent: TypeAlias = Annotated[
+    Union[
+        ConversationItemCreateEvent,
+        ConversationItemDeleteEvent,
+        ConversationItemRetrieveEvent,
+        ConversationItemTruncateEvent,
+        InputAudioBufferAppendEvent,
+        InputAudioBufferClearEvent,
+        OutputAudioBufferClearEvent,
+        InputAudioBufferCommitEvent,
+        ResponseCancelEvent,
+        ResponseCreateEvent,
+        SessionUpdateEvent,
+    ],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/realtime/realtime_client_event_param.py b/src/openai/types/realtime/realtime_client_event_param.py
new file mode 100644
index 0000000000..cda5766e2a
--- /dev/null
+++ b/src/openai/types/realtime/realtime_client_event_param.py
@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .session_update_event_param import SessionUpdateEventParam
+from .response_cancel_event_param import ResponseCancelEventParam
+from .response_create_event_param import ResponseCreateEventParam
+from .conversation_item_create_event_param import ConversationItemCreateEventParam
+from .conversation_item_delete_event_param import ConversationItemDeleteEventParam
+from .input_audio_buffer_clear_event_param import InputAudioBufferClearEventParam
+from .input_audio_buffer_append_event_param import InputAudioBufferAppendEventParam
+from .input_audio_buffer_commit_event_param import InputAudioBufferCommitEventParam
+from .output_audio_buffer_clear_event_param import OutputAudioBufferClearEventParam
+from .conversation_item_retrieve_event_param import ConversationItemRetrieveEventParam
+from .conversation_item_truncate_event_param import ConversationItemTruncateEventParam
+
+__all__ = ["RealtimeClientEventParam"]
+
+RealtimeClientEventParam: TypeAlias = Union[
+    ConversationItemCreateEventParam,
+    ConversationItemDeleteEventParam,
+    ConversationItemRetrieveEventParam,
+    ConversationItemTruncateEventParam,
+    InputAudioBufferAppendEventParam,
+    InputAudioBufferClearEventParam,
+    OutputAudioBufferClearEventParam,
+    InputAudioBufferCommitEventParam,
+    ResponseCancelEventParam,
+    ResponseCreateEventParam,
+    SessionUpdateEventParam,
+]
diff --git a/src/openai/types/realtime/realtime_connect_params.py b/src/openai/types/realtime/realtime_connect_params.py
new file mode 100644
index 0000000000..950f36212f
--- /dev/null
+++ b/src/openai/types/realtime/realtime_connect_params.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["RealtimeConnectParams"]
+
+
+class RealtimeConnectParams(TypedDict, total=False):
+    call_id: str
+
+    model: str
diff --git a/src/openai/types/realtime/realtime_conversation_item_assistant_message.py b/src/openai/types/realtime/realtime_conversation_item_assistant_message.py
new file mode 100644
index 0000000000..6b0f86ee32
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_assistant_message.py
@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeConversationItemAssistantMessage", "Content"]
+
+
+class Content(BaseModel):
+    audio: Optional[str] = None
+    """
+    Base64-encoded audio bytes, these will be parsed as the format specified in the
+    session output audio type configuration. This defaults to PCM 16-bit 24kHz mono
+    if not specified.
+    """
+
+    text: Optional[str] = None
+    """The text content."""
+
+    transcript: Optional[str] = None
+    """
+    The transcript of the audio content, this will always be present if the output
+    type is `audio`.
+    """
+
+    type: Optional[Literal["output_text", "output_audio"]] = None
+    """
+    The content type, `output_text` or `output_audio` depending on the session
+    `output_modalities` configuration.
+    """
+
+
+class RealtimeConversationItemAssistantMessage(BaseModel):
+    content: List[Content]
+    """The content of the message."""
+
+    role: Literal["assistant"]
+    """The role of the message sender. Always `assistant`."""
+
+    type: Literal["message"]
+    """The type of the item. Always `message`."""
+
+    id: Optional[str] = None
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Optional[Literal["realtime.item"]] = None
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Optional[Literal["completed", "incomplete", "in_progress"]] = None
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_assistant_message_param.py b/src/openai/types/realtime/realtime_conversation_item_assistant_message_param.py
new file mode 100644
index 0000000000..93699afba2
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_assistant_message_param.py
@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeConversationItemAssistantMessageParam", "Content"]
+
+
+class Content(TypedDict, total=False):
+    audio: str
+    """
+    Base64-encoded audio bytes, these will be parsed as the format specified in the
+    session output audio type configuration. This defaults to PCM 16-bit 24kHz mono
+    if not specified.
+    """
+
+    text: str
+    """The text content."""
+
+    transcript: str
+    """
+    The transcript of the audio content, this will always be present if the output
+    type is `audio`.
+    """
+
+    type: Literal["output_text", "output_audio"]
+    """
+    The content type, `output_text` or `output_audio` depending on the session
+    `output_modalities` configuration.
+    """
+
+
+class RealtimeConversationItemAssistantMessageParam(TypedDict, total=False):
+    content: Required[Iterable[Content]]
+    """The content of the message."""
+
+    role: Required[Literal["assistant"]]
+    """The role of the message sender. Always `assistant`."""
+
+    type: Required[Literal["message"]]
+    """The type of the item. Always `message`."""
+
+    id: str
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Literal["realtime.item"]
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Literal["completed", "incomplete", "in_progress"]
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_function_call.py b/src/openai/types/realtime/realtime_conversation_item_function_call.py
new file mode 100644
index 0000000000..279a2fcdc5
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_function_call.py
@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeConversationItemFunctionCall"]
+
+
+class RealtimeConversationItemFunctionCall(BaseModel):
+    arguments: str
+    """The arguments of the function call.
+
+    This is a JSON-encoded string representing the arguments passed to the function,
+    for example `{"arg1": "value1", "arg2": 42}`.
+    """
+
+    name: str
+    """The name of the function being called."""
+
+    type: Literal["function_call"]
+    """The type of the item. Always `function_call`."""
+
+    id: Optional[str] = None
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    call_id: Optional[str] = None
+    """The ID of the function call."""
+
+    object: Optional[Literal["realtime.item"]] = None
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Optional[Literal["completed", "incomplete", "in_progress"]] = None
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_function_call_output.py b/src/openai/types/realtime/realtime_conversation_item_function_call_output.py
new file mode 100644
index 0000000000..4b6b15d0ad
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_function_call_output.py
@@ -0,0 +1,37 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeConversationItemFunctionCallOutput"]
+
+
+class RealtimeConversationItemFunctionCallOutput(BaseModel):
+    call_id: str
+    """The ID of the function call this output is for."""
+
+    output: str
+    """
+    The output of the function call, this is free text and can contain any
+    information or simply be empty.
+    """
+
+    type: Literal["function_call_output"]
+    """The type of the item. Always `function_call_output`."""
+
+    id: Optional[str] = None
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Optional[Literal["realtime.item"]] = None
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Optional[Literal["completed", "incomplete", "in_progress"]] = None
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_function_call_output_param.py b/src/openai/types/realtime/realtime_conversation_item_function_call_output_param.py
new file mode 100644
index 0000000000..56d62da563
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_function_call_output_param.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeConversationItemFunctionCallOutputParam"]
+
+
+class RealtimeConversationItemFunctionCallOutputParam(TypedDict, total=False):
+    call_id: Required[str]
+    """The ID of the function call this output is for."""
+
+    output: Required[str]
+    """
+    The output of the function call, this is free text and can contain any
+    information or simply be empty.
+    """
+
+    type: Required[Literal["function_call_output"]]
+    """The type of the item. Always `function_call_output`."""
+
+    id: str
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Literal["realtime.item"]
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Literal["completed", "incomplete", "in_progress"]
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_function_call_param.py b/src/openai/types/realtime/realtime_conversation_item_function_call_param.py
new file mode 100644
index 0000000000..36a16a27b3
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_function_call_param.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeConversationItemFunctionCallParam"]
+
+
+class RealtimeConversationItemFunctionCallParam(TypedDict, total=False):
+    arguments: Required[str]
+    """The arguments of the function call.
+
+    This is a JSON-encoded string representing the arguments passed to the function,
+    for example `{"arg1": "value1", "arg2": 42}`.
+    """
+
+    name: Required[str]
+    """The name of the function being called."""
+
+    type: Required[Literal["function_call"]]
+    """The type of the item. Always `function_call`."""
+
+    id: str
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    call_id: str
+    """The ID of the function call."""
+
+    object: Literal["realtime.item"]
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Literal["completed", "incomplete", "in_progress"]
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_system_message.py b/src/openai/types/realtime/realtime_conversation_item_system_message.py
new file mode 100644
index 0000000000..7dac5c9fe2
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_system_message.py
@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeConversationItemSystemMessage", "Content"]
+
+
+class Content(BaseModel):
+    text: Optional[str] = None
+    """The text content."""
+
+    type: Optional[Literal["input_text"]] = None
+    """The content type. Always `input_text` for system messages."""
+
+
+class RealtimeConversationItemSystemMessage(BaseModel):
+    content: List[Content]
+    """The content of the message."""
+
+    role: Literal["system"]
+    """The role of the message sender. Always `system`."""
+
+    type: Literal["message"]
+    """The type of the item. Always `message`."""
+
+    id: Optional[str] = None
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Optional[Literal["realtime.item"]] = None
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Optional[Literal["completed", "incomplete", "in_progress"]] = None
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_system_message_param.py b/src/openai/types/realtime/realtime_conversation_item_system_message_param.py
new file mode 100644
index 0000000000..a2790fcf67
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_system_message_param.py
@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeConversationItemSystemMessageParam", "Content"]
+
+
+class Content(TypedDict, total=False):
+    text: str
+    """The text content."""
+
+    type: Literal["input_text"]
+    """The content type. Always `input_text` for system messages."""
+
+
+class RealtimeConversationItemSystemMessageParam(TypedDict, total=False):
+    content: Required[Iterable[Content]]
+    """The content of the message."""
+
+    role: Required[Literal["system"]]
+    """The role of the message sender. Always `system`."""
+
+    type: Required[Literal["message"]]
+    """The type of the item. Always `message`."""
+
+    id: str
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Literal["realtime.item"]
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Literal["completed", "incomplete", "in_progress"]
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_user_message.py b/src/openai/types/realtime/realtime_conversation_item_user_message.py
new file mode 100644
index 0000000000..30d9bb10e3
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_user_message.py
@@ -0,0 +1,69 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeConversationItemUserMessage", "Content"]
+
+
+class Content(BaseModel):
+    audio: Optional[str] = None
+    """
+    Base64-encoded audio bytes (for `input_audio`), these will be parsed as the
+    format specified in the session input audio type configuration. This defaults to
+    PCM 16-bit 24kHz mono if not specified.
+    """
+
+    detail: Optional[Literal["auto", "low", "high"]] = None
+    """The detail level of the image (for `input_image`).
+
+    `auto` will default to `high`.
+    """
+
+    image_url: Optional[str] = None
+    """Base64-encoded image bytes (for `input_image`) as a data URI.
+
+    For example `data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...`. Supported
+    formats are PNG and JPEG.
+    """
+
+    text: Optional[str] = None
+    """The text content (for `input_text`)."""
+
+    transcript: Optional[str] = None
+    """Transcript of the audio (for `input_audio`).
+
+    This is not sent to the model, but will be attached to the message item for
+    reference.
+    """
+
+    type: Optional[Literal["input_text", "input_audio", "input_image"]] = None
+    """The content type (`input_text`, `input_audio`, or `input_image`)."""
+
+
+class RealtimeConversationItemUserMessage(BaseModel):
+    content: List[Content]
+    """The content of the message."""
+
+    role: Literal["user"]
+    """The role of the message sender. Always `user`."""
+
+    type: Literal["message"]
+    """The type of the item. Always `message`."""
+
+    id: Optional[str] = None
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Optional[Literal["realtime.item"]] = None
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Optional[Literal["completed", "incomplete", "in_progress"]] = None
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_conversation_item_user_message_param.py b/src/openai/types/realtime/realtime_conversation_item_user_message_param.py
new file mode 100644
index 0000000000..7d3b9bc137
--- /dev/null
+++ b/src/openai/types/realtime/realtime_conversation_item_user_message_param.py
@@ -0,0 +1,69 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeConversationItemUserMessageParam", "Content"]
+
+
+class Content(TypedDict, total=False):
+    audio: str
+    """
+    Base64-encoded audio bytes (for `input_audio`), these will be parsed as the
+    format specified in the session input audio type configuration. This defaults to
+    PCM 16-bit 24kHz mono if not specified.
+    """
+
+    detail: Literal["auto", "low", "high"]
+    """The detail level of the image (for `input_image`).
+
+    `auto` will default to `high`.
+    """
+
+    image_url: str
+    """Base64-encoded image bytes (for `input_image`) as a data URI.
+
+    For example `data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...`. Supported
+    formats are PNG and JPEG.
+    """
+
+    text: str
+    """The text content (for `input_text`)."""
+
+    transcript: str
+    """Transcript of the audio (for `input_audio`).
+
+    This is not sent to the model, but will be attached to the message item for
+    reference.
+    """
+
+    type: Literal["input_text", "input_audio", "input_image"]
+    """The content type (`input_text`, `input_audio`, or `input_image`)."""
+
+
+class RealtimeConversationItemUserMessageParam(TypedDict, total=False):
+    content: Required[Iterable[Content]]
+    """The content of the message."""
+
+    role: Required[Literal["user"]]
+    """The role of the message sender. Always `user`."""
+
+    type: Required[Literal["message"]]
+    """The type of the item. Always `message`."""
+
+    id: str
+    """The unique ID of the item.
+
+    This may be provided by the client or generated by the server.
+    """
+
+    object: Literal["realtime.item"]
+    """Identifier for the API object being returned - always `realtime.item`.
+
+    Optional when creating a new item.
+    """
+
+    status: Literal["completed", "incomplete", "in_progress"]
+    """The status of the item. Has no effect on the conversation."""
diff --git a/src/openai/types/realtime/realtime_error.py b/src/openai/types/realtime/realtime_error.py
new file mode 100644
index 0000000000..f1017d09e4
--- /dev/null
+++ b/src/openai/types/realtime/realtime_error.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeError"]
+
+
+class RealtimeError(BaseModel):
+    message: str
+    """A human-readable error message."""
+
+    type: str
+    """The type of error (e.g., "invalid_request_error", "server_error")."""
+
+    code: Optional[str] = None
+    """Error code, if any."""
+
+    event_id: Optional[str] = None
+    """The event_id of the client event that caused the error, if applicable."""
+
+    param: Optional[str] = None
+    """Parameter related to the error, if any."""
diff --git a/src/openai/types/realtime/realtime_error_event.py b/src/openai/types/realtime/realtime_error_event.py
new file mode 100644
index 0000000000..8b501d6b21
--- /dev/null
+++ b/src/openai/types/realtime/realtime_error_event.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_error import RealtimeError
+
+__all__ = ["RealtimeErrorEvent"]
+
+
+class RealtimeErrorEvent(BaseModel):
+    error: RealtimeError
+    """Details of the error."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    type: Literal["error"]
+    """The event type, must be `error`."""
diff --git a/src/openai/types/realtime/realtime_function_tool.py b/src/openai/types/realtime/realtime_function_tool.py
new file mode 100644
index 0000000000..48dbf9929d
--- /dev/null
+++ b/src/openai/types/realtime/realtime_function_tool.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeFunctionTool"]
+
+
+class RealtimeFunctionTool(BaseModel):
+    description: Optional[str] = None
+    """
+    The description of the function, including guidance on when and how to call it,
+    and guidance about what to tell the user when calling (if anything).
+    """
+
+    name: Optional[str] = None
+    """The name of the function."""
+
+    parameters: Optional[object] = None
+    """Parameters of the function in JSON Schema."""
+
+    type: Optional[Literal["function"]] = None
+    """The type of the tool, i.e. `function`."""
diff --git a/src/openai/types/realtime/realtime_function_tool_param.py b/src/openai/types/realtime/realtime_function_tool_param.py
new file mode 100644
index 0000000000..f42e3e497c
--- /dev/null
+++ b/src/openai/types/realtime/realtime_function_tool_param.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["RealtimeFunctionToolParam"]
+
+
+class RealtimeFunctionToolParam(TypedDict, total=False):
+    description: str
+    """
+    The description of the function, including guidance on when and how to call it,
+    and guidance about what to tell the user when calling (if anything).
+    """
+
+    name: str
+    """The name of the function."""
+
+    parameters: object
+    """Parameters of the function in JSON Schema."""
+
+    type: Literal["function"]
+    """The type of the tool, i.e. `function`."""
diff --git a/src/openai/types/realtime/realtime_mcp_approval_request.py b/src/openai/types/realtime/realtime_mcp_approval_request.py
new file mode 100644
index 0000000000..bafc8d89d4
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_approval_request.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeMcpApprovalRequest"]
+
+
+class RealtimeMcpApprovalRequest(BaseModel):
+    id: str
+    """The unique ID of the approval request."""
+
+    arguments: str
+    """A JSON string of arguments for the tool."""
+
+    name: str
+    """The name of the tool to run."""
+
+    server_label: str
+    """The label of the MCP server making the request."""
+
+    type: Literal["mcp_approval_request"]
+    """The type of the item. Always `mcp_approval_request`."""
diff --git a/src/openai/types/realtime/realtime_mcp_approval_request_param.py b/src/openai/types/realtime/realtime_mcp_approval_request_param.py
new file mode 100644
index 0000000000..57c21a487f
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_approval_request_param.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeMcpApprovalRequestParam"]
+
+
+class RealtimeMcpApprovalRequestParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the approval request."""
+
+    arguments: Required[str]
+    """A JSON string of arguments for the tool."""
+
+    name: Required[str]
+    """The name of the tool to run."""
+
+    server_label: Required[str]
+    """The label of the MCP server making the request."""
+
+    type: Required[Literal["mcp_approval_request"]]
+    """The type of the item. Always `mcp_approval_request`."""
diff --git a/src/openai/types/realtime/realtime_mcp_approval_response.py b/src/openai/types/realtime/realtime_mcp_approval_response.py
new file mode 100644
index 0000000000..2cb03bc61a
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_approval_response.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeMcpApprovalResponse"]
+
+
+class RealtimeMcpApprovalResponse(BaseModel):
+    id: str
+    """The unique ID of the approval response."""
+
+    approval_request_id: str
+    """The ID of the approval request being answered."""
+
+    approve: bool
+    """Whether the request was approved."""
+
+    type: Literal["mcp_approval_response"]
+    """The type of the item. Always `mcp_approval_response`."""
+
+    reason: Optional[str] = None
+    """Optional reason for the decision."""
diff --git a/src/openai/types/realtime/realtime_mcp_approval_response_param.py b/src/openai/types/realtime/realtime_mcp_approval_response_param.py
new file mode 100644
index 0000000000..19b6337004
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_approval_response_param.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeMcpApprovalResponseParam"]
+
+
+class RealtimeMcpApprovalResponseParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the approval response."""
+
+    approval_request_id: Required[str]
+    """The ID of the approval request being answered."""
+
+    approve: Required[bool]
+    """Whether the request was approved."""
+
+    type: Required[Literal["mcp_approval_response"]]
+    """The type of the item. Always `mcp_approval_response`."""
+
+    reason: Optional[str]
+    """Optional reason for the decision."""
diff --git a/src/openai/types/realtime/realtime_mcp_list_tools.py b/src/openai/types/realtime/realtime_mcp_list_tools.py
new file mode 100644
index 0000000000..aeb58a1faf
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_list_tools.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeMcpListTools", "Tool"]
+
+
+class Tool(BaseModel):
+    input_schema: object
+    """The JSON schema describing the tool's input."""
+
+    name: str
+    """The name of the tool."""
+
+    annotations: Optional[object] = None
+    """Additional annotations about the tool."""
+
+    description: Optional[str] = None
+    """The description of the tool."""
+
+
+class RealtimeMcpListTools(BaseModel):
+    server_label: str
+    """The label of the MCP server."""
+
+    tools: List[Tool]
+    """The tools available on the server."""
+
+    type: Literal["mcp_list_tools"]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    id: Optional[str] = None
+    """The unique ID of the list."""
diff --git a/src/openai/types/realtime/realtime_mcp_list_tools_param.py b/src/openai/types/realtime/realtime_mcp_list_tools_param.py
new file mode 100644
index 0000000000..eb8605a061
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_list_tools_param.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeMcpListToolsParam", "Tool"]
+
+
+class Tool(TypedDict, total=False):
+    input_schema: Required[object]
+    """The JSON schema describing the tool's input."""
+
+    name: Required[str]
+    """The name of the tool."""
+
+    annotations: Optional[object]
+    """Additional annotations about the tool."""
+
+    description: Optional[str]
+    """The description of the tool."""
+
+
+class RealtimeMcpListToolsParam(TypedDict, total=False):
+    server_label: Required[str]
+    """The label of the MCP server."""
+
+    tools: Required[Iterable[Tool]]
+    """The tools available on the server."""
+
+    type: Required[Literal["mcp_list_tools"]]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    id: str
+    """The unique ID of the list."""
diff --git a/src/openai/types/realtime/realtime_mcp_protocol_error.py b/src/openai/types/realtime/realtime_mcp_protocol_error.py
new file mode 100644
index 0000000000..2e7cfdffa3
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_protocol_error.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeMcpProtocolError"]
+
+
+class RealtimeMcpProtocolError(BaseModel):
+    code: int
+
+    message: str
+
+    type: Literal["protocol_error"]
diff --git a/src/openai/types/realtime/realtime_mcp_protocol_error_param.py b/src/openai/types/realtime/realtime_mcp_protocol_error_param.py
new file mode 100644
index 0000000000..bebe3d379e
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_protocol_error_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeMcpProtocolErrorParam"]
+
+
+class RealtimeMcpProtocolErrorParam(TypedDict, total=False):
+    code: Required[int]
+
+    message: Required[str]
+
+    type: Required[Literal["protocol_error"]]
diff --git a/src/openai/types/realtime/realtime_mcp_tool_call.py b/src/openai/types/realtime/realtime_mcp_tool_call.py
new file mode 100644
index 0000000000..019aee25c0
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_tool_call.py
@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .realtime_mcphttp_error import RealtimeMcphttpError
+from .realtime_mcp_protocol_error import RealtimeMcpProtocolError
+from .realtime_mcp_tool_execution_error import RealtimeMcpToolExecutionError
+
+__all__ = ["RealtimeMcpToolCall", "Error"]
+
+Error: TypeAlias = Annotated[
+    Union[RealtimeMcpProtocolError, RealtimeMcpToolExecutionError, RealtimeMcphttpError, None],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class RealtimeMcpToolCall(BaseModel):
+    id: str
+    """The unique ID of the tool call."""
+
+    arguments: str
+    """A JSON string of the arguments passed to the tool."""
+
+    name: str
+    """The name of the tool that was run."""
+
+    server_label: str
+    """The label of the MCP server running the tool."""
+
+    type: Literal["mcp_call"]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str] = None
+    """The ID of an associated approval request, if any."""
+
+    error: Optional[Error] = None
+    """The error from the tool call, if any."""
+
+    output: Optional[str] = None
+    """The output from the tool call."""
diff --git a/src/openai/types/realtime/realtime_mcp_tool_call_param.py b/src/openai/types/realtime/realtime_mcp_tool_call_param.py
new file mode 100644
index 0000000000..0ba16d3dc1
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_tool_call_param.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .realtime_mcphttp_error_param import RealtimeMcphttpErrorParam
+from .realtime_mcp_protocol_error_param import RealtimeMcpProtocolErrorParam
+from .realtime_mcp_tool_execution_error_param import RealtimeMcpToolExecutionErrorParam
+
+__all__ = ["RealtimeMcpToolCallParam", "Error"]
+
+Error: TypeAlias = Union[RealtimeMcpProtocolErrorParam, RealtimeMcpToolExecutionErrorParam, RealtimeMcphttpErrorParam]
+
+
+class RealtimeMcpToolCallParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the tool call."""
+
+    arguments: Required[str]
+    """A JSON string of the arguments passed to the tool."""
+
+    name: Required[str]
+    """The name of the tool that was run."""
+
+    server_label: Required[str]
+    """The label of the MCP server running the tool."""
+
+    type: Required[Literal["mcp_call"]]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str]
+    """The ID of an associated approval request, if any."""
+
+    error: Optional[Error]
+    """The error from the tool call, if any."""
+
+    output: Optional[str]
+    """The output from the tool call."""
diff --git a/src/openai/types/realtime/realtime_mcp_tool_execution_error.py b/src/openai/types/realtime/realtime_mcp_tool_execution_error.py
new file mode 100644
index 0000000000..a2ed063129
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_tool_execution_error.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeMcpToolExecutionError"]
+
+
+class RealtimeMcpToolExecutionError(BaseModel):
+    message: str
+
+    type: Literal["tool_execution_error"]
diff --git a/src/openai/types/realtime/realtime_mcp_tool_execution_error_param.py b/src/openai/types/realtime/realtime_mcp_tool_execution_error_param.py
new file mode 100644
index 0000000000..619e11c305
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcp_tool_execution_error_param.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeMcpToolExecutionErrorParam"]
+
+
+class RealtimeMcpToolExecutionErrorParam(TypedDict, total=False):
+    message: Required[str]
+
+    type: Required[Literal["tool_execution_error"]]
diff --git a/src/openai/types/realtime/realtime_mcphttp_error.py b/src/openai/types/realtime/realtime_mcphttp_error.py
new file mode 100644
index 0000000000..53cff91e6e
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcphttp_error.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeMcphttpError"]
+
+
+class RealtimeMcphttpError(BaseModel):
+    code: int
+
+    message: str
+
+    type: Literal["http_error"]
diff --git a/src/openai/types/realtime/realtime_mcphttp_error_param.py b/src/openai/types/realtime/realtime_mcphttp_error_param.py
new file mode 100644
index 0000000000..2b80a6f0a4
--- /dev/null
+++ b/src/openai/types/realtime/realtime_mcphttp_error_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeMcphttpErrorParam"]
+
+
+class RealtimeMcphttpErrorParam(TypedDict, total=False):
+    code: Required[int]
+
+    message: Required[str]
+
+    type: Required[Literal["http_error"]]
diff --git a/src/openai/types/realtime/realtime_response.py b/src/openai/types/realtime/realtime_response.py
new file mode 100644
index 0000000000..92d75491c0
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response.py
@@ -0,0 +1,98 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..shared.metadata import Metadata
+from .conversation_item import ConversationItem
+from .realtime_audio_formats import RealtimeAudioFormats
+from .realtime_response_usage import RealtimeResponseUsage
+from .realtime_response_status import RealtimeResponseStatus
+
+__all__ = ["RealtimeResponse", "Audio", "AudioOutput"]
+
+
+class AudioOutput(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The format of the output audio."""
+
+    voice: Union[
+        str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"], None
+    ] = None
+    """The voice the model uses to respond.
+
+    Voice cannot be changed during the session once the model has responded with
+    audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
+    `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and `cedar`. We recommend
+    `marin` and `cedar` for best quality.
+    """
+
+
+class Audio(BaseModel):
+    output: Optional[AudioOutput] = None
+
+
+class RealtimeResponse(BaseModel):
+    id: Optional[str] = None
+    """The unique ID of the response, will look like `resp_1234`."""
+
+    audio: Optional[Audio] = None
+    """Configuration for audio output."""
+
+    conversation_id: Optional[str] = None
+    """
+    Which conversation the response is added to, determined by the `conversation`
+    field in the `response.create` event. If `auto`, the response will be added to
+    the default conversation and the value of `conversation_id` will be an id like
+    `conv_1234`. If `none`, the response will not be added to any conversation and
+    the value of `conversation_id` will be `null`. If responses are being triggered
+    automatically by VAD the response will be added to the default conversation
+    """
+
+    max_output_tokens: Union[int, Literal["inf"], None] = None
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls, that was used in this response.
+    """
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    object: Optional[Literal["realtime.response"]] = None
+    """The object type, must be `realtime.response`."""
+
+    output: Optional[List[ConversationItem]] = None
+    """The list of output items generated by the response."""
+
+    output_modalities: Optional[List[Literal["text", "audio"]]] = None
+    """
+    The set of modalities the model used to respond, currently the only possible
+    values are `[\"audio\"]`, `[\"text\"]`. Audio output always include a text
+    transcript. Setting the output to mode `text` will disable audio output from the
+    model.
+    """
+
+    status: Optional[Literal["completed", "cancelled", "failed", "incomplete", "in_progress"]] = None
+    """
+    The final status of the response (`completed`, `cancelled`, `failed`, or
+    `incomplete`, `in_progress`).
+    """
+
+    status_details: Optional[RealtimeResponseStatus] = None
+    """Additional details about the status."""
+
+    usage: Optional[RealtimeResponseUsage] = None
+    """Usage statistics for the Response, this will correspond to billing.
+
+    A Realtime API session will maintain a conversation context and append new Items
+    to the Conversation, thus output from previous turns (text and audio tokens)
+    will become the input for later turns.
+    """
diff --git a/src/openai/types/realtime/realtime_response_create_audio_output.py b/src/openai/types/realtime/realtime_response_create_audio_output.py
new file mode 100644
index 0000000000..48a5d67e20
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_create_audio_output.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_audio_formats import RealtimeAudioFormats
+
+__all__ = ["RealtimeResponseCreateAudioOutput", "Output"]
+
+
+class Output(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The format of the output audio."""
+
+    voice: Union[
+        str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"], None
+    ] = None
+    """The voice the model uses to respond.
+
+    Voice cannot be changed during the session once the model has responded with
+    audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
+    `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and `cedar`. We recommend
+    `marin` and `cedar` for best quality.
+    """
+
+
+class RealtimeResponseCreateAudioOutput(BaseModel):
+    output: Optional[Output] = None
diff --git a/src/openai/types/realtime/realtime_response_create_audio_output_param.py b/src/openai/types/realtime/realtime_response_create_audio_output_param.py
new file mode 100644
index 0000000000..9aa6d28835
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_create_audio_output_param.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypedDict
+
+from .realtime_audio_formats_param import RealtimeAudioFormatsParam
+
+__all__ = ["RealtimeResponseCreateAudioOutputParam", "Output"]
+
+
+class Output(TypedDict, total=False):
+    format: RealtimeAudioFormatsParam
+    """The format of the output audio."""
+
+    voice: Union[str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"]]
+    """The voice the model uses to respond.
+
+    Voice cannot be changed during the session once the model has responded with
+    audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
+    `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and `cedar`. We recommend
+    `marin` and `cedar` for best quality.
+    """
+
+
+class RealtimeResponseCreateAudioOutputParam(TypedDict, total=False):
+    output: Output
diff --git a/src/openai/types/realtime/realtime_response_create_mcp_tool.py b/src/openai/types/realtime/realtime_response_create_mcp_tool.py
new file mode 100644
index 0000000000..119b4a455d
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_create_mcp_tool.py
@@ -0,0 +1,135 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+
+__all__ = [
+    "RealtimeResponseCreateMcpTool",
+    "AllowedTools",
+    "AllowedToolsMcpToolFilter",
+    "RequireApproval",
+    "RequireApprovalMcpToolApprovalFilter",
+    "RequireApprovalMcpToolApprovalFilterAlways",
+    "RequireApprovalMcpToolApprovalFilterNever",
+]
+
+
+class AllowedToolsMcpToolFilter(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+AllowedTools: TypeAlias = Union[List[str], AllowedToolsMcpToolFilter, None]
+
+
+class RequireApprovalMcpToolApprovalFilterAlways(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class RequireApprovalMcpToolApprovalFilterNever(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class RequireApprovalMcpToolApprovalFilter(BaseModel):
+    always: Optional[RequireApprovalMcpToolApprovalFilterAlways] = None
+    """A filter object to specify which tools are allowed."""
+
+    never: Optional[RequireApprovalMcpToolApprovalFilterNever] = None
+    """A filter object to specify which tools are allowed."""
+
+
+RequireApproval: TypeAlias = Union[RequireApprovalMcpToolApprovalFilter, Literal["always", "never"], None]
+
+
+class RealtimeResponseCreateMcpTool(BaseModel):
+    server_label: str
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Literal["mcp"]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[AllowedTools] = None
+    """List of allowed tool names or a filter object."""
+
+    authorization: Optional[str] = None
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Optional[
+        Literal[
+            "connector_dropbox",
+            "connector_gmail",
+            "connector_googlecalendar",
+            "connector_googledrive",
+            "connector_microsoftteams",
+            "connector_outlookcalendar",
+            "connector_outlookemail",
+            "connector_sharepoint",
+        ]
+    ] = None
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]] = None
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[RequireApproval] = None
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: Optional[str] = None
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: Optional[str] = None
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
diff --git a/src/openai/types/realtime/realtime_response_create_mcp_tool_param.py b/src/openai/types/realtime/realtime_response_create_mcp_tool_param.py
new file mode 100644
index 0000000000..3b9cf047c1
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_create_mcp_tool_param.py
@@ -0,0 +1,135 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..._types import SequenceNotStr
+
+__all__ = [
+    "RealtimeResponseCreateMcpToolParam",
+    "AllowedTools",
+    "AllowedToolsMcpToolFilter",
+    "RequireApproval",
+    "RequireApprovalMcpToolApprovalFilter",
+    "RequireApprovalMcpToolApprovalFilterAlways",
+    "RequireApprovalMcpToolApprovalFilterNever",
+]
+
+
+class AllowedToolsMcpToolFilter(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+AllowedTools: TypeAlias = Union[SequenceNotStr[str], AllowedToolsMcpToolFilter]
+
+
+class RequireApprovalMcpToolApprovalFilterAlways(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class RequireApprovalMcpToolApprovalFilterNever(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class RequireApprovalMcpToolApprovalFilter(TypedDict, total=False):
+    always: RequireApprovalMcpToolApprovalFilterAlways
+    """A filter object to specify which tools are allowed."""
+
+    never: RequireApprovalMcpToolApprovalFilterNever
+    """A filter object to specify which tools are allowed."""
+
+
+RequireApproval: TypeAlias = Union[RequireApprovalMcpToolApprovalFilter, Literal["always", "never"]]
+
+
+class RealtimeResponseCreateMcpToolParam(TypedDict, total=False):
+    server_label: Required[str]
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Required[Literal["mcp"]]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[AllowedTools]
+    """List of allowed tool names or a filter object."""
+
+    authorization: str
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Literal[
+        "connector_dropbox",
+        "connector_gmail",
+        "connector_googlecalendar",
+        "connector_googledrive",
+        "connector_microsoftteams",
+        "connector_outlookcalendar",
+        "connector_outlookemail",
+        "connector_sharepoint",
+    ]
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]]
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[RequireApproval]
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: str
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: str
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
diff --git a/src/openai/types/realtime/realtime_response_create_params.py b/src/openai/types/realtime/realtime_response_create_params.py
new file mode 100644
index 0000000000..e8486220bf
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_create_params.py
@@ -0,0 +1,98 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from ..shared.metadata import Metadata
+from .conversation_item import ConversationItem
+from .realtime_function_tool import RealtimeFunctionTool
+from ..responses.response_prompt import ResponsePrompt
+from ..responses.tool_choice_mcp import ToolChoiceMcp
+from ..responses.tool_choice_options import ToolChoiceOptions
+from ..responses.tool_choice_function import ToolChoiceFunction
+from .realtime_response_create_mcp_tool import RealtimeResponseCreateMcpTool
+from .realtime_response_create_audio_output import RealtimeResponseCreateAudioOutput
+
+__all__ = ["RealtimeResponseCreateParams", "ToolChoice", "Tool"]
+
+ToolChoice: TypeAlias = Union[ToolChoiceOptions, ToolChoiceFunction, ToolChoiceMcp]
+
+Tool: TypeAlias = Union[RealtimeFunctionTool, RealtimeResponseCreateMcpTool]
+
+
+class RealtimeResponseCreateParams(BaseModel):
+    audio: Optional[RealtimeResponseCreateAudioOutput] = None
+    """Configuration for audio input and output."""
+
+    conversation: Union[str, Literal["auto", "none"], None] = None
+    """Controls which conversation the response is added to.
+
+    Currently supports `auto` and `none`, with `auto` as the default value. The
+    `auto` value means that the contents of the response will be added to the
+    default conversation. Set this to `none` to create an out-of-band response which
+    will not add items to default conversation.
+    """
+
+    input: Optional[List[ConversationItem]] = None
+    """Input items to include in the prompt for the model.
+
+    Using this field creates a new context for this Response instead of using the
+    default conversation. An empty array `[]` will clear the context for this
+    Response. Note that this can include references to items that previously
+    appeared in the session using their id.
+    """
+
+    instructions: Optional[str] = None
+    """The default system instructions (i.e.
+
+    system message) prepended to model calls. This field allows the client to guide
+    the model on desired responses. The model can be instructed on response content
+    and format, (e.g. "be extremely succinct", "act friendly", "here are examples of
+    good responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+    into your voice", "laugh frequently"). The instructions are not guaranteed to be
+    followed by the model, but they provide guidance to the model on the desired
+    behavior. Note that the server sets default instructions which will be used if
+    this field is not set and are visible in the `session.created` event at the
+    start of the session.
+    """
+
+    max_output_tokens: Union[int, Literal["inf"], None] = None
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+    `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+    """
+
+    metadata: Optional[Metadata] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    output_modalities: Optional[List[Literal["text", "audio"]]] = None
+    """
+    The set of modalities the model used to respond, currently the only possible
+    values are `[\"audio\"]`, `[\"text\"]`. Audio output always include a text
+    transcript. Setting the output to mode `text` will disable audio output from the
+    model.
+    """
+
+    prompt: Optional[ResponsePrompt] = None
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    tool_choice: Optional[ToolChoice] = None
+    """How the model chooses tools.
+
+    Provide one of the string modes or force a specific function/MCP tool.
+    """
+
+    tools: Optional[List[Tool]] = None
+    """Tools available to the model."""
diff --git a/src/openai/types/realtime/realtime_response_create_params_param.py b/src/openai/types/realtime/realtime_response_create_params_param.py
new file mode 100644
index 0000000000..116384bd82
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_create_params_param.py
@@ -0,0 +1,99 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Iterable, Optional
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+from ..shared_params.metadata import Metadata
+from .conversation_item_param import ConversationItemParam
+from .realtime_function_tool_param import RealtimeFunctionToolParam
+from ..responses.tool_choice_options import ToolChoiceOptions
+from ..responses.response_prompt_param import ResponsePromptParam
+from ..responses.tool_choice_mcp_param import ToolChoiceMcpParam
+from ..responses.tool_choice_function_param import ToolChoiceFunctionParam
+from .realtime_response_create_mcp_tool_param import RealtimeResponseCreateMcpToolParam
+from .realtime_response_create_audio_output_param import RealtimeResponseCreateAudioOutputParam
+
+__all__ = ["RealtimeResponseCreateParamsParam", "ToolChoice", "Tool"]
+
+ToolChoice: TypeAlias = Union[ToolChoiceOptions, ToolChoiceFunctionParam, ToolChoiceMcpParam]
+
+Tool: TypeAlias = Union[RealtimeFunctionToolParam, RealtimeResponseCreateMcpToolParam]
+
+
+class RealtimeResponseCreateParamsParam(TypedDict, total=False):
+    audio: RealtimeResponseCreateAudioOutputParam
+    """Configuration for audio input and output."""
+
+    conversation: Union[str, Literal["auto", "none"]]
+    """Controls which conversation the response is added to.
+
+    Currently supports `auto` and `none`, with `auto` as the default value. The
+    `auto` value means that the contents of the response will be added to the
+    default conversation. Set this to `none` to create an out-of-band response which
+    will not add items to default conversation.
+    """
+
+    input: Iterable[ConversationItemParam]
+    """Input items to include in the prompt for the model.
+
+    Using this field creates a new context for this Response instead of using the
+    default conversation. An empty array `[]` will clear the context for this
+    Response. Note that this can include references to items that previously
+    appeared in the session using their id.
+    """
+
+    instructions: str
+    """The default system instructions (i.e.
+
+    system message) prepended to model calls. This field allows the client to guide
+    the model on desired responses. The model can be instructed on response content
+    and format, (e.g. "be extremely succinct", "act friendly", "here are examples of
+    good responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+    into your voice", "laugh frequently"). The instructions are not guaranteed to be
+    followed by the model, but they provide guidance to the model on the desired
+    behavior. Note that the server sets default instructions which will be used if
+    this field is not set and are visible in the `session.created` event at the
+    start of the session.
+    """
+
+    max_output_tokens: Union[int, Literal["inf"]]
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+    `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+    """
+
+    metadata: Optional[Metadata]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    output_modalities: List[Literal["text", "audio"]]
+    """
+    The set of modalities the model used to respond, currently the only possible
+    values are `[\"audio\"]`, `[\"text\"]`. Audio output always include a text
+    transcript. Setting the output to mode `text` will disable audio output from the
+    model.
+    """
+
+    prompt: Optional[ResponsePromptParam]
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    tool_choice: ToolChoice
+    """How the model chooses tools.
+
+    Provide one of the string modes or force a specific function/MCP tool.
+    """
+
+    tools: Iterable[Tool]
+    """Tools available to the model."""
diff --git a/src/openai/types/realtime/realtime_response_status.py b/src/openai/types/realtime/realtime_response_status.py
new file mode 100644
index 0000000000..12999f61a1
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_status.py
@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeResponseStatus", "Error"]
+
+
+class Error(BaseModel):
+    code: Optional[str] = None
+    """Error code, if any."""
+
+    type: Optional[str] = None
+    """The type of error."""
+
+
+class RealtimeResponseStatus(BaseModel):
+    error: Optional[Error] = None
+    """
+    A description of the error that caused the response to fail, populated when the
+    `status` is `failed`.
+    """
+
+    reason: Optional[Literal["turn_detected", "client_cancelled", "max_output_tokens", "content_filter"]] = None
+    """The reason the Response did not complete.
+
+    For a `cancelled` Response, one of `turn_detected` (the server VAD detected a
+    new start of speech) or `client_cancelled` (the client sent a cancel event). For
+    an `incomplete` Response, one of `max_output_tokens` or `content_filter` (the
+    server-side safety filter activated and cut off the response).
+    """
+
+    type: Optional[Literal["completed", "cancelled", "incomplete", "failed"]] = None
+    """
+    The type of error that caused the response to fail, corresponding with the
+    `status` field (`completed`, `cancelled`, `incomplete`, `failed`).
+    """
diff --git a/src/openai/types/realtime/realtime_response_usage.py b/src/openai/types/realtime/realtime_response_usage.py
new file mode 100644
index 0000000000..fb8893b346
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_usage.py
@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .realtime_response_usage_input_token_details import RealtimeResponseUsageInputTokenDetails
+from .realtime_response_usage_output_token_details import RealtimeResponseUsageOutputTokenDetails
+
+__all__ = ["RealtimeResponseUsage"]
+
+
+class RealtimeResponseUsage(BaseModel):
+    input_token_details: Optional[RealtimeResponseUsageInputTokenDetails] = None
+    """Details about the input tokens used in the Response.
+
+    Cached tokens are tokens from previous turns in the conversation that are
+    included as context for the current response. Cached tokens here are counted as
+    a subset of input tokens, meaning input tokens will include cached and uncached
+    tokens.
+    """
+
+    input_tokens: Optional[int] = None
+    """
+    The number of input tokens used in the Response, including text and audio
+    tokens.
+    """
+
+    output_token_details: Optional[RealtimeResponseUsageOutputTokenDetails] = None
+    """Details about the output tokens used in the Response."""
+
+    output_tokens: Optional[int] = None
+    """
+    The number of output tokens sent in the Response, including text and audio
+    tokens.
+    """
+
+    total_tokens: Optional[int] = None
+    """
+    The total number of tokens in the Response including input and output text and
+    audio tokens.
+    """
diff --git a/src/openai/types/realtime/realtime_response_usage_input_token_details.py b/src/openai/types/realtime/realtime_response_usage_input_token_details.py
new file mode 100644
index 0000000000..e14a74a84e
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_usage_input_token_details.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeResponseUsageInputTokenDetails", "CachedTokensDetails"]
+
+
+class CachedTokensDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """The number of cached audio tokens used as input for the Response."""
+
+    image_tokens: Optional[int] = None
+    """The number of cached image tokens used as input for the Response."""
+
+    text_tokens: Optional[int] = None
+    """The number of cached text tokens used as input for the Response."""
+
+
+class RealtimeResponseUsageInputTokenDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """The number of audio tokens used as input for the Response."""
+
+    cached_tokens: Optional[int] = None
+    """The number of cached tokens used as input for the Response."""
+
+    cached_tokens_details: Optional[CachedTokensDetails] = None
+    """Details about the cached tokens used as input for the Response."""
+
+    image_tokens: Optional[int] = None
+    """The number of image tokens used as input for the Response."""
+
+    text_tokens: Optional[int] = None
+    """The number of text tokens used as input for the Response."""
diff --git a/src/openai/types/realtime/realtime_response_usage_output_token_details.py b/src/openai/types/realtime/realtime_response_usage_output_token_details.py
new file mode 100644
index 0000000000..dfa97a1f47
--- /dev/null
+++ b/src/openai/types/realtime/realtime_response_usage_output_token_details.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeResponseUsageOutputTokenDetails"]
+
+
+class RealtimeResponseUsageOutputTokenDetails(BaseModel):
+    audio_tokens: Optional[int] = None
+    """The number of audio tokens used in the Response."""
+
+    text_tokens: Optional[int] = None
+    """The number of text tokens used in the Response."""
diff --git a/src/openai/types/realtime/realtime_server_event.py b/src/openai/types/realtime/realtime_server_event.py
new file mode 100644
index 0000000000..1605b81a97
--- /dev/null
+++ b/src/openai/types/realtime/realtime_server_event.py
@@ -0,0 +1,155 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+from .response_done_event import ResponseDoneEvent
+from .realtime_error_event import RealtimeErrorEvent
+from .mcp_list_tools_failed import McpListToolsFailed
+from .session_created_event import SessionCreatedEvent
+from .session_updated_event import SessionUpdatedEvent
+from .conversation_item_done import ConversationItemDone
+from .response_created_event import ResponseCreatedEvent
+from .conversation_item_added import ConversationItemAdded
+from .mcp_list_tools_completed import McpListToolsCompleted
+from .response_mcp_call_failed import ResponseMcpCallFailed
+from .response_text_done_event import ResponseTextDoneEvent
+from .rate_limits_updated_event import RateLimitsUpdatedEvent
+from .response_audio_done_event import ResponseAudioDoneEvent
+from .response_text_delta_event import ResponseTextDeltaEvent
+from .conversation_created_event import ConversationCreatedEvent
+from .mcp_list_tools_in_progress import McpListToolsInProgress
+from .response_audio_delta_event import ResponseAudioDeltaEvent
+from .response_mcp_call_completed import ResponseMcpCallCompleted
+from .response_mcp_call_in_progress import ResponseMcpCallInProgress
+from .conversation_item_created_event import ConversationItemCreatedEvent
+from .conversation_item_deleted_event import ConversationItemDeletedEvent
+from .response_output_item_done_event import ResponseOutputItemDoneEvent
+from .input_audio_buffer_cleared_event import InputAudioBufferClearedEvent
+from .response_content_part_done_event import ResponseContentPartDoneEvent
+from .response_mcp_call_arguments_done import ResponseMcpCallArgumentsDone
+from .response_output_item_added_event import ResponseOutputItemAddedEvent
+from .conversation_item_truncated_event import ConversationItemTruncatedEvent
+from .response_content_part_added_event import ResponseContentPartAddedEvent
+from .response_mcp_call_arguments_delta import ResponseMcpCallArgumentsDelta
+from .input_audio_buffer_committed_event import InputAudioBufferCommittedEvent
+from .input_audio_buffer_timeout_triggered import InputAudioBufferTimeoutTriggered
+from .response_audio_transcript_done_event import ResponseAudioTranscriptDoneEvent
+from .response_audio_transcript_delta_event import ResponseAudioTranscriptDeltaEvent
+from .input_audio_buffer_speech_started_event import InputAudioBufferSpeechStartedEvent
+from .input_audio_buffer_speech_stopped_event import InputAudioBufferSpeechStoppedEvent
+from .response_function_call_arguments_done_event import ResponseFunctionCallArgumentsDoneEvent
+from .response_function_call_arguments_delta_event import ResponseFunctionCallArgumentsDeltaEvent
+from .conversation_item_input_audio_transcription_segment import ConversationItemInputAudioTranscriptionSegment
+from .conversation_item_input_audio_transcription_delta_event import ConversationItemInputAudioTranscriptionDeltaEvent
+from .conversation_item_input_audio_transcription_failed_event import ConversationItemInputAudioTranscriptionFailedEvent
+from .conversation_item_input_audio_transcription_completed_event import (
+    ConversationItemInputAudioTranscriptionCompletedEvent,
+)
+
+__all__ = [
+    "RealtimeServerEvent",
+    "ConversationItemRetrieved",
+    "OutputAudioBufferStarted",
+    "OutputAudioBufferStopped",
+    "OutputAudioBufferCleared",
+]
+
+
+class ConversationItemRetrieved(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    type: Literal["conversation.item.retrieved"]
+    """The event type, must be `conversation.item.retrieved`."""
+
+
+class OutputAudioBufferStarted(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response_id: str
+    """The unique ID of the response that produced the audio."""
+
+    type: Literal["output_audio_buffer.started"]
+    """The event type, must be `output_audio_buffer.started`."""
+
+
+class OutputAudioBufferStopped(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response_id: str
+    """The unique ID of the response that produced the audio."""
+
+    type: Literal["output_audio_buffer.stopped"]
+    """The event type, must be `output_audio_buffer.stopped`."""
+
+
+class OutputAudioBufferCleared(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response_id: str
+    """The unique ID of the response that produced the audio."""
+
+    type: Literal["output_audio_buffer.cleared"]
+    """The event type, must be `output_audio_buffer.cleared`."""
+
+
+RealtimeServerEvent: TypeAlias = Annotated[
+    Union[
+        ConversationCreatedEvent,
+        ConversationItemCreatedEvent,
+        ConversationItemDeletedEvent,
+        ConversationItemInputAudioTranscriptionCompletedEvent,
+        ConversationItemInputAudioTranscriptionDeltaEvent,
+        ConversationItemInputAudioTranscriptionFailedEvent,
+        ConversationItemRetrieved,
+        ConversationItemTruncatedEvent,
+        RealtimeErrorEvent,
+        InputAudioBufferClearedEvent,
+        InputAudioBufferCommittedEvent,
+        InputAudioBufferSpeechStartedEvent,
+        InputAudioBufferSpeechStoppedEvent,
+        RateLimitsUpdatedEvent,
+        ResponseAudioDeltaEvent,
+        ResponseAudioDoneEvent,
+        ResponseAudioTranscriptDeltaEvent,
+        ResponseAudioTranscriptDoneEvent,
+        ResponseContentPartAddedEvent,
+        ResponseContentPartDoneEvent,
+        ResponseCreatedEvent,
+        ResponseDoneEvent,
+        ResponseFunctionCallArgumentsDeltaEvent,
+        ResponseFunctionCallArgumentsDoneEvent,
+        ResponseOutputItemAddedEvent,
+        ResponseOutputItemDoneEvent,
+        ResponseTextDeltaEvent,
+        ResponseTextDoneEvent,
+        SessionCreatedEvent,
+        SessionUpdatedEvent,
+        OutputAudioBufferStarted,
+        OutputAudioBufferStopped,
+        OutputAudioBufferCleared,
+        ConversationItemAdded,
+        ConversationItemDone,
+        InputAudioBufferTimeoutTriggered,
+        ConversationItemInputAudioTranscriptionSegment,
+        McpListToolsInProgress,
+        McpListToolsCompleted,
+        McpListToolsFailed,
+        ResponseMcpCallArgumentsDelta,
+        ResponseMcpCallArgumentsDone,
+        ResponseMcpCallInProgress,
+        ResponseMcpCallCompleted,
+        ResponseMcpCallFailed,
+    ],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/realtime/realtime_session_client_secret.py b/src/openai/types/realtime/realtime_session_client_secret.py
new file mode 100644
index 0000000000..a4998802bb
--- /dev/null
+++ b/src/openai/types/realtime/realtime_session_client_secret.py
@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeSessionClientSecret"]
+
+
+class RealtimeSessionClientSecret(BaseModel):
+    expires_at: int
+    """Timestamp for when the token expires.
+
+    Currently, all tokens expire after one minute.
+    """
+
+    value: str
+    """
+    Ephemeral key usable in client environments to authenticate connections to the
+    Realtime API. Use this in client-side environments rather than a standard API
+    token, which should only be used server-side.
+    """
diff --git a/src/openai/types/realtime/realtime_session_create_request.py b/src/openai/types/realtime/realtime_session_create_request.py
new file mode 100644
index 0000000000..016ae45b67
--- /dev/null
+++ b/src/openai/types/realtime/realtime_session_create_request.py
@@ -0,0 +1,122 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_truncation import RealtimeTruncation
+from .realtime_audio_config import RealtimeAudioConfig
+from .realtime_tools_config import RealtimeToolsConfig
+from .realtime_tracing_config import RealtimeTracingConfig
+from ..responses.response_prompt import ResponsePrompt
+from .realtime_tool_choice_config import RealtimeToolChoiceConfig
+
+__all__ = ["RealtimeSessionCreateRequest"]
+
+
+class RealtimeSessionCreateRequest(BaseModel):
+    type: Literal["realtime"]
+    """The type of session to create. Always `realtime` for the Realtime API."""
+
+    audio: Optional[RealtimeAudioConfig] = None
+    """Configuration for input and output audio."""
+
+    include: Optional[List[Literal["item.input_audio_transcription.logprobs"]]] = None
+    """Additional fields to include in server outputs.
+
+    `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+    transcription.
+    """
+
+    instructions: Optional[str] = None
+    """The default system instructions (i.e.
+
+    system message) prepended to model calls. This field allows the client to guide
+    the model on desired responses. The model can be instructed on response content
+    and format, (e.g. "be extremely succinct", "act friendly", "here are examples of
+    good responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+    into your voice", "laugh frequently"). The instructions are not guaranteed to be
+    followed by the model, but they provide guidance to the model on the desired
+    behavior.
+
+    Note that the server sets default instructions which will be used if this field
+    is not set and are visible in the `session.created` event at the start of the
+    session.
+    """
+
+    max_output_tokens: Union[int, Literal["inf"], None] = None
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+    `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+    """
+
+    model: Union[
+        str,
+        Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
+            "gpt-4o-realtime-preview",
+            "gpt-4o-realtime-preview-2024-10-01",
+            "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
+            "gpt-4o-mini-realtime-preview",
+            "gpt-4o-mini-realtime-preview-2024-12-17",
+            "gpt-realtime-mini",
+            "gpt-realtime-mini-2025-10-06",
+            "gpt-audio-mini",
+            "gpt-audio-mini-2025-10-06",
+        ],
+        None,
+    ] = None
+    """The Realtime model used for this session."""
+
+    output_modalities: Optional[List[Literal["text", "audio"]]] = None
+    """The set of modalities the model can respond with.
+
+    It defaults to `["audio"]`, indicating that the model will respond with audio
+    plus a transcript. `["text"]` can be used to make the model respond with text
+    only. It is not possible to request both `text` and `audio` at the same time.
+    """
+
+    prompt: Optional[ResponsePrompt] = None
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    tool_choice: Optional[RealtimeToolChoiceConfig] = None
+    """How the model chooses tools.
+
+    Provide one of the string modes or force a specific function/MCP tool.
+    """
+
+    tools: Optional[RealtimeToolsConfig] = None
+    """Tools available to the model."""
+
+    tracing: Optional[RealtimeTracingConfig] = None
+    """
+    Realtime API can write session traces to the
+    [Traces Dashboard](/logs?api=traces). Set to null to disable tracing. Once
+    tracing is enabled for a session, the configuration cannot be modified.
+
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    truncation: Optional[RealtimeTruncation] = None
+    """
+    When the number of tokens in a conversation exceeds the model's input token
+    limit, the conversation be truncated, meaning messages (starting from the
+    oldest) will not be included in the model's context. A 32k context model with
+    4,096 max output tokens can only include 28,224 tokens in the context before
+    truncation occurs. Clients can configure truncation behavior to truncate with a
+    lower max token limit, which is an effective way to control token usage and
+    cost. Truncation will reduce the number of cached tokens on the next turn
+    (busting the cache), since messages are dropped from the beginning of the
+    context. However, clients can also configure truncation to retain messages up to
+    a fraction of the maximum context size, which will reduce the need for future
+    truncations and thus improve the cache rate. Truncation can be disabled
+    entirely, which means the server will never truncate but would instead return an
+    error if the conversation exceeds the model's input token limit.
+    """
diff --git a/src/openai/types/realtime/realtime_session_create_request_param.py b/src/openai/types/realtime/realtime_session_create_request_param.py
new file mode 100644
index 0000000000..8c3998c1ca
--- /dev/null
+++ b/src/openai/types/realtime/realtime_session_create_request_param.py
@@ -0,0 +1,122 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from .realtime_truncation_param import RealtimeTruncationParam
+from .realtime_audio_config_param import RealtimeAudioConfigParam
+from .realtime_tools_config_param import RealtimeToolsConfigParam
+from .realtime_tracing_config_param import RealtimeTracingConfigParam
+from ..responses.response_prompt_param import ResponsePromptParam
+from .realtime_tool_choice_config_param import RealtimeToolChoiceConfigParam
+
+__all__ = ["RealtimeSessionCreateRequestParam"]
+
+
+class RealtimeSessionCreateRequestParam(TypedDict, total=False):
+    type: Required[Literal["realtime"]]
+    """The type of session to create. Always `realtime` for the Realtime API."""
+
+    audio: RealtimeAudioConfigParam
+    """Configuration for input and output audio."""
+
+    include: List[Literal["item.input_audio_transcription.logprobs"]]
+    """Additional fields to include in server outputs.
+
+    `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+    transcription.
+    """
+
+    instructions: str
+    """The default system instructions (i.e.
+
+    system message) prepended to model calls. This field allows the client to guide
+    the model on desired responses. The model can be instructed on response content
+    and format, (e.g. "be extremely succinct", "act friendly", "here are examples of
+    good responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+    into your voice", "laugh frequently"). The instructions are not guaranteed to be
+    followed by the model, but they provide guidance to the model on the desired
+    behavior.
+
+    Note that the server sets default instructions which will be used if this field
+    is not set and are visible in the `session.created` event at the start of the
+    session.
+    """
+
+    max_output_tokens: Union[int, Literal["inf"]]
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+    `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+    """
+
+    model: Union[
+        str,
+        Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
+            "gpt-4o-realtime-preview",
+            "gpt-4o-realtime-preview-2024-10-01",
+            "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
+            "gpt-4o-mini-realtime-preview",
+            "gpt-4o-mini-realtime-preview-2024-12-17",
+            "gpt-realtime-mini",
+            "gpt-realtime-mini-2025-10-06",
+            "gpt-audio-mini",
+            "gpt-audio-mini-2025-10-06",
+        ],
+    ]
+    """The Realtime model used for this session."""
+
+    output_modalities: List[Literal["text", "audio"]]
+    """The set of modalities the model can respond with.
+
+    It defaults to `["audio"]`, indicating that the model will respond with audio
+    plus a transcript. `["text"]` can be used to make the model respond with text
+    only. It is not possible to request both `text` and `audio` at the same time.
+    """
+
+    prompt: Optional[ResponsePromptParam]
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    tool_choice: RealtimeToolChoiceConfigParam
+    """How the model chooses tools.
+
+    Provide one of the string modes or force a specific function/MCP tool.
+    """
+
+    tools: RealtimeToolsConfigParam
+    """Tools available to the model."""
+
+    tracing: Optional[RealtimeTracingConfigParam]
+    """
+    Realtime API can write session traces to the
+    [Traces Dashboard](/logs?api=traces). Set to null to disable tracing. Once
+    tracing is enabled for a session, the configuration cannot be modified.
+
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    truncation: RealtimeTruncationParam
+    """
+    When the number of tokens in a conversation exceeds the model's input token
+    limit, the conversation be truncated, meaning messages (starting from the
+    oldest) will not be included in the model's context. A 32k context model with
+    4,096 max output tokens can only include 28,224 tokens in the context before
+    truncation occurs. Clients can configure truncation behavior to truncate with a
+    lower max token limit, which is an effective way to control token usage and
+    cost. Truncation will reduce the number of cached tokens on the next turn
+    (busting the cache), since messages are dropped from the beginning of the
+    context. However, clients can also configure truncation to retain messages up to
+    a fraction of the maximum context size, which will reduce the need for future
+    truncations and thus improve the cache rate. Truncation can be disabled
+    entirely, which means the server will never truncate but would instead return an
+    error if the conversation exceeds the model's input token limit.
+    """
diff --git a/src/openai/types/realtime/realtime_session_create_response.py b/src/openai/types/realtime/realtime_session_create_response.py
new file mode 100644
index 0000000000..c1336cd6e4
--- /dev/null
+++ b/src/openai/types/realtime/realtime_session_create_response.py
@@ -0,0 +1,475 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .audio_transcription import AudioTranscription
+from .realtime_truncation import RealtimeTruncation
+from .noise_reduction_type import NoiseReductionType
+from .realtime_audio_formats import RealtimeAudioFormats
+from .realtime_function_tool import RealtimeFunctionTool
+from ..responses.response_prompt import ResponsePrompt
+from ..responses.tool_choice_mcp import ToolChoiceMcp
+from ..responses.tool_choice_options import ToolChoiceOptions
+from .realtime_session_client_secret import RealtimeSessionClientSecret
+from ..responses.tool_choice_function import ToolChoiceFunction
+
+__all__ = [
+    "RealtimeSessionCreateResponse",
+    "Audio",
+    "AudioInput",
+    "AudioInputNoiseReduction",
+    "AudioInputTurnDetection",
+    "AudioInputTurnDetectionServerVad",
+    "AudioInputTurnDetectionSemanticVad",
+    "AudioOutput",
+    "ToolChoice",
+    "Tool",
+    "ToolMcpTool",
+    "ToolMcpToolAllowedTools",
+    "ToolMcpToolAllowedToolsMcpToolFilter",
+    "ToolMcpToolRequireApproval",
+    "ToolMcpToolRequireApprovalMcpToolApprovalFilter",
+    "ToolMcpToolRequireApprovalMcpToolApprovalFilterAlways",
+    "ToolMcpToolRequireApprovalMcpToolApprovalFilterNever",
+    "Tracing",
+    "TracingTracingConfiguration",
+]
+
+
+class AudioInputNoiseReduction(BaseModel):
+    type: Optional[NoiseReductionType] = None
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class AudioInputTurnDetectionServerVad(BaseModel):
+    type: Literal["server_vad"]
+    """Type of turn detection, `server_vad` to turn on simple Server VAD."""
+
+    create_response: Optional[bool] = None
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    idle_timeout_ms: Optional[int] = None
+    """Optional timeout after which a model response will be triggered automatically.
+
+    This is useful for situations in which a long pause from the user is unexpected,
+    such as a phone call. The model will effectively prompt the user to continue the
+    conversation based on the current context.
+
+    The timeout value will be applied after the last model response's audio has
+    finished playing, i.e. it's set to the `response.done` time plus audio playback
+    duration.
+
+    An `input_audio_buffer.timeout_triggered` event (plus events associated with the
+    Response) will be emitted when the timeout is reached. Idle timeout is currently
+    only supported for `server_vad` mode.
+    """
+
+    interrupt_response: Optional[bool] = None
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+    prefix_padding_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: Optional[float] = None
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+
+class AudioInputTurnDetectionSemanticVad(BaseModel):
+    type: Literal["semantic_vad"]
+    """Type of turn detection, `semantic_vad` to turn on Semantic VAD."""
+
+    create_response: Optional[bool] = None
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    eagerness: Optional[Literal["low", "medium", "high", "auto"]] = None
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`. `low`, `medium`, and `high` have max timeouts of 8s,
+    4s, and 2s respectively.
+    """
+
+    interrupt_response: Optional[bool] = None
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+
+AudioInputTurnDetection: TypeAlias = Annotated[
+    Union[AudioInputTurnDetectionServerVad, AudioInputTurnDetectionSemanticVad, None],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class AudioInput(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The format of the input audio."""
+
+    noise_reduction: Optional[AudioInputNoiseReduction] = None
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    transcription: Optional[AudioTranscription] = None
+    """
+    Configuration for input audio transcription, defaults to off and can be set to
+    `null` to turn off once on. Input audio transcription is not native to the
+    model, since the model consumes audio directly. Transcription runs
+    asynchronously through
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
+    """
+
+    turn_detection: Optional[AudioInputTurnDetection] = None
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response.
+
+    Server VAD means that the model will detect the start and end of speech based on
+    audio volume and respond at the end of user speech.
+
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
+
+
+class AudioOutput(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The format of the output audio."""
+
+    speed: Optional[float] = None
+    """
+    The speed of the model's spoken response as a multiple of the original speed.
+    1.0 is the default speed. 0.25 is the minimum speed. 1.5 is the maximum speed.
+    This value can only be changed in between model turns, not while a response is
+    in progress.
+
+    This parameter is a post-processing adjustment to the audio after it is
+    generated, it's also possible to prompt the model to speak faster or slower.
+    """
+
+    voice: Union[
+        str, Literal["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"], None
+    ] = None
+    """The voice the model uses to respond.
+
+    Voice cannot be changed during the session once the model has responded with
+    audio at least once. Current voice options are `alloy`, `ash`, `ballad`,
+    `coral`, `echo`, `sage`, `shimmer`, `verse`, `marin`, and `cedar`. We recommend
+    `marin` and `cedar` for best quality.
+    """
+
+
+class Audio(BaseModel):
+    input: Optional[AudioInput] = None
+
+    output: Optional[AudioOutput] = None
+
+
+ToolChoice: TypeAlias = Union[ToolChoiceOptions, ToolChoiceFunction, ToolChoiceMcp]
+
+
+class ToolMcpToolAllowedToolsMcpToolFilter(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+ToolMcpToolAllowedTools: TypeAlias = Union[List[str], ToolMcpToolAllowedToolsMcpToolFilter, None]
+
+
+class ToolMcpToolRequireApprovalMcpToolApprovalFilterAlways(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class ToolMcpToolRequireApprovalMcpToolApprovalFilterNever(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class ToolMcpToolRequireApprovalMcpToolApprovalFilter(BaseModel):
+    always: Optional[ToolMcpToolRequireApprovalMcpToolApprovalFilterAlways] = None
+    """A filter object to specify which tools are allowed."""
+
+    never: Optional[ToolMcpToolRequireApprovalMcpToolApprovalFilterNever] = None
+    """A filter object to specify which tools are allowed."""
+
+
+ToolMcpToolRequireApproval: TypeAlias = Union[
+    ToolMcpToolRequireApprovalMcpToolApprovalFilter, Literal["always", "never"], None
+]
+
+
+class ToolMcpTool(BaseModel):
+    server_label: str
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Literal["mcp"]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[ToolMcpToolAllowedTools] = None
+    """List of allowed tool names or a filter object."""
+
+    authorization: Optional[str] = None
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Optional[
+        Literal[
+            "connector_dropbox",
+            "connector_gmail",
+            "connector_googlecalendar",
+            "connector_googledrive",
+            "connector_microsoftteams",
+            "connector_outlookcalendar",
+            "connector_outlookemail",
+            "connector_sharepoint",
+        ]
+    ] = None
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]] = None
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[ToolMcpToolRequireApproval] = None
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: Optional[str] = None
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: Optional[str] = None
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
+
+
+Tool: TypeAlias = Union[RealtimeFunctionTool, ToolMcpTool]
+
+
+class TracingTracingConfiguration(BaseModel):
+    group_id: Optional[str] = None
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    Traces Dashboard.
+    """
+
+    metadata: Optional[object] = None
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the Traces
+    Dashboard.
+    """
+
+    workflow_name: Optional[str] = None
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the Traces Dashboard.
+    """
+
+
+Tracing: TypeAlias = Union[Literal["auto"], TracingTracingConfiguration, None]
+
+
+class RealtimeSessionCreateResponse(BaseModel):
+    client_secret: RealtimeSessionClientSecret
+    """Ephemeral key returned by the API."""
+
+    type: Literal["realtime"]
+    """The type of session to create. Always `realtime` for the Realtime API."""
+
+    audio: Optional[Audio] = None
+    """Configuration for input and output audio."""
+
+    include: Optional[List[Literal["item.input_audio_transcription.logprobs"]]] = None
+    """Additional fields to include in server outputs.
+
+    `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+    transcription.
+    """
+
+    instructions: Optional[str] = None
+    """The default system instructions (i.e.
+
+    system message) prepended to model calls. This field allows the client to guide
+    the model on desired responses. The model can be instructed on response content
+    and format, (e.g. "be extremely succinct", "act friendly", "here are examples of
+    good responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+    into your voice", "laugh frequently"). The instructions are not guaranteed to be
+    followed by the model, but they provide guidance to the model on the desired
+    behavior.
+
+    Note that the server sets default instructions which will be used if this field
+    is not set and are visible in the `session.created` event at the start of the
+    session.
+    """
+
+    max_output_tokens: Union[int, Literal["inf"], None] = None
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+    `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+    """
+
+    model: Union[
+        str,
+        Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
+            "gpt-4o-realtime-preview",
+            "gpt-4o-realtime-preview-2024-10-01",
+            "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
+            "gpt-4o-mini-realtime-preview",
+            "gpt-4o-mini-realtime-preview-2024-12-17",
+            "gpt-realtime-mini",
+            "gpt-realtime-mini-2025-10-06",
+            "gpt-audio-mini",
+            "gpt-audio-mini-2025-10-06",
+        ],
+        None,
+    ] = None
+    """The Realtime model used for this session."""
+
+    output_modalities: Optional[List[Literal["text", "audio"]]] = None
+    """The set of modalities the model can respond with.
+
+    It defaults to `["audio"]`, indicating that the model will respond with audio
+    plus a transcript. `["text"]` can be used to make the model respond with text
+    only. It is not possible to request both `text` and `audio` at the same time.
+    """
+
+    prompt: Optional[ResponsePrompt] = None
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    tool_choice: Optional[ToolChoice] = None
+    """How the model chooses tools.
+
+    Provide one of the string modes or force a specific function/MCP tool.
+    """
+
+    tools: Optional[List[Tool]] = None
+    """Tools available to the model."""
+
+    tracing: Optional[Tracing] = None
+    """
+    Realtime API can write session traces to the
+    [Traces Dashboard](/logs?api=traces). Set to null to disable tracing. Once
+    tracing is enabled for a session, the configuration cannot be modified.
+
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    truncation: Optional[RealtimeTruncation] = None
+    """
+    When the number of tokens in a conversation exceeds the model's input token
+    limit, the conversation be truncated, meaning messages (starting from the
+    oldest) will not be included in the model's context. A 32k context model with
+    4,096 max output tokens can only include 28,224 tokens in the context before
+    truncation occurs. Clients can configure truncation behavior to truncate with a
+    lower max token limit, which is an effective way to control token usage and
+    cost. Truncation will reduce the number of cached tokens on the next turn
+    (busting the cache), since messages are dropped from the beginning of the
+    context. However, clients can also configure truncation to retain messages up to
+    a fraction of the maximum context size, which will reduce the need for future
+    truncations and thus improve the cache rate. Truncation can be disabled
+    entirely, which means the server will never truncate but would instead return an
+    error if the conversation exceeds the model's input token limit.
+    """
diff --git a/src/openai/types/realtime/realtime_tool_choice_config.py b/src/openai/types/realtime/realtime_tool_choice_config.py
new file mode 100644
index 0000000000..f93c490004
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tool_choice_config.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from ..responses.tool_choice_mcp import ToolChoiceMcp
+from ..responses.tool_choice_options import ToolChoiceOptions
+from ..responses.tool_choice_function import ToolChoiceFunction
+
+__all__ = ["RealtimeToolChoiceConfig"]
+
+RealtimeToolChoiceConfig: TypeAlias = Union[ToolChoiceOptions, ToolChoiceFunction, ToolChoiceMcp]
diff --git a/src/openai/types/realtime/realtime_tool_choice_config_param.py b/src/openai/types/realtime/realtime_tool_choice_config_param.py
new file mode 100644
index 0000000000..af92f243b0
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tool_choice_config_param.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from ..responses.tool_choice_options import ToolChoiceOptions
+from ..responses.tool_choice_mcp_param import ToolChoiceMcpParam
+from ..responses.tool_choice_function_param import ToolChoiceFunctionParam
+
+__all__ = ["RealtimeToolChoiceConfigParam"]
+
+RealtimeToolChoiceConfigParam: TypeAlias = Union[ToolChoiceOptions, ToolChoiceFunctionParam, ToolChoiceMcpParam]
diff --git a/src/openai/types/realtime/realtime_tools_config.py b/src/openai/types/realtime/realtime_tools_config.py
new file mode 100644
index 0000000000..b97599ab42
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tools_config.py
@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from .realtime_tools_config_union import RealtimeToolsConfigUnion
+
+__all__ = ["RealtimeToolsConfig"]
+
+RealtimeToolsConfig: TypeAlias = List[RealtimeToolsConfigUnion]
diff --git a/src/openai/types/realtime/realtime_tools_config_param.py b/src/openai/types/realtime/realtime_tools_config_param.py
new file mode 100644
index 0000000000..630fc74691
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tools_config_param.py
@@ -0,0 +1,143 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..._types import SequenceNotStr
+from .realtime_function_tool_param import RealtimeFunctionToolParam
+
+__all__ = [
+    "RealtimeToolsConfigParam",
+    "RealtimeToolsConfigUnionParam",
+    "Mcp",
+    "McpAllowedTools",
+    "McpAllowedToolsMcpToolFilter",
+    "McpRequireApproval",
+    "McpRequireApprovalMcpToolApprovalFilter",
+    "McpRequireApprovalMcpToolApprovalFilterAlways",
+    "McpRequireApprovalMcpToolApprovalFilterNever",
+]
+
+
+class McpAllowedToolsMcpToolFilter(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+McpAllowedTools: TypeAlias = Union[SequenceNotStr[str], McpAllowedToolsMcpToolFilter]
+
+
+class McpRequireApprovalMcpToolApprovalFilterAlways(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilterNever(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilter(TypedDict, total=False):
+    always: McpRequireApprovalMcpToolApprovalFilterAlways
+    """A filter object to specify which tools are allowed."""
+
+    never: McpRequireApprovalMcpToolApprovalFilterNever
+    """A filter object to specify which tools are allowed."""
+
+
+McpRequireApproval: TypeAlias = Union[McpRequireApprovalMcpToolApprovalFilter, Literal["always", "never"]]
+
+
+class Mcp(TypedDict, total=False):
+    server_label: Required[str]
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Required[Literal["mcp"]]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[McpAllowedTools]
+    """List of allowed tool names or a filter object."""
+
+    authorization: str
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Literal[
+        "connector_dropbox",
+        "connector_gmail",
+        "connector_googlecalendar",
+        "connector_googledrive",
+        "connector_microsoftteams",
+        "connector_outlookcalendar",
+        "connector_outlookemail",
+        "connector_sharepoint",
+    ]
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]]
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[McpRequireApproval]
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: str
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: str
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
+
+
+RealtimeToolsConfigUnionParam: TypeAlias = Union[RealtimeFunctionToolParam, Mcp]
+
+RealtimeToolsConfigParam: TypeAlias = List[RealtimeToolsConfigUnionParam]
diff --git a/src/openai/types/realtime/realtime_tools_config_union.py b/src/openai/types/realtime/realtime_tools_config_union.py
new file mode 100644
index 0000000000..e7126ed60d
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tools_config_union.py
@@ -0,0 +1,141 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .realtime_function_tool import RealtimeFunctionTool
+
+__all__ = [
+    "RealtimeToolsConfigUnion",
+    "Mcp",
+    "McpAllowedTools",
+    "McpAllowedToolsMcpToolFilter",
+    "McpRequireApproval",
+    "McpRequireApprovalMcpToolApprovalFilter",
+    "McpRequireApprovalMcpToolApprovalFilterAlways",
+    "McpRequireApprovalMcpToolApprovalFilterNever",
+]
+
+
+class McpAllowedToolsMcpToolFilter(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+McpAllowedTools: TypeAlias = Union[List[str], McpAllowedToolsMcpToolFilter, None]
+
+
+class McpRequireApprovalMcpToolApprovalFilterAlways(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilterNever(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilter(BaseModel):
+    always: Optional[McpRequireApprovalMcpToolApprovalFilterAlways] = None
+    """A filter object to specify which tools are allowed."""
+
+    never: Optional[McpRequireApprovalMcpToolApprovalFilterNever] = None
+    """A filter object to specify which tools are allowed."""
+
+
+McpRequireApproval: TypeAlias = Union[McpRequireApprovalMcpToolApprovalFilter, Literal["always", "never"], None]
+
+
+class Mcp(BaseModel):
+    server_label: str
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Literal["mcp"]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[McpAllowedTools] = None
+    """List of allowed tool names or a filter object."""
+
+    authorization: Optional[str] = None
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Optional[
+        Literal[
+            "connector_dropbox",
+            "connector_gmail",
+            "connector_googlecalendar",
+            "connector_googledrive",
+            "connector_microsoftteams",
+            "connector_outlookcalendar",
+            "connector_outlookemail",
+            "connector_sharepoint",
+        ]
+    ] = None
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]] = None
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[McpRequireApproval] = None
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: Optional[str] = None
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: Optional[str] = None
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
+
+
+RealtimeToolsConfigUnion: TypeAlias = Annotated[Union[RealtimeFunctionTool, Mcp], PropertyInfo(discriminator="type")]
diff --git a/src/openai/types/realtime/realtime_tools_config_union_param.py b/src/openai/types/realtime/realtime_tools_config_union_param.py
new file mode 100644
index 0000000000..9ee58fdbe6
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tools_config_union_param.py
@@ -0,0 +1,140 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from ..._types import SequenceNotStr
+from .realtime_function_tool_param import RealtimeFunctionToolParam
+
+__all__ = [
+    "RealtimeToolsConfigUnionParam",
+    "Mcp",
+    "McpAllowedTools",
+    "McpAllowedToolsMcpToolFilter",
+    "McpRequireApproval",
+    "McpRequireApprovalMcpToolApprovalFilter",
+    "McpRequireApprovalMcpToolApprovalFilterAlways",
+    "McpRequireApprovalMcpToolApprovalFilterNever",
+]
+
+
+class McpAllowedToolsMcpToolFilter(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+McpAllowedTools: TypeAlias = Union[SequenceNotStr[str], McpAllowedToolsMcpToolFilter]
+
+
+class McpRequireApprovalMcpToolApprovalFilterAlways(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilterNever(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilter(TypedDict, total=False):
+    always: McpRequireApprovalMcpToolApprovalFilterAlways
+    """A filter object to specify which tools are allowed."""
+
+    never: McpRequireApprovalMcpToolApprovalFilterNever
+    """A filter object to specify which tools are allowed."""
+
+
+McpRequireApproval: TypeAlias = Union[McpRequireApprovalMcpToolApprovalFilter, Literal["always", "never"]]
+
+
+class Mcp(TypedDict, total=False):
+    server_label: Required[str]
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Required[Literal["mcp"]]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[McpAllowedTools]
+    """List of allowed tool names or a filter object."""
+
+    authorization: str
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Literal[
+        "connector_dropbox",
+        "connector_gmail",
+        "connector_googlecalendar",
+        "connector_googledrive",
+        "connector_microsoftteams",
+        "connector_outlookcalendar",
+        "connector_outlookemail",
+        "connector_sharepoint",
+    ]
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]]
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[McpRequireApproval]
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: str
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: str
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
+
+
+RealtimeToolsConfigUnionParam: TypeAlias = Union[RealtimeFunctionToolParam, Mcp]
diff --git a/src/openai/types/realtime/realtime_tracing_config.py b/src/openai/types/realtime/realtime_tracing_config.py
new file mode 100644
index 0000000000..1c46de7928
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tracing_config.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeTracingConfig", "TracingConfiguration"]
+
+
+class TracingConfiguration(BaseModel):
+    group_id: Optional[str] = None
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    Traces Dashboard.
+    """
+
+    metadata: Optional[object] = None
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the Traces
+    Dashboard.
+    """
+
+    workflow_name: Optional[str] = None
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the Traces Dashboard.
+    """
+
+
+RealtimeTracingConfig: TypeAlias = Union[Literal["auto"], TracingConfiguration, None]
diff --git a/src/openai/types/realtime/realtime_tracing_config_param.py b/src/openai/types/realtime/realtime_tracing_config_param.py
new file mode 100644
index 0000000000..fd9e266244
--- /dev/null
+++ b/src/openai/types/realtime/realtime_tracing_config_param.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+__all__ = ["RealtimeTracingConfigParam", "TracingConfiguration"]
+
+
+class TracingConfiguration(TypedDict, total=False):
+    group_id: str
+    """
+    The group id to attach to this trace to enable filtering and grouping in the
+    Traces Dashboard.
+    """
+
+    metadata: object
+    """
+    The arbitrary metadata to attach to this trace to enable filtering in the Traces
+    Dashboard.
+    """
+
+    workflow_name: str
+    """The name of the workflow to attach to this trace.
+
+    This is used to name the trace in the Traces Dashboard.
+    """
+
+
+RealtimeTracingConfigParam: TypeAlias = Union[Literal["auto"], TracingConfiguration]
diff --git a/src/openai/types/realtime/realtime_transcription_session_audio.py b/src/openai/types/realtime/realtime_transcription_session_audio.py
new file mode 100644
index 0000000000..a5506947f1
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_audio.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .realtime_transcription_session_audio_input import RealtimeTranscriptionSessionAudioInput
+
+__all__ = ["RealtimeTranscriptionSessionAudio"]
+
+
+class RealtimeTranscriptionSessionAudio(BaseModel):
+    input: Optional[RealtimeTranscriptionSessionAudioInput] = None
diff --git a/src/openai/types/realtime/realtime_transcription_session_audio_input.py b/src/openai/types/realtime/realtime_transcription_session_audio_input.py
new file mode 100644
index 0000000000..efc321cbeb
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_audio_input.py
@@ -0,0 +1,65 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+from .audio_transcription import AudioTranscription
+from .noise_reduction_type import NoiseReductionType
+from .realtime_audio_formats import RealtimeAudioFormats
+from .realtime_transcription_session_audio_input_turn_detection import (
+    RealtimeTranscriptionSessionAudioInputTurnDetection,
+)
+
+__all__ = ["RealtimeTranscriptionSessionAudioInput", "NoiseReduction"]
+
+
+class NoiseReduction(BaseModel):
+    type: Optional[NoiseReductionType] = None
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class RealtimeTranscriptionSessionAudioInput(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The PCM audio format. Only a 24kHz sample rate is supported."""
+
+    noise_reduction: Optional[NoiseReduction] = None
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    transcription: Optional[AudioTranscription] = None
+    """
+    Configuration for input audio transcription, defaults to off and can be set to
+    `null` to turn off once on. Input audio transcription is not native to the
+    model, since the model consumes audio directly. Transcription runs
+    asynchronously through
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
+    """
+
+    turn_detection: Optional[RealtimeTranscriptionSessionAudioInputTurnDetection] = None
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response.
+
+    Server VAD means that the model will detect the start and end of speech based on
+    audio volume and respond at the end of user speech.
+
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
diff --git a/src/openai/types/realtime/realtime_transcription_session_audio_input_param.py b/src/openai/types/realtime/realtime_transcription_session_audio_input_param.py
new file mode 100644
index 0000000000..c9153b68a4
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_audio_input_param.py
@@ -0,0 +1,67 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+from .noise_reduction_type import NoiseReductionType
+from .audio_transcription_param import AudioTranscriptionParam
+from .realtime_audio_formats_param import RealtimeAudioFormatsParam
+from .realtime_transcription_session_audio_input_turn_detection_param import (
+    RealtimeTranscriptionSessionAudioInputTurnDetectionParam,
+)
+
+__all__ = ["RealtimeTranscriptionSessionAudioInputParam", "NoiseReduction"]
+
+
+class NoiseReduction(TypedDict, total=False):
+    type: NoiseReductionType
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class RealtimeTranscriptionSessionAudioInputParam(TypedDict, total=False):
+    format: RealtimeAudioFormatsParam
+    """The PCM audio format. Only a 24kHz sample rate is supported."""
+
+    noise_reduction: NoiseReduction
+    """Configuration for input audio noise reduction.
+
+    This can be set to `null` to turn off. Noise reduction filters audio added to
+    the input audio buffer before it is sent to VAD and the model. Filtering the
+    audio can improve VAD and turn detection accuracy (reducing false positives) and
+    model performance by improving perception of the input audio.
+    """
+
+    transcription: AudioTranscriptionParam
+    """
+    Configuration for input audio transcription, defaults to off and can be set to
+    `null` to turn off once on. Input audio transcription is not native to the
+    model, since the model consumes audio directly. Transcription runs
+    asynchronously through
+    [the /audio/transcriptions endpoint](https://platform.openai.com/docs/api-reference/audio/createTranscription)
+    and should be treated as guidance of input audio content rather than precisely
+    what the model heard. The client can optionally set the language and prompt for
+    transcription, these offer additional guidance to the transcription service.
+    """
+
+    turn_detection: Optional[RealtimeTranscriptionSessionAudioInputTurnDetectionParam]
+    """Configuration for turn detection, ether Server VAD or Semantic VAD.
+
+    This can be set to `null` to turn off, in which case the client must manually
+    trigger model response.
+
+    Server VAD means that the model will detect the start and end of speech based on
+    audio volume and respond at the end of user speech.
+
+    Semantic VAD is more advanced and uses a turn detection model (in conjunction
+    with VAD) to semantically estimate whether the user has finished speaking, then
+    dynamically sets a timeout based on this probability. For example, if user audio
+    trails off with "uhhm", the model will score a low probability of turn end and
+    wait longer for the user to continue speaking. This can be useful for more
+    natural conversations, but may have a higher latency.
+    """
diff --git a/src/openai/types/realtime/realtime_transcription_session_audio_input_turn_detection.py b/src/openai/types/realtime/realtime_transcription_session_audio_input_turn_detection.py
new file mode 100644
index 0000000000..7dc7a8f302
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_audio_input_turn_detection.py
@@ -0,0 +1,98 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = ["RealtimeTranscriptionSessionAudioInputTurnDetection", "ServerVad", "SemanticVad"]
+
+
+class ServerVad(BaseModel):
+    type: Literal["server_vad"]
+    """Type of turn detection, `server_vad` to turn on simple Server VAD."""
+
+    create_response: Optional[bool] = None
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    idle_timeout_ms: Optional[int] = None
+    """Optional timeout after which a model response will be triggered automatically.
+
+    This is useful for situations in which a long pause from the user is unexpected,
+    such as a phone call. The model will effectively prompt the user to continue the
+    conversation based on the current context.
+
+    The timeout value will be applied after the last model response's audio has
+    finished playing, i.e. it's set to the `response.done` time plus audio playback
+    duration.
+
+    An `input_audio_buffer.timeout_triggered` event (plus events associated with the
+    Response) will be emitted when the timeout is reached. Idle timeout is currently
+    only supported for `server_vad` mode.
+    """
+
+    interrupt_response: Optional[bool] = None
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+    prefix_padding_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: Optional[int] = None
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: Optional[float] = None
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+
+class SemanticVad(BaseModel):
+    type: Literal["semantic_vad"]
+    """Type of turn detection, `semantic_vad` to turn on Semantic VAD."""
+
+    create_response: Optional[bool] = None
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    eagerness: Optional[Literal["low", "medium", "high", "auto"]] = None
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`. `low`, `medium`, and `high` have max timeouts of 8s,
+    4s, and 2s respectively.
+    """
+
+    interrupt_response: Optional[bool] = None
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+
+RealtimeTranscriptionSessionAudioInputTurnDetection: TypeAlias = Annotated[
+    Union[ServerVad, SemanticVad, None], PropertyInfo(discriminator="type")
+]
diff --git a/src/openai/types/realtime/realtime_transcription_session_audio_input_turn_detection_param.py b/src/openai/types/realtime/realtime_transcription_session_audio_input_turn_detection_param.py
new file mode 100644
index 0000000000..d899b8c5c1
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_audio_input_turn_detection_param.py
@@ -0,0 +1,95 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["RealtimeTranscriptionSessionAudioInputTurnDetectionParam", "ServerVad", "SemanticVad"]
+
+
+class ServerVad(TypedDict, total=False):
+    type: Required[Literal["server_vad"]]
+    """Type of turn detection, `server_vad` to turn on simple Server VAD."""
+
+    create_response: bool
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    idle_timeout_ms: Optional[int]
+    """Optional timeout after which a model response will be triggered automatically.
+
+    This is useful for situations in which a long pause from the user is unexpected,
+    such as a phone call. The model will effectively prompt the user to continue the
+    conversation based on the current context.
+
+    The timeout value will be applied after the last model response's audio has
+    finished playing, i.e. it's set to the `response.done` time plus audio playback
+    duration.
+
+    An `input_audio_buffer.timeout_triggered` event (plus events associated with the
+    Response) will be emitted when the timeout is reached. Idle timeout is currently
+    only supported for `server_vad` mode.
+    """
+
+    interrupt_response: bool
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+    prefix_padding_ms: int
+    """Used only for `server_vad` mode.
+
+    Amount of audio to include before the VAD detected speech (in milliseconds).
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: int
+    """Used only for `server_vad` mode.
+
+    Duration of silence to detect speech stop (in milliseconds). Defaults to 500ms.
+    With shorter values the model will respond more quickly, but may jump in on
+    short pauses from the user.
+    """
+
+    threshold: float
+    """Used only for `server_vad` mode.
+
+    Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5. A higher
+    threshold will require louder audio to activate the model, and thus might
+    perform better in noisy environments.
+    """
+
+
+class SemanticVad(TypedDict, total=False):
+    type: Required[Literal["semantic_vad"]]
+    """Type of turn detection, `semantic_vad` to turn on Semantic VAD."""
+
+    create_response: bool
+    """
+    Whether or not to automatically generate a response when a VAD stop event
+    occurs.
+    """
+
+    eagerness: Literal["low", "medium", "high", "auto"]
+    """Used only for `semantic_vad` mode.
+
+    The eagerness of the model to respond. `low` will wait longer for the user to
+    continue speaking, `high` will respond more quickly. `auto` is the default and
+    is equivalent to `medium`. `low`, `medium`, and `high` have max timeouts of 8s,
+    4s, and 2s respectively.
+    """
+
+    interrupt_response: bool
+    """
+    Whether or not to automatically interrupt any ongoing response with output to
+    the default conversation (i.e. `conversation` of `auto`) when a VAD start event
+    occurs.
+    """
+
+
+RealtimeTranscriptionSessionAudioInputTurnDetectionParam: TypeAlias = Union[ServerVad, SemanticVad]
diff --git a/src/openai/types/realtime/realtime_transcription_session_audio_param.py b/src/openai/types/realtime/realtime_transcription_session_audio_param.py
new file mode 100644
index 0000000000..1503a606d3
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_audio_param.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+from .realtime_transcription_session_audio_input_param import RealtimeTranscriptionSessionAudioInputParam
+
+__all__ = ["RealtimeTranscriptionSessionAudioParam"]
+
+
+class RealtimeTranscriptionSessionAudioParam(TypedDict, total=False):
+    input: RealtimeTranscriptionSessionAudioInputParam
diff --git a/src/openai/types/realtime/realtime_transcription_session_create_request.py b/src/openai/types/realtime/realtime_transcription_session_create_request.py
new file mode 100644
index 0000000000..102f2b14fb
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_create_request.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_transcription_session_audio import RealtimeTranscriptionSessionAudio
+
+__all__ = ["RealtimeTranscriptionSessionCreateRequest"]
+
+
+class RealtimeTranscriptionSessionCreateRequest(BaseModel):
+    type: Literal["transcription"]
+    """The type of session to create.
+
+    Always `transcription` for transcription sessions.
+    """
+
+    audio: Optional[RealtimeTranscriptionSessionAudio] = None
+    """Configuration for input and output audio."""
+
+    include: Optional[List[Literal["item.input_audio_transcription.logprobs"]]] = None
+    """Additional fields to include in server outputs.
+
+    `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+    transcription.
+    """
diff --git a/src/openai/types/realtime/realtime_transcription_session_create_request_param.py b/src/openai/types/realtime/realtime_transcription_session_create_request_param.py
new file mode 100644
index 0000000000..80cbe2d414
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_create_request_param.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, Required, TypedDict
+
+from .realtime_transcription_session_audio_param import RealtimeTranscriptionSessionAudioParam
+
+__all__ = ["RealtimeTranscriptionSessionCreateRequestParam"]
+
+
+class RealtimeTranscriptionSessionCreateRequestParam(TypedDict, total=False):
+    type: Required[Literal["transcription"]]
+    """The type of session to create.
+
+    Always `transcription` for transcription sessions.
+    """
+
+    audio: RealtimeTranscriptionSessionAudioParam
+    """Configuration for input and output audio."""
+
+    include: List[Literal["item.input_audio_transcription.logprobs"]]
+    """Additional fields to include in server outputs.
+
+    `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+    transcription.
+    """
diff --git a/src/openai/types/realtime/realtime_transcription_session_create_response.py b/src/openai/types/realtime/realtime_transcription_session_create_response.py
new file mode 100644
index 0000000000..301af1ac3f
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_create_response.py
@@ -0,0 +1,68 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .audio_transcription import AudioTranscription
+from .noise_reduction_type import NoiseReductionType
+from .realtime_audio_formats import RealtimeAudioFormats
+from .realtime_transcription_session_turn_detection import RealtimeTranscriptionSessionTurnDetection
+
+__all__ = ["RealtimeTranscriptionSessionCreateResponse", "Audio", "AudioInput", "AudioInputNoiseReduction"]
+
+
+class AudioInputNoiseReduction(BaseModel):
+    type: Optional[NoiseReductionType] = None
+    """Type of noise reduction.
+
+    `near_field` is for close-talking microphones such as headphones, `far_field` is
+    for far-field microphones such as laptop or conference room microphones.
+    """
+
+
+class AudioInput(BaseModel):
+    format: Optional[RealtimeAudioFormats] = None
+    """The PCM audio format. Only a 24kHz sample rate is supported."""
+
+    noise_reduction: Optional[AudioInputNoiseReduction] = None
+    """Configuration for input audio noise reduction."""
+
+    transcription: Optional[AudioTranscription] = None
+    """Configuration of the transcription model."""
+
+    turn_detection: Optional[RealtimeTranscriptionSessionTurnDetection] = None
+    """Configuration for turn detection.
+
+    Can be set to `null` to turn off. Server VAD means that the model will detect
+    the start and end of speech based on audio volume and respond at the end of user
+    speech.
+    """
+
+
+class Audio(BaseModel):
+    input: Optional[AudioInput] = None
+
+
+class RealtimeTranscriptionSessionCreateResponse(BaseModel):
+    id: str
+    """Unique identifier for the session that looks like `sess_1234567890abcdef`."""
+
+    object: str
+    """The object type. Always `realtime.transcription_session`."""
+
+    type: Literal["transcription"]
+    """The type of session. Always `transcription` for transcription sessions."""
+
+    audio: Optional[Audio] = None
+    """Configuration for input audio for the session."""
+
+    expires_at: Optional[int] = None
+    """Expiration timestamp for the session, in seconds since epoch."""
+
+    include: Optional[List[Literal["item.input_audio_transcription.logprobs"]]] = None
+    """Additional fields to include in server outputs.
+
+    - `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+      transcription.
+    """
diff --git a/src/openai/types/realtime/realtime_transcription_session_turn_detection.py b/src/openai/types/realtime/realtime_transcription_session_turn_detection.py
new file mode 100644
index 0000000000..f5da31ce77
--- /dev/null
+++ b/src/openai/types/realtime/realtime_transcription_session_turn_detection.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeTranscriptionSessionTurnDetection"]
+
+
+class RealtimeTranscriptionSessionTurnDetection(BaseModel):
+    prefix_padding_ms: Optional[int] = None
+    """Amount of audio to include before the VAD detected speech (in milliseconds).
+
+    Defaults to 300ms.
+    """
+
+    silence_duration_ms: Optional[int] = None
+    """Duration of silence to detect speech stop (in milliseconds).
+
+    Defaults to 500ms. With shorter values the model will respond more quickly, but
+    may jump in on short pauses from the user.
+    """
+
+    threshold: Optional[float] = None
+    """Activation threshold for VAD (0.0 to 1.0), this defaults to 0.5.
+
+    A higher threshold will require louder audio to activate the model, and thus
+    might perform better in noisy environments.
+    """
+
+    type: Optional[str] = None
+    """Type of turn detection, only `server_vad` is currently supported."""
diff --git a/src/openai/types/realtime/realtime_truncation.py b/src/openai/types/realtime/realtime_truncation.py
new file mode 100644
index 0000000000..515f869071
--- /dev/null
+++ b/src/openai/types/realtime/realtime_truncation.py
@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from .realtime_truncation_retention_ratio import RealtimeTruncationRetentionRatio
+
+__all__ = ["RealtimeTruncation"]
+
+RealtimeTruncation: TypeAlias = Union[Literal["auto", "disabled"], RealtimeTruncationRetentionRatio]
diff --git a/src/openai/types/realtime/realtime_truncation_param.py b/src/openai/types/realtime/realtime_truncation_param.py
new file mode 100644
index 0000000000..5e42b27418
--- /dev/null
+++ b/src/openai/types/realtime/realtime_truncation_param.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from .realtime_truncation_retention_ratio_param import RealtimeTruncationRetentionRatioParam
+
+__all__ = ["RealtimeTruncationParam"]
+
+RealtimeTruncationParam: TypeAlias = Union[Literal["auto", "disabled"], RealtimeTruncationRetentionRatioParam]
diff --git a/src/openai/types/realtime/realtime_truncation_retention_ratio.py b/src/openai/types/realtime/realtime_truncation_retention_ratio.py
new file mode 100644
index 0000000000..e19ed64831
--- /dev/null
+++ b/src/openai/types/realtime/realtime_truncation_retention_ratio.py
@@ -0,0 +1,38 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeTruncationRetentionRatio", "TokenLimits"]
+
+
+class TokenLimits(BaseModel):
+    post_instructions: Optional[int] = None
+    """
+    Maximum tokens allowed in the conversation after instructions (which including
+    tool definitions). For example, setting this to 5,000 would mean that truncation
+    would occur when the conversation exceeds 5,000 tokens after instructions. This
+    cannot be higher than the model's context window size minus the maximum output
+    tokens.
+    """
+
+
+class RealtimeTruncationRetentionRatio(BaseModel):
+    retention_ratio: float
+    """
+    Fraction of post-instruction conversation tokens to retain (`0.0` - `1.0`) when
+    the conversation exceeds the input token limit. Setting this to `0.8` means that
+    messages will be dropped until 80% of the maximum allowed tokens are used. This
+    helps reduce the frequency of truncations and improve cache rates.
+    """
+
+    type: Literal["retention_ratio"]
+    """Use retention ratio truncation."""
+
+    token_limits: Optional[TokenLimits] = None
+    """Optional custom token limits for this truncation strategy.
+
+    If not provided, the model's default token limits will be used.
+    """
diff --git a/src/openai/types/realtime/realtime_truncation_retention_ratio_param.py b/src/openai/types/realtime/realtime_truncation_retention_ratio_param.py
new file mode 100644
index 0000000000..4ea80fe4ce
--- /dev/null
+++ b/src/openai/types/realtime/realtime_truncation_retention_ratio_param.py
@@ -0,0 +1,37 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["RealtimeTruncationRetentionRatioParam", "TokenLimits"]
+
+
+class TokenLimits(TypedDict, total=False):
+    post_instructions: int
+    """
+    Maximum tokens allowed in the conversation after instructions (which including
+    tool definitions). For example, setting this to 5,000 would mean that truncation
+    would occur when the conversation exceeds 5,000 tokens after instructions. This
+    cannot be higher than the model's context window size minus the maximum output
+    tokens.
+    """
+
+
+class RealtimeTruncationRetentionRatioParam(TypedDict, total=False):
+    retention_ratio: Required[float]
+    """
+    Fraction of post-instruction conversation tokens to retain (`0.0` - `1.0`) when
+    the conversation exceeds the input token limit. Setting this to `0.8` means that
+    messages will be dropped until 80% of the maximum allowed tokens are used. This
+    helps reduce the frequency of truncations and improve cache rates.
+    """
+
+    type: Required[Literal["retention_ratio"]]
+    """Use retention ratio truncation."""
+
+    token_limits: TokenLimits
+    """Optional custom token limits for this truncation strategy.
+
+    If not provided, the model's default token limits will be used.
+    """
diff --git a/src/openai/types/realtime/response_audio_delta_event.py b/src/openai/types/realtime/response_audio_delta_event.py
new file mode 100644
index 0000000000..d92c5462d0
--- /dev/null
+++ b/src/openai/types/realtime/response_audio_delta_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseAudioDeltaEvent"]
+
+
+class ResponseAudioDeltaEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    delta: str
+    """Base64-encoded audio data delta."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.output_audio.delta"]
+    """The event type, must be `response.output_audio.delta`."""
diff --git a/src/openai/types/realtime/response_audio_done_event.py b/src/openai/types/realtime/response_audio_done_event.py
new file mode 100644
index 0000000000..5ea0f07e36
--- /dev/null
+++ b/src/openai/types/realtime/response_audio_done_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseAudioDoneEvent"]
+
+
+class ResponseAudioDoneEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.output_audio.done"]
+    """The event type, must be `response.output_audio.done`."""
diff --git a/src/openai/types/realtime/response_audio_transcript_delta_event.py b/src/openai/types/realtime/response_audio_transcript_delta_event.py
new file mode 100644
index 0000000000..4dd5fecac0
--- /dev/null
+++ b/src/openai/types/realtime/response_audio_transcript_delta_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseAudioTranscriptDeltaEvent"]
+
+
+class ResponseAudioTranscriptDeltaEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    delta: str
+    """The transcript delta."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.output_audio_transcript.delta"]
+    """The event type, must be `response.output_audio_transcript.delta`."""
diff --git a/src/openai/types/realtime/response_audio_transcript_done_event.py b/src/openai/types/realtime/response_audio_transcript_done_event.py
new file mode 100644
index 0000000000..2de913d277
--- /dev/null
+++ b/src/openai/types/realtime/response_audio_transcript_done_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseAudioTranscriptDoneEvent"]
+
+
+class ResponseAudioTranscriptDoneEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    transcript: str
+    """The final transcript of the audio."""
+
+    type: Literal["response.output_audio_transcript.done"]
+    """The event type, must be `response.output_audio_transcript.done`."""
diff --git a/src/openai/types/realtime/response_cancel_event.py b/src/openai/types/realtime/response_cancel_event.py
new file mode 100644
index 0000000000..15dc141cbf
--- /dev/null
+++ b/src/openai/types/realtime/response_cancel_event.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseCancelEvent"]
+
+
+class ResponseCancelEvent(BaseModel):
+    type: Literal["response.cancel"]
+    """The event type, must be `response.cancel`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
+
+    response_id: Optional[str] = None
+    """
+    A specific response ID to cancel - if not provided, will cancel an in-progress
+    response in the default conversation.
+    """
diff --git a/src/openai/types/realtime/response_cancel_event_param.py b/src/openai/types/realtime/response_cancel_event_param.py
new file mode 100644
index 0000000000..f33740730a
--- /dev/null
+++ b/src/openai/types/realtime/response_cancel_event_param.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ResponseCancelEventParam"]
+
+
+class ResponseCancelEventParam(TypedDict, total=False):
+    type: Required[Literal["response.cancel"]]
+    """The event type, must be `response.cancel`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
+
+    response_id: str
+    """
+    A specific response ID to cancel - if not provided, will cancel an in-progress
+    response in the default conversation.
+    """
diff --git a/src/openai/types/realtime/response_content_part_added_event.py b/src/openai/types/realtime/response_content_part_added_event.py
new file mode 100644
index 0000000000..aca965c3d8
--- /dev/null
+++ b/src/openai/types/realtime/response_content_part_added_event.py
@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseContentPartAddedEvent", "Part"]
+
+
+class Part(BaseModel):
+    audio: Optional[str] = None
+    """Base64-encoded audio data (if type is "audio")."""
+
+    text: Optional[str] = None
+    """The text content (if type is "text")."""
+
+    transcript: Optional[str] = None
+    """The transcript of the audio (if type is "audio")."""
+
+    type: Optional[Literal["text", "audio"]] = None
+    """The content type ("text", "audio")."""
+
+
+class ResponseContentPartAddedEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item to which the content part was added."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    part: Part
+    """The content part that was added."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.content_part.added"]
+    """The event type, must be `response.content_part.added`."""
diff --git a/src/openai/types/realtime/response_content_part_done_event.py b/src/openai/types/realtime/response_content_part_done_event.py
new file mode 100644
index 0000000000..59af808a90
--- /dev/null
+++ b/src/openai/types/realtime/response_content_part_done_event.py
@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseContentPartDoneEvent", "Part"]
+
+
+class Part(BaseModel):
+    audio: Optional[str] = None
+    """Base64-encoded audio data (if type is "audio")."""
+
+    text: Optional[str] = None
+    """The text content (if type is "text")."""
+
+    transcript: Optional[str] = None
+    """The transcript of the audio (if type is "audio")."""
+
+    type: Optional[Literal["text", "audio"]] = None
+    """The content type ("text", "audio")."""
+
+
+class ResponseContentPartDoneEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    part: Part
+    """The content part that is done."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.content_part.done"]
+    """The event type, must be `response.content_part.done`."""
diff --git a/src/openai/types/realtime/response_create_event.py b/src/openai/types/realtime/response_create_event.py
new file mode 100644
index 0000000000..75a08ee460
--- /dev/null
+++ b/src/openai/types/realtime/response_create_event.py
@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_response_create_params import RealtimeResponseCreateParams
+
+__all__ = ["ResponseCreateEvent"]
+
+
+class ResponseCreateEvent(BaseModel):
+    type: Literal["response.create"]
+    """The event type, must be `response.create`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event."""
+
+    response: Optional[RealtimeResponseCreateParams] = None
+    """Create a new Realtime response with these parameters"""
diff --git a/src/openai/types/realtime/response_create_event_param.py b/src/openai/types/realtime/response_create_event_param.py
new file mode 100644
index 0000000000..e5dd46d9b6
--- /dev/null
+++ b/src/openai/types/realtime/response_create_event_param.py
@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .realtime_response_create_params_param import RealtimeResponseCreateParamsParam
+
+__all__ = ["ResponseCreateEventParam"]
+
+
+class ResponseCreateEventParam(TypedDict, total=False):
+    type: Required[Literal["response.create"]]
+    """The event type, must be `response.create`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event."""
+
+    response: RealtimeResponseCreateParamsParam
+    """Create a new Realtime response with these parameters"""
diff --git a/src/openai/types/realtime/response_created_event.py b/src/openai/types/realtime/response_created_event.py
new file mode 100644
index 0000000000..996bf26f75
--- /dev/null
+++ b/src/openai/types/realtime/response_created_event.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_response import RealtimeResponse
+
+__all__ = ["ResponseCreatedEvent"]
+
+
+class ResponseCreatedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response: RealtimeResponse
+    """The response resource."""
+
+    type: Literal["response.created"]
+    """The event type, must be `response.created`."""
diff --git a/src/openai/types/realtime/response_done_event.py b/src/openai/types/realtime/response_done_event.py
new file mode 100644
index 0000000000..ce9a4b9f1d
--- /dev/null
+++ b/src/openai/types/realtime/response_done_event.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .realtime_response import RealtimeResponse
+
+__all__ = ["ResponseDoneEvent"]
+
+
+class ResponseDoneEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    response: RealtimeResponse
+    """The response resource."""
+
+    type: Literal["response.done"]
+    """The event type, must be `response.done`."""
diff --git a/src/openai/types/realtime/response_function_call_arguments_delta_event.py b/src/openai/types/realtime/response_function_call_arguments_delta_event.py
new file mode 100644
index 0000000000..6d96e78b24
--- /dev/null
+++ b/src/openai/types/realtime/response_function_call_arguments_delta_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseFunctionCallArgumentsDeltaEvent"]
+
+
+class ResponseFunctionCallArgumentsDeltaEvent(BaseModel):
+    call_id: str
+    """The ID of the function call."""
+
+    delta: str
+    """The arguments delta as a JSON string."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the function call item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.function_call_arguments.delta"]
+    """The event type, must be `response.function_call_arguments.delta`."""
diff --git a/src/openai/types/realtime/response_function_call_arguments_done_event.py b/src/openai/types/realtime/response_function_call_arguments_done_event.py
new file mode 100644
index 0000000000..be7fae9a1b
--- /dev/null
+++ b/src/openai/types/realtime/response_function_call_arguments_done_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseFunctionCallArgumentsDoneEvent"]
+
+
+class ResponseFunctionCallArgumentsDoneEvent(BaseModel):
+    arguments: str
+    """The final arguments as a JSON string."""
+
+    call_id: str
+    """The ID of the function call."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the function call item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.function_call_arguments.done"]
+    """The event type, must be `response.function_call_arguments.done`."""
diff --git a/src/openai/types/realtime/response_mcp_call_arguments_delta.py b/src/openai/types/realtime/response_mcp_call_arguments_delta.py
new file mode 100644
index 0000000000..0a02a1a578
--- /dev/null
+++ b/src/openai/types/realtime/response_mcp_call_arguments_delta.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallArgumentsDelta"]
+
+
+class ResponseMcpCallArgumentsDelta(BaseModel):
+    delta: str
+    """The JSON-encoded arguments delta."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP tool call item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.mcp_call_arguments.delta"]
+    """The event type, must be `response.mcp_call_arguments.delta`."""
+
+    obfuscation: Optional[str] = None
+    """If present, indicates the delta text was obfuscated."""
diff --git a/src/openai/types/realtime/response_mcp_call_arguments_done.py b/src/openai/types/realtime/response_mcp_call_arguments_done.py
new file mode 100644
index 0000000000..5ec95f1728
--- /dev/null
+++ b/src/openai/types/realtime/response_mcp_call_arguments_done.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallArgumentsDone"]
+
+
+class ResponseMcpCallArgumentsDone(BaseModel):
+    arguments: str
+    """The final JSON-encoded arguments string."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP tool call item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.mcp_call_arguments.done"]
+    """The event type, must be `response.mcp_call_arguments.done`."""
diff --git a/src/openai/types/realtime/response_mcp_call_completed.py b/src/openai/types/realtime/response_mcp_call_completed.py
new file mode 100644
index 0000000000..e3fcec21f0
--- /dev/null
+++ b/src/openai/types/realtime/response_mcp_call_completed.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallCompleted"]
+
+
+class ResponseMcpCallCompleted(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP tool call item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    type: Literal["response.mcp_call.completed"]
+    """The event type, must be `response.mcp_call.completed`."""
diff --git a/src/openai/types/realtime/response_mcp_call_failed.py b/src/openai/types/realtime/response_mcp_call_failed.py
new file mode 100644
index 0000000000..b7adc8c2a7
--- /dev/null
+++ b/src/openai/types/realtime/response_mcp_call_failed.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallFailed"]
+
+
+class ResponseMcpCallFailed(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP tool call item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    type: Literal["response.mcp_call.failed"]
+    """The event type, must be `response.mcp_call.failed`."""
diff --git a/src/openai/types/realtime/response_mcp_call_in_progress.py b/src/openai/types/realtime/response_mcp_call_in_progress.py
new file mode 100644
index 0000000000..d0fcc7615c
--- /dev/null
+++ b/src/openai/types/realtime/response_mcp_call_in_progress.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallInProgress"]
+
+
+class ResponseMcpCallInProgress(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the MCP tool call item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    type: Literal["response.mcp_call.in_progress"]
+    """The event type, must be `response.mcp_call.in_progress`."""
diff --git a/src/openai/types/realtime/response_output_item_added_event.py b/src/openai/types/realtime/response_output_item_added_event.py
new file mode 100644
index 0000000000..509dfcaeaf
--- /dev/null
+++ b/src/openai/types/realtime/response_output_item_added_event.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ResponseOutputItemAddedEvent"]
+
+
+class ResponseOutputItemAddedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    output_index: int
+    """The index of the output item in the Response."""
+
+    response_id: str
+    """The ID of the Response to which the item belongs."""
+
+    type: Literal["response.output_item.added"]
+    """The event type, must be `response.output_item.added`."""
diff --git a/src/openai/types/realtime/response_output_item_done_event.py b/src/openai/types/realtime/response_output_item_done_event.py
new file mode 100644
index 0000000000..800e4ae8ee
--- /dev/null
+++ b/src/openai/types/realtime/response_output_item_done_event.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ResponseOutputItemDoneEvent"]
+
+
+class ResponseOutputItemDoneEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    output_index: int
+    """The index of the output item in the Response."""
+
+    response_id: str
+    """The ID of the Response to which the item belongs."""
+
+    type: Literal["response.output_item.done"]
+    """The event type, must be `response.output_item.done`."""
diff --git a/src/openai/types/realtime/response_text_delta_event.py b/src/openai/types/realtime/response_text_delta_event.py
new file mode 100644
index 0000000000..493348aa22
--- /dev/null
+++ b/src/openai/types/realtime/response_text_delta_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseTextDeltaEvent"]
+
+
+class ResponseTextDeltaEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    delta: str
+    """The text delta."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    type: Literal["response.output_text.delta"]
+    """The event type, must be `response.output_text.delta`."""
diff --git a/src/openai/types/realtime/response_text_done_event.py b/src/openai/types/realtime/response_text_done_event.py
new file mode 100644
index 0000000000..83c6cf0694
--- /dev/null
+++ b/src/openai/types/realtime/response_text_done_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseTextDoneEvent"]
+
+
+class ResponseTextDoneEvent(BaseModel):
+    content_index: int
+    """The index of the content part in the item's content array."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    item_id: str
+    """The ID of the item."""
+
+    output_index: int
+    """The index of the output item in the response."""
+
+    response_id: str
+    """The ID of the response."""
+
+    text: str
+    """The final text content."""
+
+    type: Literal["response.output_text.done"]
+    """The event type, must be `response.output_text.done`."""
diff --git a/src/openai/types/realtime/session_created_event.py b/src/openai/types/realtime/session_created_event.py
new file mode 100644
index 0000000000..b5caad35d7
--- /dev/null
+++ b/src/openai/types/realtime/session_created_event.py
@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from .realtime_session_create_request import RealtimeSessionCreateRequest
+from .realtime_transcription_session_create_request import RealtimeTranscriptionSessionCreateRequest
+
+__all__ = ["SessionCreatedEvent", "Session"]
+
+Session: TypeAlias = Union[RealtimeSessionCreateRequest, RealtimeTranscriptionSessionCreateRequest]
+
+
+class SessionCreatedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    session: Session
+    """The session configuration."""
+
+    type: Literal["session.created"]
+    """The event type, must be `session.created`."""
diff --git a/src/openai/types/realtime/session_update_event.py b/src/openai/types/realtime/session_update_event.py
new file mode 100644
index 0000000000..2e226162c4
--- /dev/null
+++ b/src/openai/types/realtime/session_update_event.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from .realtime_session_create_request import RealtimeSessionCreateRequest
+from .realtime_transcription_session_create_request import RealtimeTranscriptionSessionCreateRequest
+
+__all__ = ["SessionUpdateEvent", "Session"]
+
+Session: TypeAlias = Union[RealtimeSessionCreateRequest, RealtimeTranscriptionSessionCreateRequest]
+
+
+class SessionUpdateEvent(BaseModel):
+    session: Session
+    """Update the Realtime session.
+
+    Choose either a realtime session or a transcription session.
+    """
+
+    type: Literal["session.update"]
+    """The event type, must be `session.update`."""
+
+    event_id: Optional[str] = None
+    """Optional client-generated ID used to identify this event.
+
+    This is an arbitrary string that a client may assign. It will be passed back if
+    there is an error with the event, but the corresponding `session.updated` event
+    will not include it.
+    """
diff --git a/src/openai/types/realtime/session_update_event_param.py b/src/openai/types/realtime/session_update_event_param.py
new file mode 100644
index 0000000000..5962361431
--- /dev/null
+++ b/src/openai/types/realtime/session_update_event_param.py
@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .realtime_session_create_request_param import RealtimeSessionCreateRequestParam
+from .realtime_transcription_session_create_request_param import RealtimeTranscriptionSessionCreateRequestParam
+
+__all__ = ["SessionUpdateEventParam", "Session"]
+
+Session: TypeAlias = Union[RealtimeSessionCreateRequestParam, RealtimeTranscriptionSessionCreateRequestParam]
+
+
+class SessionUpdateEventParam(TypedDict, total=False):
+    session: Required[Session]
+    """Update the Realtime session.
+
+    Choose either a realtime session or a transcription session.
+    """
+
+    type: Required[Literal["session.update"]]
+    """The event type, must be `session.update`."""
+
+    event_id: str
+    """Optional client-generated ID used to identify this event.
+
+    This is an arbitrary string that a client may assign. It will be passed back if
+    there is an error with the event, but the corresponding `session.updated` event
+    will not include it.
+    """
diff --git a/src/openai/types/realtime/session_updated_event.py b/src/openai/types/realtime/session_updated_event.py
new file mode 100644
index 0000000000..eb7ee0332d
--- /dev/null
+++ b/src/openai/types/realtime/session_updated_event.py
@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from .realtime_session_create_request import RealtimeSessionCreateRequest
+from .realtime_transcription_session_create_request import RealtimeTranscriptionSessionCreateRequest
+
+__all__ = ["SessionUpdatedEvent", "Session"]
+
+Session: TypeAlias = Union[RealtimeSessionCreateRequest, RealtimeTranscriptionSessionCreateRequest]
+
+
+class SessionUpdatedEvent(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    session: Session
+    """The session configuration."""
+
+    type: Literal["session.updated"]
+    """The event type, must be `session.updated`."""
diff --git a/src/openai/types/responses/__init__.py b/src/openai/types/responses/__init__.py
index 7c0cf9e3f2..e707141d9a 100644
--- a/src/openai/types/responses/__init__.py
+++ b/src/openai/types/responses/__init__.py
@@ -5,8 +5,10 @@
 from .tool import Tool as Tool
 from .response import Response as Response
 from .tool_param import ToolParam as ToolParam
+from .custom_tool import CustomTool as CustomTool
 from .computer_tool import ComputerTool as ComputerTool
 from .function_tool import FunctionTool as FunctionTool
+from .response_item import ResponseItem as ResponseItem
 from .response_error import ResponseError as ResponseError
 from .response_usage import ResponseUsage as ResponseUsage
 from .parsed_response import (
@@ -17,18 +19,29 @@
     ParsedResponseOutputMessage as ParsedResponseOutputMessage,
     ParsedResponseFunctionToolCall as ParsedResponseFunctionToolCall,
 )
+from .response_prompt import ResponsePrompt as ResponsePrompt
 from .response_status import ResponseStatus as ResponseStatus
+from .tool_choice_mcp import ToolChoiceMcp as ToolChoiceMcp
 from .web_search_tool import WebSearchTool as WebSearchTool
+from .apply_patch_tool import ApplyPatchTool as ApplyPatchTool
 from .file_search_tool import FileSearchTool as FileSearchTool
+from .custom_tool_param import CustomToolParam as CustomToolParam
+from .tool_choice_shell import ToolChoiceShell as ToolChoiceShell
 from .tool_choice_types import ToolChoiceTypes as ToolChoiceTypes
+from .easy_input_message import EasyInputMessage as EasyInputMessage
 from .response_item_list import ResponseItemList as ResponseItemList
+from .tool_choice_custom import ToolChoiceCustom as ToolChoiceCustom
 from .computer_tool_param import ComputerToolParam as ComputerToolParam
+from .function_shell_tool import FunctionShellTool as FunctionShellTool
 from .function_tool_param import FunctionToolParam as FunctionToolParam
 from .response_includable import ResponseIncludable as ResponseIncludable
 from .response_input_file import ResponseInputFile as ResponseInputFile
+from .response_input_item import ResponseInputItem as ResponseInputItem
 from .response_input_text import ResponseInputText as ResponseInputText
+from .tool_choice_allowed import ToolChoiceAllowed as ToolChoiceAllowed
 from .tool_choice_options import ToolChoiceOptions as ToolChoiceOptions
 from .response_error_event import ResponseErrorEvent as ResponseErrorEvent
+from .response_input_audio import ResponseInputAudio as ResponseInputAudio
 from .response_input_image import ResponseInputImage as ResponseInputImage
 from .response_input_param import ResponseInputParam as ResponseInputParam
 from .response_output_item import ResponseOutputItem as ResponseOutputItem
@@ -36,8 +49,12 @@
 from .response_text_config import ResponseTextConfig as ResponseTextConfig
 from .tool_choice_function import ToolChoiceFunction as ToolChoiceFunction
 from .response_failed_event import ResponseFailedEvent as ResponseFailedEvent
+from .response_prompt_param import ResponsePromptParam as ResponsePromptParam
+from .response_queued_event import ResponseQueuedEvent as ResponseQueuedEvent
 from .response_stream_event import ResponseStreamEvent as ResponseStreamEvent
+from .tool_choice_mcp_param import ToolChoiceMcpParam as ToolChoiceMcpParam
 from .web_search_tool_param import WebSearchToolParam as WebSearchToolParam
+from .apply_patch_tool_param import ApplyPatchToolParam as ApplyPatchToolParam
 from .file_search_tool_param import FileSearchToolParam as FileSearchToolParam
 from .input_item_list_params import InputItemListParams as InputItemListParams
 from .response_create_params import ResponseCreateParams as ResponseCreateParams
@@ -46,83 +63,190 @@
 from .response_output_message import ResponseOutputMessage as ResponseOutputMessage
 from .response_output_refusal import ResponseOutputRefusal as ResponseOutputRefusal
 from .response_reasoning_item import ResponseReasoningItem as ResponseReasoningItem
+from .tool_choice_apply_patch import ToolChoiceApplyPatch as ToolChoiceApplyPatch
+from .tool_choice_shell_param import ToolChoiceShellParam as ToolChoiceShellParam
 from .tool_choice_types_param import ToolChoiceTypesParam as ToolChoiceTypesParam
+from .web_search_preview_tool import WebSearchPreviewTool as WebSearchPreviewTool
 from .easy_input_message_param import EasyInputMessageParam as EasyInputMessageParam
+from .input_token_count_params import InputTokenCountParams as InputTokenCountParams
 from .response_completed_event import ResponseCompletedEvent as ResponseCompletedEvent
 from .response_retrieve_params import ResponseRetrieveParams as ResponseRetrieveParams
 from .response_text_done_event import ResponseTextDoneEvent as ResponseTextDoneEvent
+from .tool_choice_custom_param import ToolChoiceCustomParam as ToolChoiceCustomParam
+from .function_shell_tool_param import FunctionShellToolParam as FunctionShellToolParam
 from .response_audio_done_event import ResponseAudioDoneEvent as ResponseAudioDoneEvent
+from .response_custom_tool_call import ResponseCustomToolCall as ResponseCustomToolCall
 from .response_incomplete_event import ResponseIncompleteEvent as ResponseIncompleteEvent
 from .response_input_file_param import ResponseInputFileParam as ResponseInputFileParam
 from .response_input_item_param import ResponseInputItemParam as ResponseInputItemParam
 from .response_input_text_param import ResponseInputTextParam as ResponseInputTextParam
 from .response_text_delta_event import ResponseTextDeltaEvent as ResponseTextDeltaEvent
+from .tool_choice_allowed_param import ToolChoiceAllowedParam as ToolChoiceAllowedParam
+from .input_token_count_response import InputTokenCountResponse as InputTokenCountResponse
 from .response_audio_delta_event import ResponseAudioDeltaEvent as ResponseAudioDeltaEvent
 from .response_in_progress_event import ResponseInProgressEvent as ResponseInProgressEvent
+from .response_input_audio_param import ResponseInputAudioParam as ResponseInputAudioParam
 from .response_input_image_param import ResponseInputImageParam as ResponseInputImageParam
 from .response_output_text_param import ResponseOutputTextParam as ResponseOutputTextParam
 from .response_text_config_param import ResponseTextConfigParam as ResponseTextConfigParam
 from .tool_choice_function_param import ToolChoiceFunctionParam as ToolChoiceFunctionParam
 from .response_computer_tool_call import ResponseComputerToolCall as ResponseComputerToolCall
+from .response_conversation_param import ResponseConversationParam as ResponseConversationParam
 from .response_format_text_config import ResponseFormatTextConfig as ResponseFormatTextConfig
 from .response_function_tool_call import ResponseFunctionToolCall as ResponseFunctionToolCall
+from .response_input_file_content import ResponseInputFileContent as ResponseInputFileContent
+from .response_input_message_item import ResponseInputMessageItem as ResponseInputMessageItem
+from .response_input_text_content import ResponseInputTextContent as ResponseInputTextContent
 from .response_refusal_done_event import ResponseRefusalDoneEvent as ResponseRefusalDoneEvent
 from .response_function_web_search import ResponseFunctionWebSearch as ResponseFunctionWebSearch
 from .response_input_content_param import ResponseInputContentParam as ResponseInputContentParam
+from .response_input_image_content import ResponseInputImageContent as ResponseInputImageContent
 from .response_refusal_delta_event import ResponseRefusalDeltaEvent as ResponseRefusalDeltaEvent
 from .response_output_message_param import ResponseOutputMessageParam as ResponseOutputMessageParam
 from .response_output_refusal_param import ResponseOutputRefusalParam as ResponseOutputRefusalParam
 from .response_reasoning_item_param import ResponseReasoningItemParam as ResponseReasoningItemParam
+from .tool_choice_apply_patch_param import ToolChoiceApplyPatchParam as ToolChoiceApplyPatchParam
+from .web_search_preview_tool_param import WebSearchPreviewToolParam as WebSearchPreviewToolParam
+from .response_apply_patch_tool_call import ResponseApplyPatchToolCall as ResponseApplyPatchToolCall
 from .response_file_search_tool_call import ResponseFileSearchToolCall as ResponseFileSearchToolCall
+from .response_mcp_call_failed_event import ResponseMcpCallFailedEvent as ResponseMcpCallFailedEvent
+from .response_custom_tool_call_param import ResponseCustomToolCallParam as ResponseCustomToolCallParam
 from .response_output_item_done_event import ResponseOutputItemDoneEvent as ResponseOutputItemDoneEvent
 from .response_content_part_done_event import ResponseContentPartDoneEvent as ResponseContentPartDoneEvent
+from .response_custom_tool_call_output import ResponseCustomToolCallOutput as ResponseCustomToolCallOutput
+from .response_function_tool_call_item import ResponseFunctionToolCallItem as ResponseFunctionToolCallItem
 from .response_output_item_added_event import ResponseOutputItemAddedEvent as ResponseOutputItemAddedEvent
 from .response_computer_tool_call_param import ResponseComputerToolCallParam as ResponseComputerToolCallParam
 from .response_content_part_added_event import ResponseContentPartAddedEvent as ResponseContentPartAddedEvent
 from .response_format_text_config_param import ResponseFormatTextConfigParam as ResponseFormatTextConfigParam
+from .response_function_shell_tool_call import ResponseFunctionShellToolCall as ResponseFunctionShellToolCall
 from .response_function_tool_call_param import ResponseFunctionToolCallParam as ResponseFunctionToolCallParam
+from .response_input_file_content_param import ResponseInputFileContentParam as ResponseInputFileContentParam
+from .response_input_text_content_param import ResponseInputTextContentParam as ResponseInputTextContentParam
+from .response_mcp_call_completed_event import ResponseMcpCallCompletedEvent as ResponseMcpCallCompletedEvent
+from .response_function_call_output_item import ResponseFunctionCallOutputItem as ResponseFunctionCallOutputItem
 from .response_function_web_search_param import ResponseFunctionWebSearchParam as ResponseFunctionWebSearchParam
+from .response_input_image_content_param import ResponseInputImageContentParam as ResponseInputImageContentParam
+from .response_reasoning_text_done_event import ResponseReasoningTextDoneEvent as ResponseReasoningTextDoneEvent
 from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall as ResponseCodeInterpreterToolCall
 from .response_input_message_content_list import ResponseInputMessageContentList as ResponseInputMessageContentList
+from .response_mcp_call_in_progress_event import ResponseMcpCallInProgressEvent as ResponseMcpCallInProgressEvent
+from .response_reasoning_text_delta_event import ResponseReasoningTextDeltaEvent as ResponseReasoningTextDeltaEvent
 from .response_audio_transcript_done_event import ResponseAudioTranscriptDoneEvent as ResponseAudioTranscriptDoneEvent
 from .response_file_search_tool_call_param import ResponseFileSearchToolCallParam as ResponseFileSearchToolCallParam
-from .response_text_annotation_delta_event import ResponseTextAnnotationDeltaEvent as ResponseTextAnnotationDeltaEvent
+from .response_mcp_list_tools_failed_event import ResponseMcpListToolsFailedEvent as ResponseMcpListToolsFailedEvent
+from .response_apply_patch_tool_call_output import ResponseApplyPatchToolCallOutput as ResponseApplyPatchToolCallOutput
 from .response_audio_transcript_delta_event import (
     ResponseAudioTranscriptDeltaEvent as ResponseAudioTranscriptDeltaEvent,
 )
+from .response_custom_tool_call_output_param import (
+    ResponseCustomToolCallOutputParam as ResponseCustomToolCallOutputParam,
+)
+from .response_mcp_call_arguments_done_event import (
+    ResponseMcpCallArgumentsDoneEvent as ResponseMcpCallArgumentsDoneEvent,
+)
+from .response_computer_tool_call_output_item import (
+    ResponseComputerToolCallOutputItem as ResponseComputerToolCallOutputItem,
+)
 from .response_format_text_json_schema_config import (
     ResponseFormatTextJSONSchemaConfig as ResponseFormatTextJSONSchemaConfig,
 )
+from .response_function_call_output_item_list import (
+    ResponseFunctionCallOutputItemList as ResponseFunctionCallOutputItemList,
+)
+from .response_function_tool_call_output_item import (
+    ResponseFunctionToolCallOutputItem as ResponseFunctionToolCallOutputItem,
+)
+from .response_image_gen_call_completed_event import (
+    ResponseImageGenCallCompletedEvent as ResponseImageGenCallCompletedEvent,
+)
+from .response_mcp_call_arguments_delta_event import (
+    ResponseMcpCallArgumentsDeltaEvent as ResponseMcpCallArgumentsDeltaEvent,
+)
+from .response_mcp_list_tools_completed_event import (
+    ResponseMcpListToolsCompletedEvent as ResponseMcpListToolsCompletedEvent,
+)
+from .response_function_call_output_item_param import (
+    ResponseFunctionCallOutputItemParam as ResponseFunctionCallOutputItemParam,
+)
+from .response_function_shell_tool_call_output import (
+    ResponseFunctionShellToolCallOutput as ResponseFunctionShellToolCallOutput,
+)
+from .response_image_gen_call_generating_event import (
+    ResponseImageGenCallGeneratingEvent as ResponseImageGenCallGeneratingEvent,
+)
 from .response_web_search_call_completed_event import (
     ResponseWebSearchCallCompletedEvent as ResponseWebSearchCallCompletedEvent,
 )
 from .response_web_search_call_searching_event import (
     ResponseWebSearchCallSearchingEvent as ResponseWebSearchCallSearchingEvent,
 )
+from .response_code_interpreter_tool_call_param import (
+    ResponseCodeInterpreterToolCallParam as ResponseCodeInterpreterToolCallParam,
+)
 from .response_file_search_call_completed_event import (
     ResponseFileSearchCallCompletedEvent as ResponseFileSearchCallCompletedEvent,
 )
 from .response_file_search_call_searching_event import (
     ResponseFileSearchCallSearchingEvent as ResponseFileSearchCallSearchingEvent,
 )
+from .response_image_gen_call_in_progress_event import (
+    ResponseImageGenCallInProgressEvent as ResponseImageGenCallInProgressEvent,
+)
 from .response_input_message_content_list_param import (
     ResponseInputMessageContentListParam as ResponseInputMessageContentListParam,
 )
+from .response_mcp_list_tools_in_progress_event import (
+    ResponseMcpListToolsInProgressEvent as ResponseMcpListToolsInProgressEvent,
+)
+from .response_custom_tool_call_input_done_event import (
+    ResponseCustomToolCallInputDoneEvent as ResponseCustomToolCallInputDoneEvent,
+)
+from .response_reasoning_summary_part_done_event import (
+    ResponseReasoningSummaryPartDoneEvent as ResponseReasoningSummaryPartDoneEvent,
+)
+from .response_reasoning_summary_text_done_event import (
+    ResponseReasoningSummaryTextDoneEvent as ResponseReasoningSummaryTextDoneEvent,
+)
 from .response_web_search_call_in_progress_event import (
     ResponseWebSearchCallInProgressEvent as ResponseWebSearchCallInProgressEvent,
 )
+from .response_custom_tool_call_input_delta_event import (
+    ResponseCustomToolCallInputDeltaEvent as ResponseCustomToolCallInputDeltaEvent,
+)
 from .response_file_search_call_in_progress_event import (
     ResponseFileSearchCallInProgressEvent as ResponseFileSearchCallInProgressEvent,
 )
 from .response_function_call_arguments_done_event import (
     ResponseFunctionCallArgumentsDoneEvent as ResponseFunctionCallArgumentsDoneEvent,
 )
+from .response_function_shell_call_output_content import (
+    ResponseFunctionShellCallOutputContent as ResponseFunctionShellCallOutputContent,
+)
+from .response_image_gen_call_partial_image_event import (
+    ResponseImageGenCallPartialImageEvent as ResponseImageGenCallPartialImageEvent,
+)
+from .response_output_text_annotation_added_event import (
+    ResponseOutputTextAnnotationAddedEvent as ResponseOutputTextAnnotationAddedEvent,
+)
+from .response_reasoning_summary_part_added_event import (
+    ResponseReasoningSummaryPartAddedEvent as ResponseReasoningSummaryPartAddedEvent,
+)
+from .response_reasoning_summary_text_delta_event import (
+    ResponseReasoningSummaryTextDeltaEvent as ResponseReasoningSummaryTextDeltaEvent,
+)
 from .response_function_call_arguments_delta_event import (
     ResponseFunctionCallArgumentsDeltaEvent as ResponseFunctionCallArgumentsDeltaEvent,
 )
+from .response_computer_tool_call_output_screenshot import (
+    ResponseComputerToolCallOutputScreenshot as ResponseComputerToolCallOutputScreenshot,
+)
 from .response_format_text_json_schema_config_param import (
     ResponseFormatTextJSONSchemaConfigParam as ResponseFormatTextJSONSchemaConfigParam,
 )
+from .response_function_call_output_item_list_param import (
+    ResponseFunctionCallOutputItemListParam as ResponseFunctionCallOutputItemListParam,
+)
 from .response_code_interpreter_call_code_done_event import (
     ResponseCodeInterpreterCallCodeDoneEvent as ResponseCodeInterpreterCallCodeDoneEvent,
 )
@@ -138,3 +262,9 @@
 from .response_code_interpreter_call_interpreting_event import (
     ResponseCodeInterpreterCallInterpretingEvent as ResponseCodeInterpreterCallInterpretingEvent,
 )
+from .response_function_shell_call_output_content_param import (
+    ResponseFunctionShellCallOutputContentParam as ResponseFunctionShellCallOutputContentParam,
+)
+from .response_computer_tool_call_output_screenshot_param import (
+    ResponseComputerToolCallOutputScreenshotParam as ResponseComputerToolCallOutputScreenshotParam,
+)
diff --git a/src/openai/types/responses/apply_patch_tool.py b/src/openai/types/responses/apply_patch_tool.py
new file mode 100644
index 0000000000..07706ce239
--- /dev/null
+++ b/src/openai/types/responses/apply_patch_tool.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ApplyPatchTool"]
+
+
+class ApplyPatchTool(BaseModel):
+    type: Literal["apply_patch"]
+    """The type of the tool. Always `apply_patch`."""
diff --git a/src/openai/types/responses/apply_patch_tool_param.py b/src/openai/types/responses/apply_patch_tool_param.py
new file mode 100644
index 0000000000..93d15f0b1f
--- /dev/null
+++ b/src/openai/types/responses/apply_patch_tool_param.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ApplyPatchToolParam"]
+
+
+class ApplyPatchToolParam(TypedDict, total=False):
+    type: Required[Literal["apply_patch"]]
+    """The type of the tool. Always `apply_patch`."""
diff --git a/src/openai/types/responses/computer_tool.py b/src/openai/types/responses/computer_tool.py
index dffb7af7b7..5b844f5bf4 100644
--- a/src/openai/types/responses/computer_tool.py
+++ b/src/openai/types/responses/computer_tool.py
@@ -8,13 +8,13 @@
 
 
 class ComputerTool(BaseModel):
-    display_height: float
+    display_height: int
     """The height of the computer display."""
 
-    display_width: float
+    display_width: int
     """The width of the computer display."""
 
-    environment: Literal["mac", "windows", "ubuntu", "browser"]
+    environment: Literal["windows", "mac", "linux", "ubuntu", "browser"]
     """The type of computer environment to control."""
 
     type: Literal["computer_use_preview"]
diff --git a/src/openai/types/responses/computer_tool_param.py b/src/openai/types/responses/computer_tool_param.py
index 6b1072ffd2..06a5c132ec 100644
--- a/src/openai/types/responses/computer_tool_param.py
+++ b/src/openai/types/responses/computer_tool_param.py
@@ -8,13 +8,13 @@
 
 
 class ComputerToolParam(TypedDict, total=False):
-    display_height: Required[float]
+    display_height: Required[int]
     """The height of the computer display."""
 
-    display_width: Required[float]
+    display_width: Required[int]
     """The width of the computer display."""
 
-    environment: Required[Literal["mac", "windows", "ubuntu", "browser"]]
+    environment: Required[Literal["windows", "mac", "linux", "ubuntu", "browser"]]
     """The type of computer environment to control."""
 
     type: Required[Literal["computer_use_preview"]]
diff --git a/src/openai/types/responses/custom_tool.py b/src/openai/types/responses/custom_tool.py
new file mode 100644
index 0000000000..c16ae715eb
--- /dev/null
+++ b/src/openai/types/responses/custom_tool.py
@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..shared.custom_tool_input_format import CustomToolInputFormat
+
+__all__ = ["CustomTool"]
+
+
+class CustomTool(BaseModel):
+    name: str
+    """The name of the custom tool, used to identify it in tool calls."""
+
+    type: Literal["custom"]
+    """The type of the custom tool. Always `custom`."""
+
+    description: Optional[str] = None
+    """Optional description of the custom tool, used to provide more context."""
+
+    format: Optional[CustomToolInputFormat] = None
+    """The input format for the custom tool. Default is unconstrained text."""
diff --git a/src/openai/types/responses/custom_tool_param.py b/src/openai/types/responses/custom_tool_param.py
new file mode 100644
index 0000000000..2afc8b19b8
--- /dev/null
+++ b/src/openai/types/responses/custom_tool_param.py
@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from ..shared_params.custom_tool_input_format import CustomToolInputFormat
+
+__all__ = ["CustomToolParam"]
+
+
+class CustomToolParam(TypedDict, total=False):
+    name: Required[str]
+    """The name of the custom tool, used to identify it in tool calls."""
+
+    type: Required[Literal["custom"]]
+    """The type of the custom tool. Always `custom`."""
+
+    description: str
+    """Optional description of the custom tool, used to provide more context."""
+
+    format: CustomToolInputFormat
+    """The input format for the custom tool. Default is unconstrained text."""
diff --git a/src/openai/types/responses/easy_input_message.py b/src/openai/types/responses/easy_input_message.py
new file mode 100644
index 0000000000..4ed0194f9f
--- /dev/null
+++ b/src/openai/types/responses/easy_input_message.py
@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .response_input_message_content_list import ResponseInputMessageContentList
+
+__all__ = ["EasyInputMessage"]
+
+
+class EasyInputMessage(BaseModel):
+    content: Union[str, ResponseInputMessageContentList]
+    """
+    Text, image, or audio input to the model, used to generate a response. Can also
+    contain previous assistant responses.
+    """
+
+    role: Literal["user", "assistant", "system", "developer"]
+    """The role of the message input.
+
+    One of `user`, `assistant`, `system`, or `developer`.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always `message`."""
diff --git a/src/openai/types/responses/file_search_tool.py b/src/openai/types/responses/file_search_tool.py
index 683fc533fe..d0d08a323f 100644
--- a/src/openai/types/responses/file_search_tool.py
+++ b/src/openai/types/responses/file_search_tool.py
@@ -7,20 +7,34 @@
 from ..shared.compound_filter import CompoundFilter
 from ..shared.comparison_filter import ComparisonFilter
 
-__all__ = ["FileSearchTool", "Filters", "RankingOptions"]
+__all__ = ["FileSearchTool", "Filters", "RankingOptions", "RankingOptionsHybridSearch"]
 
-Filters: TypeAlias = Union[ComparisonFilter, CompoundFilter]
+Filters: TypeAlias = Union[ComparisonFilter, CompoundFilter, None]
+
+
+class RankingOptionsHybridSearch(BaseModel):
+    embedding_weight: float
+    """The weight of the embedding in the reciprocal ranking fusion."""
+
+    text_weight: float
+    """The weight of the text in the reciprocal ranking fusion."""
 
 
 class RankingOptions(BaseModel):
+    hybrid_search: Optional[RankingOptionsHybridSearch] = None
+    """
+    Weights that control how reciprocal rank fusion balances semantic embedding
+    matches versus sparse keyword matches when hybrid search is enabled.
+    """
+
     ranker: Optional[Literal["auto", "default-2024-11-15"]] = None
     """The ranker to use for the file search."""
 
     score_threshold: Optional[float] = None
-    """
-    The score threshold for the file search, a number between 0 and 1. Numbers
-    closer to 1 will attempt to return only the most relevant results, but may
-    return fewer results.
+    """The score threshold for the file search, a number between 0 and 1.
+
+    Numbers closer to 1 will attempt to return only the most relevant results, but
+    may return fewer results.
     """
 
 
@@ -32,7 +46,7 @@ class FileSearchTool(BaseModel):
     """The IDs of the vector stores to search."""
 
     filters: Optional[Filters] = None
-    """A filter to apply based on file attributes."""
+    """A filter to apply."""
 
     max_num_results: Optional[int] = None
     """The maximum number of results to return.
diff --git a/src/openai/types/responses/file_search_tool_param.py b/src/openai/types/responses/file_search_tool_param.py
index 2d6af8536b..b37a669ebd 100644
--- a/src/openai/types/responses/file_search_tool_param.py
+++ b/src/openai/types/responses/file_search_tool_param.py
@@ -2,26 +2,41 @@
 
 from __future__ import annotations
 
-from typing import List, Union
+from typing import Union, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from ..shared_params.compound_filter import CompoundFilter
 from ..shared_params.comparison_filter import ComparisonFilter
 
-__all__ = ["FileSearchToolParam", "Filters", "RankingOptions"]
+__all__ = ["FileSearchToolParam", "Filters", "RankingOptions", "RankingOptionsHybridSearch"]
 
 Filters: TypeAlias = Union[ComparisonFilter, CompoundFilter]
 
 
+class RankingOptionsHybridSearch(TypedDict, total=False):
+    embedding_weight: Required[float]
+    """The weight of the embedding in the reciprocal ranking fusion."""
+
+    text_weight: Required[float]
+    """The weight of the text in the reciprocal ranking fusion."""
+
+
 class RankingOptions(TypedDict, total=False):
+    hybrid_search: RankingOptionsHybridSearch
+    """
+    Weights that control how reciprocal rank fusion balances semantic embedding
+    matches versus sparse keyword matches when hybrid search is enabled.
+    """
+
     ranker: Literal["auto", "default-2024-11-15"]
     """The ranker to use for the file search."""
 
     score_threshold: float
-    """
-    The score threshold for the file search, a number between 0 and 1. Numbers
-    closer to 1 will attempt to return only the most relevant results, but may
-    return fewer results.
+    """The score threshold for the file search, a number between 0 and 1.
+
+    Numbers closer to 1 will attempt to return only the most relevant results, but
+    may return fewer results.
     """
 
 
@@ -29,11 +44,11 @@ class FileSearchToolParam(TypedDict, total=False):
     type: Required[Literal["file_search"]]
     """The type of the file search tool. Always `file_search`."""
 
-    vector_store_ids: Required[List[str]]
+    vector_store_ids: Required[SequenceNotStr[str]]
     """The IDs of the vector stores to search."""
 
-    filters: Filters
-    """A filter to apply based on file attributes."""
+    filters: Optional[Filters]
+    """A filter to apply."""
 
     max_num_results: int
     """The maximum number of results to return.
diff --git a/src/openai/types/responses/function_shell_tool.py b/src/openai/types/responses/function_shell_tool.py
new file mode 100644
index 0000000000..1784b6c2f1
--- /dev/null
+++ b/src/openai/types/responses/function_shell_tool.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["FunctionShellTool"]
+
+
+class FunctionShellTool(BaseModel):
+    type: Literal["shell"]
+    """The type of the shell tool. Always `shell`."""
diff --git a/src/openai/types/responses/function_shell_tool_param.py b/src/openai/types/responses/function_shell_tool_param.py
new file mode 100644
index 0000000000..cee7ba23c9
--- /dev/null
+++ b/src/openai/types/responses/function_shell_tool_param.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["FunctionShellToolParam"]
+
+
+class FunctionShellToolParam(TypedDict, total=False):
+    type: Required[Literal["shell"]]
+    """The type of the shell tool. Always `shell`."""
diff --git a/src/openai/types/responses/function_tool.py b/src/openai/types/responses/function_tool.py
index 236a2c7c63..d881565356 100644
--- a/src/openai/types/responses/function_tool.py
+++ b/src/openai/types/responses/function_tool.py
@@ -12,10 +12,10 @@ class FunctionTool(BaseModel):
     name: str
     """The name of the function to call."""
 
-    parameters: Dict[str, object]
+    parameters: Optional[Dict[str, object]] = None
     """A JSON schema object describing the parameters of the function."""
 
-    strict: bool
+    strict: Optional[bool] = None
     """Whether to enforce strict parameter validation. Default `true`."""
 
     type: Literal["function"]
diff --git a/src/openai/types/responses/function_tool_param.py b/src/openai/types/responses/function_tool_param.py
index 774a22e336..56bab36f47 100644
--- a/src/openai/types/responses/function_tool_param.py
+++ b/src/openai/types/responses/function_tool_param.py
@@ -12,10 +12,10 @@ class FunctionToolParam(TypedDict, total=False):
     name: Required[str]
     """The name of the function to call."""
 
-    parameters: Required[Dict[str, object]]
+    parameters: Required[Optional[Dict[str, object]]]
     """A JSON schema object describing the parameters of the function."""
 
-    strict: Required[bool]
+    strict: Required[Optional[bool]]
     """Whether to enforce strict parameter validation. Default `true`."""
 
     type: Required[Literal["function"]]
diff --git a/src/openai/types/responses/input_item_list_params.py b/src/openai/types/responses/input_item_list_params.py
index e0b71f1ac5..44a8dc5de3 100644
--- a/src/openai/types/responses/input_item_list_params.py
+++ b/src/openai/types/responses/input_item_list_params.py
@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+from typing import List
 from typing_extensions import Literal, TypedDict
 
+from .response_includable import ResponseIncludable
+
 __all__ = ["InputItemListParams"]
 
 
@@ -11,8 +14,11 @@ class InputItemListParams(TypedDict, total=False):
     after: str
     """An item ID to list items after, used in pagination."""
 
-    before: str
-    """An item ID to list items before, used in pagination."""
+    include: List[ResponseIncludable]
+    """Additional fields to include in the response.
+
+    See the `include` parameter for Response creation above for more information.
+    """
 
     limit: int
     """A limit on the number of objects to be returned.
@@ -21,7 +27,7 @@ class InputItemListParams(TypedDict, total=False):
     """
 
     order: Literal["asc", "desc"]
-    """The order to return the input items in. Default is `asc`.
+    """The order to return the input items in. Default is `desc`.
 
     - `asc`: Return the input items in ascending order.
     - `desc`: Return the input items in descending order.
diff --git a/src/openai/types/responses/input_token_count_params.py b/src/openai/types/responses/input_token_count_params.py
new file mode 100644
index 0000000000..296d0718d8
--- /dev/null
+++ b/src/openai/types/responses/input_token_count_params.py
@@ -0,0 +1,142 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable, Optional
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+from .tool_param import ToolParam
+from .tool_choice_options import ToolChoiceOptions
+from .tool_choice_mcp_param import ToolChoiceMcpParam
+from .tool_choice_shell_param import ToolChoiceShellParam
+from .tool_choice_types_param import ToolChoiceTypesParam
+from ..shared_params.reasoning import Reasoning
+from .tool_choice_custom_param import ToolChoiceCustomParam
+from .response_input_item_param import ResponseInputItemParam
+from .tool_choice_allowed_param import ToolChoiceAllowedParam
+from .tool_choice_function_param import ToolChoiceFunctionParam
+from .response_conversation_param import ResponseConversationParam
+from .tool_choice_apply_patch_param import ToolChoiceApplyPatchParam
+from .response_format_text_config_param import ResponseFormatTextConfigParam
+
+__all__ = ["InputTokenCountParams", "Conversation", "Text", "ToolChoice"]
+
+
+class InputTokenCountParams(TypedDict, total=False):
+    conversation: Optional[Conversation]
+    """The conversation that this response belongs to.
+
+    Items from this conversation are prepended to `input_items` for this response
+    request. Input items and output items from this response are automatically added
+    to this conversation after this response completes.
+    """
+
+    input: Union[str, Iterable[ResponseInputItemParam], None]
+    """Text, image, or file inputs to the model, used to generate a response"""
+
+    instructions: Optional[str]
+    """
+    A system (or developer) message inserted into the model's context. When used
+    along with `previous_response_id`, the instructions from a previous response
+    will not be carried over to the next response. This makes it simple to swap out
+    system (or developer) messages in new responses.
+    """
+
+    model: Optional[str]
+    """Model ID used to generate the response, like `gpt-4o` or `o3`.
+
+    OpenAI offers a wide range of models with different capabilities, performance
+    characteristics, and price points. Refer to the
+    [model guide](https://platform.openai.com/docs/models) to browse and compare
+    available models.
+    """
+
+    parallel_tool_calls: Optional[bool]
+    """Whether to allow the model to run tool calls in parallel."""
+
+    previous_response_id: Optional[str]
+    """The unique ID of the previous response to the model.
+
+    Use this to create multi-turn conversations. Learn more about
+    [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+    Cannot be used in conjunction with `conversation`.
+    """
+
+    reasoning: Optional[Reasoning]
+    """
+    **gpt-5 and o-series models only** Configuration options for
+    [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+    """
+
+    text: Optional[Text]
+    """Configuration options for a text response from the model.
+
+    Can be plain text or structured JSON data. Learn more:
+
+    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+    - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+    """
+
+    tool_choice: Optional[ToolChoice]
+    """
+    How the model should select which tool (or tools) to use when generating a
+    response. See the `tools` parameter to see how to specify which tools the model
+    can call.
+    """
+
+    tools: Optional[Iterable[ToolParam]]
+    """An array of tools the model may call while generating a response.
+
+    You can specify which tool to use by setting the `tool_choice` parameter.
+    """
+
+    truncation: Literal["auto", "disabled"]
+    """The truncation strategy to use for the model response.
+
+    - `auto`: If the input to this Response exceeds the model's context window size,
+      the model will truncate the response to fit the context window by dropping
+      items from the beginning of the conversation. - `disabled` (default): If the
+      input size will exceed the context window size for a model, the request will
+      fail with a 400 error.
+    """
+
+
+Conversation: TypeAlias = Union[str, ResponseConversationParam]
+
+
+class Text(TypedDict, total=False):
+    format: ResponseFormatTextConfigParam
+    """An object specifying the format that the model must output.
+
+    Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+    ensures the model will match your supplied JSON schema. Learn more in the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+
+    The default format is `{ "type": "text" }` with no additional options.
+
+    **Not recommended for gpt-4o and newer models:**
+
+    Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+    ensures the message the model generates is valid JSON. Using `json_schema` is
+    preferred for models that support it.
+    """
+
+    verbosity: Optional[Literal["low", "medium", "high"]]
+    """Constrains the verbosity of the model's response.
+
+    Lower values will result in more concise responses, while higher values will
+    result in more verbose responses. Currently supported values are `low`,
+    `medium`, and `high`.
+    """
+
+
+ToolChoice: TypeAlias = Union[
+    ToolChoiceOptions,
+    ToolChoiceAllowedParam,
+    ToolChoiceTypesParam,
+    ToolChoiceFunctionParam,
+    ToolChoiceMcpParam,
+    ToolChoiceCustomParam,
+    ToolChoiceApplyPatchParam,
+    ToolChoiceShellParam,
+]
diff --git a/src/openai/types/responses/input_token_count_response.py b/src/openai/types/responses/input_token_count_response.py
new file mode 100644
index 0000000000..30ddfc1217
--- /dev/null
+++ b/src/openai/types/responses/input_token_count_response.py
@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["InputTokenCountResponse"]
+
+
+class InputTokenCountResponse(BaseModel):
+    input_tokens: int
+
+    object: Literal["response.input_tokens"]
diff --git a/src/openai/types/responses/parsed_response.py b/src/openai/types/responses/parsed_response.py
index 1263dfd648..c120f4641d 100644
--- a/src/openai/types/responses/parsed_response.py
+++ b/src/openai/types/responses/parsed_response.py
@@ -7,14 +7,28 @@
 from .response import Response
 from ..._models import GenericModel
 from ..._utils._transform import PropertyInfo
+from .response_output_item import (
+    McpCall,
+    McpListTools,
+    LocalShellCall,
+    McpApprovalRequest,
+    ImageGenerationCall,
+    LocalShellCallAction,
+)
 from .response_output_text import ResponseOutputText
 from .response_output_message import ResponseOutputMessage
 from .response_output_refusal import ResponseOutputRefusal
 from .response_reasoning_item import ResponseReasoningItem
+from .response_custom_tool_call import ResponseCustomToolCall
 from .response_computer_tool_call import ResponseComputerToolCall
 from .response_function_tool_call import ResponseFunctionToolCall
 from .response_function_web_search import ResponseFunctionWebSearch
+from .response_apply_patch_tool_call import ResponseApplyPatchToolCall
 from .response_file_search_tool_call import ResponseFileSearchToolCall
+from .response_function_shell_tool_call import ResponseFunctionShellToolCall
+from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
+from .response_apply_patch_tool_call_output import ResponseApplyPatchToolCallOutput
+from .response_function_shell_tool_call_output import ResponseFunctionShellToolCallOutput
 
 __all__ = ["ParsedResponse", "ParsedResponseOutputMessage", "ParsedResponseOutputText"]
 
@@ -46,6 +60,8 @@ class ParsedResponseOutputMessage(ResponseOutputMessage, GenericModel, Generic[C
 class ParsedResponseFunctionToolCall(ResponseFunctionToolCall):
     parsed_arguments: object = None
 
+    __api_exclude__ = {"parsed_arguments"}
+
 
 ParsedResponseOutputItem: TypeAlias = Annotated[
     Union[
@@ -55,6 +71,18 @@ class ParsedResponseFunctionToolCall(ResponseFunctionToolCall):
         ResponseFunctionWebSearch,
         ResponseComputerToolCall,
         ResponseReasoningItem,
+        McpCall,
+        McpApprovalRequest,
+        ImageGenerationCall,
+        LocalShellCall,
+        LocalShellCallAction,
+        McpListTools,
+        ResponseCodeInterpreterToolCall,
+        ResponseCustomToolCall,
+        ResponseFunctionShellToolCall,
+        ResponseFunctionShellToolCallOutput,
+        ResponseApplyPatchToolCall,
+        ResponseApplyPatchToolCallOutput,
     ],
     PropertyInfo(discriminator="type"),
 ]
diff --git a/src/openai/types/responses/response.py b/src/openai/types/responses/response.py
index 66887ae9b5..cdd143f1cb 100644
--- a/src/openai/types/responses/response.py
+++ b/src/openai/types/responses/response.py
@@ -7,17 +7,24 @@
 from ..._models import BaseModel
 from .response_error import ResponseError
 from .response_usage import ResponseUsage
+from .response_prompt import ResponsePrompt
 from .response_status import ResponseStatus
+from .tool_choice_mcp import ToolChoiceMcp
 from ..shared.metadata import Metadata
 from ..shared.reasoning import Reasoning
+from .tool_choice_shell import ToolChoiceShell
 from .tool_choice_types import ToolChoiceTypes
-from ..shared.chat_model import ChatModel
+from .tool_choice_custom import ToolChoiceCustom
+from .response_input_item import ResponseInputItem
+from .tool_choice_allowed import ToolChoiceAllowed
 from .tool_choice_options import ToolChoiceOptions
 from .response_output_item import ResponseOutputItem
 from .response_text_config import ResponseTextConfig
 from .tool_choice_function import ToolChoiceFunction
+from ..shared.responses_model import ResponsesModel
+from .tool_choice_apply_patch import ToolChoiceApplyPatch
 
-__all__ = ["Response", "IncompleteDetails", "ToolChoice"]
+__all__ = ["Response", "IncompleteDetails", "ToolChoice", "Conversation"]
 
 
 class IncompleteDetails(BaseModel):
@@ -25,7 +32,21 @@ class IncompleteDetails(BaseModel):
     """The reason why the response is incomplete."""
 
 
-ToolChoice: TypeAlias = Union[ToolChoiceOptions, ToolChoiceTypes, ToolChoiceFunction]
+ToolChoice: TypeAlias = Union[
+    ToolChoiceOptions,
+    ToolChoiceAllowed,
+    ToolChoiceTypes,
+    ToolChoiceFunction,
+    ToolChoiceMcp,
+    ToolChoiceCustom,
+    ToolChoiceApplyPatch,
+    ToolChoiceShell,
+]
+
+
+class Conversation(BaseModel):
+    id: str
+    """The unique ID of the conversation."""
 
 
 class Response(BaseModel):
@@ -41,14 +62,12 @@ class Response(BaseModel):
     incomplete_details: Optional[IncompleteDetails] = None
     """Details about why the response is incomplete."""
 
-    instructions: Optional[str] = None
-    """
-    Inserts a system (or developer) message as the first item in the model's
-    context.
+    instructions: Union[str, List[ResponseInputItem], None] = None
+    """A system (or developer) message inserted into the model's context.
 
     When using along with `previous_response_id`, the instructions from a previous
-    response will be not be carried over to the next response. This makes it simple
-    to swap out system (or developer) messages in new responses.
+    response will not be carried over to the next response. This makes it simple to
+    swap out system (or developer) messages in new responses.
     """
 
     metadata: Optional[Metadata] = None
@@ -61,8 +80,8 @@ class Response(BaseModel):
     a maximum length of 512 characters.
     """
 
-    model: Union[str, ChatModel]
-    """Model ID used to generate the response, like `gpt-4o` or `o1`.
+    model: ResponsesModel
+    """Model ID used to generate the response, like `gpt-4o` or `o3`.
 
     OpenAI offers a wide range of models with different capabilities, performance
     characteristics, and price points. Refer to the
@@ -106,7 +125,7 @@ class Response(BaseModel):
 
     You can specify which tool to use by setting the `tool_choice` parameter.
 
-    The two categories of tools you can provide the model are:
+    We support the following categories of tools:
 
     - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
       capabilities, like
@@ -114,9 +133,14 @@ class Response(BaseModel):
       [file search](https://platform.openai.com/docs/guides/tools-file-search).
       Learn more about
       [built-in tools](https://platform.openai.com/docs/guides/tools).
+    - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+      predefined connectors such as Google Drive and SharePoint. Learn more about
+      [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
     - **Function calls (custom tools)**: Functions that are defined by you, enabling
-      the model to call your own code. Learn more about
+      the model to call your own code with strongly typed arguments and outputs.
+      Learn more about
       [function calling](https://platform.openai.com/docs/guides/function-calling).
+      You can also use custom tools to call your own code.
     """
 
     top_p: Optional[float] = None
@@ -128,6 +152,19 @@ class Response(BaseModel):
     We generally recommend altering this or `temperature` but not both.
     """
 
+    background: Optional[bool] = None
+    """
+    Whether to run the model response in the background.
+    [Learn more](https://platform.openai.com/docs/guides/background).
+    """
+
+    conversation: Optional[Conversation] = None
+    """The conversation that this response belongs to.
+
+    Input items and output items from this response are automatically added to this
+    conversation.
+    """
+
     max_output_tokens: Optional[int] = None
     """
     An upper bound for the number of tokens that can be generated for a response,
@@ -135,24 +172,83 @@ class Response(BaseModel):
     [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
     """
 
+    max_tool_calls: Optional[int] = None
+    """
+    The maximum number of total calls to built-in tools that can be processed in a
+    response. This maximum number applies across all built-in tool calls, not per
+    individual tool. Any further attempts to call a tool by the model will be
+    ignored.
+    """
+
     previous_response_id: Optional[str] = None
     """The unique ID of the previous response to the model.
 
     Use this to create multi-turn conversations. Learn more about
     [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+    Cannot be used in conjunction with `conversation`.
+    """
+
+    prompt: Optional[ResponsePrompt] = None
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    prompt_cache_key: Optional[str] = None
+    """
+    Used by OpenAI to cache responses for similar requests to optimize your cache
+    hit rates. Replaces the `user` field.
+    [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+    """
+
+    prompt_cache_retention: Optional[Literal["in-memory", "24h"]] = None
+    """The retention policy for the prompt cache.
+
+    Set to `24h` to enable extended prompt caching, which keeps cached prefixes
+    active for longer, up to a maximum of 24 hours.
+    [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
     """
 
     reasoning: Optional[Reasoning] = None
-    """**o-series models only**
+    """**gpt-5 and o-series models only**
 
     Configuration options for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning).
     """
 
+    safety_identifier: Optional[str] = None
+    """
+    A stable identifier used to help detect users of your application that may be
+    violating OpenAI's usage policies. The IDs should be a string that uniquely
+    identifies each user. We recommend hashing their username or email address, in
+    order to avoid sending us any identifying information.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+    """
+
+    service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] = None
+    """Specifies the processing type used for serving the request.
+
+    - If set to 'auto', then the request will be processed with the service tier
+      configured in the Project settings. Unless otherwise configured, the Project
+      will use 'default'.
+    - If set to 'default', then the request will be processed with the standard
+      pricing and performance for the selected model.
+    - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+      '[priority](https://openai.com/api-priority-processing/)', then the request
+      will be processed with the corresponding service tier.
+    - When not set, the default behavior is 'auto'.
+
+    When the `service_tier` parameter is set, the response body will include the
+    `service_tier` value based on the processing mode actually used to serve the
+    request. This response value may be different from the value set in the
+    parameter.
+    """
+
     status: Optional[ResponseStatus] = None
     """The status of the response generation.
 
-    One of `completed`, `failed`, `in_progress`, or `incomplete`.
+    One of `completed`, `failed`, `in_progress`, `cancelled`, `queued`, or
+    `incomplete`.
     """
 
     text: Optional[ResponseTextConfig] = None
@@ -164,13 +260,19 @@ class Response(BaseModel):
     - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
     """
 
+    top_logprobs: Optional[int] = None
+    """
+    An integer between 0 and 20 specifying the number of most likely tokens to
+    return at each token position, each with an associated log probability.
+    """
+
     truncation: Optional[Literal["auto", "disabled"]] = None
     """The truncation strategy to use for the model response.
 
-    - `auto`: If the context of this response and previous ones exceeds the model's
-      context window size, the model will truncate the response to fit the context
-      window by dropping input items in the middle of the conversation.
-    - `disabled` (default): If a model response will exceed the context window size
+    - `auto`: If the input to this Response exceeds the model's context window size,
+      the model will truncate the response to fit the context window by dropping
+      items from the beginning of the conversation.
+    - `disabled` (default): If the input size will exceed the context window size
       for a model, the request will fail with a 400 error.
     """
 
@@ -181,16 +283,17 @@ class Response(BaseModel):
     """
 
     user: Optional[str] = None
-    """
-    A unique identifier representing your end-user, which can help OpenAI to monitor
-    and detect abuse.
-    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+    """This field is being replaced by `safety_identifier` and `prompt_cache_key`.
+
+    Use `prompt_cache_key` instead to maintain caching optimizations. A stable
+    identifier for your end-users. Used to boost cache hit rates by better bucketing
+    similar requests and to help OpenAI detect and prevent abuse.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
     """
 
     @property
     def output_text(self) -> str:
-        """Convenience property that aggregates all `output_text` items from the `output`
-        list.
+        """Convenience property that aggregates all `output_text` items from the `output` list.
 
         If no `output_text` content blocks exist, then an empty string is returned.
         """
diff --git a/src/openai/types/responses/response_apply_patch_tool_call.py b/src/openai/types/responses/response_apply_patch_tool_call.py
new file mode 100644
index 0000000000..7dc2a3c2b5
--- /dev/null
+++ b/src/openai/types/responses/response_apply_patch_tool_call.py
@@ -0,0 +1,76 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = [
+    "ResponseApplyPatchToolCall",
+    "Operation",
+    "OperationCreateFile",
+    "OperationDeleteFile",
+    "OperationUpdateFile",
+]
+
+
+class OperationCreateFile(BaseModel):
+    diff: str
+    """Diff to apply."""
+
+    path: str
+    """Path of the file to create."""
+
+    type: Literal["create_file"]
+    """Create a new file with the provided diff."""
+
+
+class OperationDeleteFile(BaseModel):
+    path: str
+    """Path of the file to delete."""
+
+    type: Literal["delete_file"]
+    """Delete the specified file."""
+
+
+class OperationUpdateFile(BaseModel):
+    diff: str
+    """Diff to apply."""
+
+    path: str
+    """Path of the file to update."""
+
+    type: Literal["update_file"]
+    """Update an existing file with the provided diff."""
+
+
+Operation: TypeAlias = Annotated[
+    Union[OperationCreateFile, OperationDeleteFile, OperationUpdateFile], PropertyInfo(discriminator="type")
+]
+
+
+class ResponseApplyPatchToolCall(BaseModel):
+    id: str
+    """The unique ID of the apply patch tool call.
+
+    Populated when this item is returned via API.
+    """
+
+    call_id: str
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    operation: Operation
+    """
+    One of the create_file, delete_file, or update_file operations applied via
+    apply_patch.
+    """
+
+    status: Literal["in_progress", "completed"]
+    """The status of the apply patch tool call. One of `in_progress` or `completed`."""
+
+    type: Literal["apply_patch_call"]
+    """The type of the item. Always `apply_patch_call`."""
+
+    created_by: Optional[str] = None
+    """The ID of the entity that created this tool call."""
diff --git a/src/openai/types/responses/response_apply_patch_tool_call_output.py b/src/openai/types/responses/response_apply_patch_tool_call_output.py
new file mode 100644
index 0000000000..cf0bcfeecc
--- /dev/null
+++ b/src/openai/types/responses/response_apply_patch_tool_call_output.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseApplyPatchToolCallOutput"]
+
+
+class ResponseApplyPatchToolCallOutput(BaseModel):
+    id: str
+    """The unique ID of the apply patch tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    call_id: str
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    status: Literal["completed", "failed"]
+    """The status of the apply patch tool call output. One of `completed` or `failed`."""
+
+    type: Literal["apply_patch_call_output"]
+    """The type of the item. Always `apply_patch_call_output`."""
+
+    created_by: Optional[str] = None
+    """The ID of the entity that created this tool call output."""
+
+    output: Optional[str] = None
+    """Optional textual output returned by the apply patch tool."""
diff --git a/src/openai/types/responses/response_audio_delta_event.py b/src/openai/types/responses/response_audio_delta_event.py
index f3d77fac52..6fb7887b80 100644
--- a/src/openai/types/responses/response_audio_delta_event.py
+++ b/src/openai/types/responses/response_audio_delta_event.py
@@ -11,5 +11,8 @@ class ResponseAudioDeltaEvent(BaseModel):
     delta: str
     """A chunk of Base64 encoded response audio bytes."""
 
+    sequence_number: int
+    """A sequence number for this chunk of the stream response."""
+
     type: Literal["response.audio.delta"]
     """The type of the event. Always `response.audio.delta`."""
diff --git a/src/openai/types/responses/response_audio_done_event.py b/src/openai/types/responses/response_audio_done_event.py
index 5654f8e398..2592ae8dcd 100644
--- a/src/openai/types/responses/response_audio_done_event.py
+++ b/src/openai/types/responses/response_audio_done_event.py
@@ -8,5 +8,8 @@
 
 
 class ResponseAudioDoneEvent(BaseModel):
+    sequence_number: int
+    """The sequence number of the delta."""
+
     type: Literal["response.audio.done"]
     """The type of the event. Always `response.audio.done`."""
diff --git a/src/openai/types/responses/response_audio_transcript_delta_event.py b/src/openai/types/responses/response_audio_transcript_delta_event.py
index 69b6660f3f..830c133d61 100644
--- a/src/openai/types/responses/response_audio_transcript_delta_event.py
+++ b/src/openai/types/responses/response_audio_transcript_delta_event.py
@@ -11,5 +11,8 @@ class ResponseAudioTranscriptDeltaEvent(BaseModel):
     delta: str
     """The partial transcript of the audio response."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.audio.transcript.delta"]
     """The type of the event. Always `response.audio.transcript.delta`."""
diff --git a/src/openai/types/responses/response_audio_transcript_done_event.py b/src/openai/types/responses/response_audio_transcript_done_event.py
index 1a20319f83..e39f501cf0 100644
--- a/src/openai/types/responses/response_audio_transcript_done_event.py
+++ b/src/openai/types/responses/response_audio_transcript_done_event.py
@@ -8,5 +8,8 @@
 
 
 class ResponseAudioTranscriptDoneEvent(BaseModel):
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.audio.transcript.done"]
     """The type of the event. Always `response.audio.transcript.done`."""
diff --git a/src/openai/types/responses/response_code_interpreter_call_code_delta_event.py b/src/openai/types/responses/response_code_interpreter_call_code_delta_event.py
index 7527238d06..c5fef939b1 100644
--- a/src/openai/types/responses/response_code_interpreter_call_code_delta_event.py
+++ b/src/openai/types/responses/response_code_interpreter_call_code_delta_event.py
@@ -9,10 +9,19 @@
 
 class ResponseCodeInterpreterCallCodeDeltaEvent(BaseModel):
     delta: str
-    """The partial code snippet added by the code interpreter."""
+    """The partial code snippet being streamed by the code interpreter."""
+
+    item_id: str
+    """The unique identifier of the code interpreter tool call item."""
 
     output_index: int
-    """The index of the output item that the code interpreter call is in progress."""
+    """
+    The index of the output item in the response for which the code is being
+    streamed.
+    """
+
+    sequence_number: int
+    """The sequence number of this event, used to order streaming events."""
 
-    type: Literal["response.code_interpreter_call.code.delta"]
-    """The type of the event. Always `response.code_interpreter_call.code.delta`."""
+    type: Literal["response.code_interpreter_call_code.delta"]
+    """The type of the event. Always `response.code_interpreter_call_code.delta`."""
diff --git a/src/openai/types/responses/response_code_interpreter_call_code_done_event.py b/src/openai/types/responses/response_code_interpreter_call_code_done_event.py
index f84d4cf3e8..5201a02d36 100644
--- a/src/openai/types/responses/response_code_interpreter_call_code_done_event.py
+++ b/src/openai/types/responses/response_code_interpreter_call_code_done_event.py
@@ -11,8 +11,14 @@ class ResponseCodeInterpreterCallCodeDoneEvent(BaseModel):
     code: str
     """The final code snippet output by the code interpreter."""
 
+    item_id: str
+    """The unique identifier of the code interpreter tool call item."""
+
     output_index: int
-    """The index of the output item that the code interpreter call is in progress."""
+    """The index of the output item in the response for which the code is finalized."""
+
+    sequence_number: int
+    """The sequence number of this event, used to order streaming events."""
 
-    type: Literal["response.code_interpreter_call.code.done"]
-    """The type of the event. Always `response.code_interpreter_call.code.done`."""
+    type: Literal["response.code_interpreter_call_code.done"]
+    """The type of the event. Always `response.code_interpreter_call_code.done`."""
diff --git a/src/openai/types/responses/response_code_interpreter_call_completed_event.py b/src/openai/types/responses/response_code_interpreter_call_completed_event.py
index b0cb73fb72..bb9563a16b 100644
--- a/src/openai/types/responses/response_code_interpreter_call_completed_event.py
+++ b/src/openai/types/responses/response_code_interpreter_call_completed_event.py
@@ -3,17 +3,22 @@
 from typing_extensions import Literal
 
 from ..._models import BaseModel
-from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
 
 __all__ = ["ResponseCodeInterpreterCallCompletedEvent"]
 
 
 class ResponseCodeInterpreterCallCompletedEvent(BaseModel):
-    code_interpreter_call: ResponseCodeInterpreterToolCall
-    """A tool call to run code."""
+    item_id: str
+    """The unique identifier of the code interpreter tool call item."""
 
     output_index: int
-    """The index of the output item that the code interpreter call is in progress."""
+    """
+    The index of the output item in the response for which the code interpreter call
+    is completed.
+    """
+
+    sequence_number: int
+    """The sequence number of this event, used to order streaming events."""
 
     type: Literal["response.code_interpreter_call.completed"]
     """The type of the event. Always `response.code_interpreter_call.completed`."""
diff --git a/src/openai/types/responses/response_code_interpreter_call_in_progress_event.py b/src/openai/types/responses/response_code_interpreter_call_in_progress_event.py
index 64b739f308..9c6b221004 100644
--- a/src/openai/types/responses/response_code_interpreter_call_in_progress_event.py
+++ b/src/openai/types/responses/response_code_interpreter_call_in_progress_event.py
@@ -3,17 +3,22 @@
 from typing_extensions import Literal
 
 from ..._models import BaseModel
-from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
 
 __all__ = ["ResponseCodeInterpreterCallInProgressEvent"]
 
 
 class ResponseCodeInterpreterCallInProgressEvent(BaseModel):
-    code_interpreter_call: ResponseCodeInterpreterToolCall
-    """A tool call to run code."""
+    item_id: str
+    """The unique identifier of the code interpreter tool call item."""
 
     output_index: int
-    """The index of the output item that the code interpreter call is in progress."""
+    """
+    The index of the output item in the response for which the code interpreter call
+    is in progress.
+    """
+
+    sequence_number: int
+    """The sequence number of this event, used to order streaming events."""
 
     type: Literal["response.code_interpreter_call.in_progress"]
     """The type of the event. Always `response.code_interpreter_call.in_progress`."""
diff --git a/src/openai/types/responses/response_code_interpreter_call_interpreting_event.py b/src/openai/types/responses/response_code_interpreter_call_interpreting_event.py
index 3100eac175..f6191e4165 100644
--- a/src/openai/types/responses/response_code_interpreter_call_interpreting_event.py
+++ b/src/openai/types/responses/response_code_interpreter_call_interpreting_event.py
@@ -3,17 +3,22 @@
 from typing_extensions import Literal
 
 from ..._models import BaseModel
-from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
 
 __all__ = ["ResponseCodeInterpreterCallInterpretingEvent"]
 
 
 class ResponseCodeInterpreterCallInterpretingEvent(BaseModel):
-    code_interpreter_call: ResponseCodeInterpreterToolCall
-    """A tool call to run code."""
+    item_id: str
+    """The unique identifier of the code interpreter tool call item."""
 
     output_index: int
-    """The index of the output item that the code interpreter call is in progress."""
+    """
+    The index of the output item in the response for which the code interpreter is
+    interpreting code.
+    """
+
+    sequence_number: int
+    """The sequence number of this event, used to order streaming events."""
 
     type: Literal["response.code_interpreter_call.interpreting"]
     """The type of the event. Always `response.code_interpreter_call.interpreting`."""
diff --git a/src/openai/types/responses/response_code_interpreter_tool_call.py b/src/openai/types/responses/response_code_interpreter_tool_call.py
index d5a5057074..b651581520 100644
--- a/src/openai/types/responses/response_code_interpreter_tool_call.py
+++ b/src/openai/types/responses/response_code_interpreter_tool_call.py
@@ -1,52 +1,55 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Union
+from typing import List, Union, Optional
 from typing_extensions import Literal, Annotated, TypeAlias
 
 from ..._utils import PropertyInfo
 from ..._models import BaseModel
 
-__all__ = ["ResponseCodeInterpreterToolCall", "Result", "ResultLogs", "ResultFiles", "ResultFilesFile"]
+__all__ = ["ResponseCodeInterpreterToolCall", "Output", "OutputLogs", "OutputImage"]
 
 
-class ResultLogs(BaseModel):
+class OutputLogs(BaseModel):
     logs: str
-    """The logs of the code interpreter tool call."""
+    """The logs output from the code interpreter."""
 
     type: Literal["logs"]
-    """The type of the code interpreter text output. Always `logs`."""
+    """The type of the output. Always `logs`."""
 
 
-class ResultFilesFile(BaseModel):
-    file_id: str
-    """The ID of the file."""
+class OutputImage(BaseModel):
+    type: Literal["image"]
+    """The type of the output. Always `image`."""
 
-    mime_type: str
-    """The MIME type of the file."""
+    url: str
+    """The URL of the image output from the code interpreter."""
 
 
-class ResultFiles(BaseModel):
-    files: List[ResultFilesFile]
-
-    type: Literal["files"]
-    """The type of the code interpreter file output. Always `files`."""
-
-
-Result: TypeAlias = Annotated[Union[ResultLogs, ResultFiles], PropertyInfo(discriminator="type")]
+Output: TypeAlias = Annotated[Union[OutputLogs, OutputImage], PropertyInfo(discriminator="type")]
 
 
 class ResponseCodeInterpreterToolCall(BaseModel):
     id: str
     """The unique ID of the code interpreter tool call."""
 
-    code: str
-    """The code to run."""
+    code: Optional[str] = None
+    """The code to run, or null if not available."""
+
+    container_id: str
+    """The ID of the container used to run the code."""
+
+    outputs: Optional[List[Output]] = None
+    """
+    The outputs generated by the code interpreter, such as logs or images. Can be
+    null if no outputs are available.
+    """
 
-    results: List[Result]
-    """The results of the code interpreter tool call."""
+    status: Literal["in_progress", "completed", "incomplete", "interpreting", "failed"]
+    """The status of the code interpreter tool call.
 
-    status: Literal["in_progress", "interpreting", "completed"]
-    """The status of the code interpreter tool call."""
+    Valid values are `in_progress`, `completed`, `incomplete`, `interpreting`, and
+    `failed`.
+    """
 
     type: Literal["code_interpreter_call"]
     """The type of the code interpreter tool call. Always `code_interpreter_call`."""
diff --git a/src/openai/types/responses/response_code_interpreter_tool_call_param.py b/src/openai/types/responses/response_code_interpreter_tool_call_param.py
new file mode 100644
index 0000000000..d402b872a4
--- /dev/null
+++ b/src/openai/types/responses/response_code_interpreter_tool_call_param.py
@@ -0,0 +1,54 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["ResponseCodeInterpreterToolCallParam", "Output", "OutputLogs", "OutputImage"]
+
+
+class OutputLogs(TypedDict, total=False):
+    logs: Required[str]
+    """The logs output from the code interpreter."""
+
+    type: Required[Literal["logs"]]
+    """The type of the output. Always `logs`."""
+
+
+class OutputImage(TypedDict, total=False):
+    type: Required[Literal["image"]]
+    """The type of the output. Always `image`."""
+
+    url: Required[str]
+    """The URL of the image output from the code interpreter."""
+
+
+Output: TypeAlias = Union[OutputLogs, OutputImage]
+
+
+class ResponseCodeInterpreterToolCallParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the code interpreter tool call."""
+
+    code: Required[Optional[str]]
+    """The code to run, or null if not available."""
+
+    container_id: Required[str]
+    """The ID of the container used to run the code."""
+
+    outputs: Required[Optional[Iterable[Output]]]
+    """
+    The outputs generated by the code interpreter, such as logs or images. Can be
+    null if no outputs are available.
+    """
+
+    status: Required[Literal["in_progress", "completed", "incomplete", "interpreting", "failed"]]
+    """The status of the code interpreter tool call.
+
+    Valid values are `in_progress`, `completed`, `incomplete`, `interpreting`, and
+    `failed`.
+    """
+
+    type: Required[Literal["code_interpreter_call"]]
+    """The type of the code interpreter tool call. Always `code_interpreter_call`."""
diff --git a/src/openai/types/responses/response_completed_event.py b/src/openai/types/responses/response_completed_event.py
index a944f248ef..8a2bd51f75 100644
--- a/src/openai/types/responses/response_completed_event.py
+++ b/src/openai/types/responses/response_completed_event.py
@@ -12,5 +12,8 @@ class ResponseCompletedEvent(BaseModel):
     response: Response
     """Properties of the completed response."""
 
+    sequence_number: int
+    """The sequence number for this event."""
+
     type: Literal["response.completed"]
     """The type of the event. Always `response.completed`."""
diff --git a/src/openai/types/responses/response_computer_tool_call.py b/src/openai/types/responses/response_computer_tool_call.py
index 994837567a..f1476fa0fb 100644
--- a/src/openai/types/responses/response_computer_tool_call.py
+++ b/src/openai/types/responses/response_computer_tool_call.py
@@ -1,6 +1,6 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Union
+from typing import List, Union, Optional
 from typing_extensions import Literal, Annotated, TypeAlias
 
 from ..._utils import PropertyInfo
@@ -31,10 +31,7 @@ class ActionClick(BaseModel):
     """
 
     type: Literal["click"]
-    """Specifies the event type.
-
-    For a click action, this property is always set to `click`.
-    """
+    """Specifies the event type. For a click action, this property is always `click`."""
 
     x: int
     """The x-coordinate where the click occurred."""
@@ -181,10 +178,10 @@ class PendingSafetyCheck(BaseModel):
     id: str
     """The ID of the pending safety check."""
 
-    code: str
+    code: Optional[str] = None
     """The type of the pending safety check."""
 
-    message: str
+    message: Optional[str] = None
     """Details about the pending safety check."""
 
 
diff --git a/src/openai/types/responses/response_computer_tool_call_output_item.py b/src/openai/types/responses/response_computer_tool_call_output_item.py
new file mode 100644
index 0000000000..e1ac358cc6
--- /dev/null
+++ b/src/openai/types/responses/response_computer_tool_call_output_item.py
@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .response_computer_tool_call_output_screenshot import ResponseComputerToolCallOutputScreenshot
+
+__all__ = ["ResponseComputerToolCallOutputItem", "AcknowledgedSafetyCheck"]
+
+
+class AcknowledgedSafetyCheck(BaseModel):
+    id: str
+    """The ID of the pending safety check."""
+
+    code: Optional[str] = None
+    """The type of the pending safety check."""
+
+    message: Optional[str] = None
+    """Details about the pending safety check."""
+
+
+class ResponseComputerToolCallOutputItem(BaseModel):
+    id: str
+    """The unique ID of the computer call tool output."""
+
+    call_id: str
+    """The ID of the computer tool call that produced the output."""
+
+    output: ResponseComputerToolCallOutputScreenshot
+    """A computer screenshot image used with the computer use tool."""
+
+    type: Literal["computer_call_output"]
+    """The type of the computer tool call output. Always `computer_call_output`."""
+
+    acknowledged_safety_checks: Optional[List[AcknowledgedSafetyCheck]] = None
+    """
+    The safety checks reported by the API that have been acknowledged by the
+    developer.
+    """
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the message input.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when input items
+    are returned via API.
+    """
diff --git a/src/openai/types/responses/response_computer_tool_call_output_screenshot.py b/src/openai/types/responses/response_computer_tool_call_output_screenshot.py
new file mode 100644
index 0000000000..a500da85c1
--- /dev/null
+++ b/src/openai/types/responses/response_computer_tool_call_output_screenshot.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseComputerToolCallOutputScreenshot"]
+
+
+class ResponseComputerToolCallOutputScreenshot(BaseModel):
+    type: Literal["computer_screenshot"]
+    """Specifies the event type.
+
+    For a computer screenshot, this property is always set to `computer_screenshot`.
+    """
+
+    file_id: Optional[str] = None
+    """The identifier of an uploaded file that contains the screenshot."""
+
+    image_url: Optional[str] = None
+    """The URL of the screenshot image."""
diff --git a/src/openai/types/responses/response_computer_tool_call_output_screenshot_param.py b/src/openai/types/responses/response_computer_tool_call_output_screenshot_param.py
new file mode 100644
index 0000000000..efc2028aa4
--- /dev/null
+++ b/src/openai/types/responses/response_computer_tool_call_output_screenshot_param.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ResponseComputerToolCallOutputScreenshotParam"]
+
+
+class ResponseComputerToolCallOutputScreenshotParam(TypedDict, total=False):
+    type: Required[Literal["computer_screenshot"]]
+    """Specifies the event type.
+
+    For a computer screenshot, this property is always set to `computer_screenshot`.
+    """
+
+    file_id: str
+    """The identifier of an uploaded file that contains the screenshot."""
+
+    image_url: str
+    """The URL of the screenshot image."""
diff --git a/src/openai/types/responses/response_computer_tool_call_param.py b/src/openai/types/responses/response_computer_tool_call_param.py
index d4ef56ab5c..228f76bac9 100644
--- a/src/openai/types/responses/response_computer_tool_call_param.py
+++ b/src/openai/types/responses/response_computer_tool_call_param.py
@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable
+from typing import Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = [
     "ResponseComputerToolCallParam",
     "Action",
@@ -30,10 +32,7 @@ class ActionClick(TypedDict, total=False):
     """
 
     type: Required[Literal["click"]]
-    """Specifies the event type.
-
-    For a click action, this property is always set to `click`.
-    """
+    """Specifies the event type. For a click action, this property is always `click`."""
 
     x: Required[int]
     """The x-coordinate where the click occurred."""
@@ -86,7 +85,7 @@ class ActionDrag(TypedDict, total=False):
 
 
 class ActionKeypress(TypedDict, total=False):
-    keys: Required[List[str]]
+    keys: Required[SequenceNotStr[str]]
     """The combination of keys the model is requesting to be pressed.
 
     This is an array of strings, each representing a key.
@@ -177,10 +176,10 @@ class PendingSafetyCheck(TypedDict, total=False):
     id: Required[str]
     """The ID of the pending safety check."""
 
-    code: Required[str]
+    code: Optional[str]
     """The type of the pending safety check."""
 
-    message: Required[str]
+    message: Optional[str]
     """Details about the pending safety check."""
 
 
diff --git a/src/openai/types/responses/response_content_part_added_event.py b/src/openai/types/responses/response_content_part_added_event.py
index 93f5ec4b0c..c78e80d1c4 100644
--- a/src/openai/types/responses/response_content_part_added_event.py
+++ b/src/openai/types/responses/response_content_part_added_event.py
@@ -8,9 +8,20 @@
 from .response_output_text import ResponseOutputText
 from .response_output_refusal import ResponseOutputRefusal
 
-__all__ = ["ResponseContentPartAddedEvent", "Part"]
+__all__ = ["ResponseContentPartAddedEvent", "Part", "PartReasoningText"]
 
-Part: TypeAlias = Annotated[Union[ResponseOutputText, ResponseOutputRefusal], PropertyInfo(discriminator="type")]
+
+class PartReasoningText(BaseModel):
+    text: str
+    """The reasoning text from the model."""
+
+    type: Literal["reasoning_text"]
+    """The type of the reasoning text. Always `reasoning_text`."""
+
+
+Part: TypeAlias = Annotated[
+    Union[ResponseOutputText, ResponseOutputRefusal, PartReasoningText], PropertyInfo(discriminator="type")
+]
 
 
 class ResponseContentPartAddedEvent(BaseModel):
@@ -26,5 +37,8 @@ class ResponseContentPartAddedEvent(BaseModel):
     part: Part
     """The content part that was added."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.content_part.added"]
     """The type of the event. Always `response.content_part.added`."""
diff --git a/src/openai/types/responses/response_content_part_done_event.py b/src/openai/types/responses/response_content_part_done_event.py
index 4ec0739877..732f2303ef 100644
--- a/src/openai/types/responses/response_content_part_done_event.py
+++ b/src/openai/types/responses/response_content_part_done_event.py
@@ -8,9 +8,20 @@
 from .response_output_text import ResponseOutputText
 from .response_output_refusal import ResponseOutputRefusal
 
-__all__ = ["ResponseContentPartDoneEvent", "Part"]
+__all__ = ["ResponseContentPartDoneEvent", "Part", "PartReasoningText"]
 
-Part: TypeAlias = Annotated[Union[ResponseOutputText, ResponseOutputRefusal], PropertyInfo(discriminator="type")]
+
+class PartReasoningText(BaseModel):
+    text: str
+    """The reasoning text from the model."""
+
+    type: Literal["reasoning_text"]
+    """The type of the reasoning text. Always `reasoning_text`."""
+
+
+Part: TypeAlias = Annotated[
+    Union[ResponseOutputText, ResponseOutputRefusal, PartReasoningText], PropertyInfo(discriminator="type")
+]
 
 
 class ResponseContentPartDoneEvent(BaseModel):
@@ -26,5 +37,8 @@ class ResponseContentPartDoneEvent(BaseModel):
     part: Part
     """The content part that is done."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.content_part.done"]
     """The type of the event. Always `response.content_part.done`."""
diff --git a/src/openai/types/responses/response_conversation_param.py b/src/openai/types/responses/response_conversation_param.py
new file mode 100644
index 0000000000..067bdc7a31
--- /dev/null
+++ b/src/openai/types/responses/response_conversation_param.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["ResponseConversationParam"]
+
+
+class ResponseConversationParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the conversation."""
diff --git a/src/openai/types/responses/response_create_params.py b/src/openai/types/responses/response_create_params.py
index d5b2fdeb1a..64888ac62d 100644
--- a/src/openai/types/responses/response_create_params.py
+++ b/src/openai/types/responses/response_create_params.py
@@ -6,18 +6,27 @@
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
 from .tool_param import ToolParam
-from ..shared.chat_model import ChatModel
 from .response_includable import ResponseIncludable
 from .tool_choice_options import ToolChoiceOptions
 from .response_input_param import ResponseInputParam
+from .response_prompt_param import ResponsePromptParam
+from .tool_choice_mcp_param import ToolChoiceMcpParam
 from ..shared_params.metadata import Metadata
+from .tool_choice_shell_param import ToolChoiceShellParam
 from .tool_choice_types_param import ToolChoiceTypesParam
 from ..shared_params.reasoning import Reasoning
+from .tool_choice_custom_param import ToolChoiceCustomParam
+from .tool_choice_allowed_param import ToolChoiceAllowedParam
 from .response_text_config_param import ResponseTextConfigParam
 from .tool_choice_function_param import ToolChoiceFunctionParam
+from .response_conversation_param import ResponseConversationParam
+from .tool_choice_apply_patch_param import ToolChoiceApplyPatchParam
+from ..shared_params.responses_model import ResponsesModel
 
 __all__ = [
     "ResponseCreateParamsBase",
+    "Conversation",
+    "StreamOptions",
     "ToolChoice",
     "ResponseCreateParamsNonStreaming",
     "ResponseCreateParamsStreaming",
@@ -25,25 +34,18 @@
 
 
 class ResponseCreateParamsBase(TypedDict, total=False):
-    input: Required[Union[str, ResponseInputParam]]
-    """Text, image, or file inputs to the model, used to generate a response.
-
-    Learn more:
-
-    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
-    - [Image inputs](https://platform.openai.com/docs/guides/images)
-    - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
-    - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
-    - [Function calling](https://platform.openai.com/docs/guides/function-calling)
+    background: Optional[bool]
+    """
+    Whether to run the model response in the background.
+    [Learn more](https://platform.openai.com/docs/guides/background).
     """
 
-    model: Required[Union[str, ChatModel]]
-    """Model ID used to generate the response, like `gpt-4o` or `o1`.
+    conversation: Optional[Conversation]
+    """The conversation that this response belongs to.
 
-    OpenAI offers a wide range of models with different capabilities, performance
-    characteristics, and price points. Refer to the
-    [model guide](https://platform.openai.com/docs/models) to browse and compare
-    available models.
+    Items from this conversation are prepended to `input_items` for this response
+    request. Input items and output items from this response are automatically added
+    to this conversation after this response completes.
     """
 
     include: Optional[List[ResponseIncludable]]
@@ -51,21 +53,41 @@ class ResponseCreateParamsBase(TypedDict, total=False):
 
     Currently supported values are:
 
-    - `file_search_call.results`: Include the search results of the file search tool
+    - `web_search_call.action.sources`: Include the sources of the web search tool
       call.
-    - `message.input_image.image_url`: Include image urls from the input message.
+    - `code_interpreter_call.outputs`: Includes the outputs of python code execution
+      in code interpreter tool call items.
     - `computer_call_output.output.image_url`: Include image urls from the computer
       call output.
+    - `file_search_call.results`: Include the search results of the file search tool
+      call.
+    - `message.input_image.image_url`: Include image urls from the input message.
+    - `message.output_text.logprobs`: Include logprobs with assistant messages.
+    - `reasoning.encrypted_content`: Includes an encrypted version of reasoning
+      tokens in reasoning item outputs. This enables reasoning items to be used in
+      multi-turn conversations when using the Responses API statelessly (like when
+      the `store` parameter is set to `false`, or when an organization is enrolled
+      in the zero data retention program).
     """
 
-    instructions: Optional[str]
+    input: Union[str, ResponseInputParam]
+    """Text, image, or file inputs to the model, used to generate a response.
+
+    Learn more:
+
+    - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+    - [Image inputs](https://platform.openai.com/docs/guides/images)
+    - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
+    - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
+    - [Function calling](https://platform.openai.com/docs/guides/function-calling)
     """
-    Inserts a system (or developer) message as the first item in the model's
-    context.
+
+    instructions: Optional[str]
+    """A system (or developer) message inserted into the model's context.
 
     When using along with `previous_response_id`, the instructions from a previous
-    response will be not be carried over to the next response. This makes it simple
-    to swap out system (or developer) messages in new responses.
+    response will not be carried over to the next response. This makes it simple to
+    swap out system (or developer) messages in new responses.
     """
 
     max_output_tokens: Optional[int]
@@ -75,6 +97,14 @@ class ResponseCreateParamsBase(TypedDict, total=False):
     [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
     """
 
+    max_tool_calls: Optional[int]
+    """
+    The maximum number of total calls to built-in tools that can be processed in a
+    response. This maximum number applies across all built-in tool calls, not per
+    individual tool. Any further attempts to call a tool by the model will be
+    ignored.
+    """
+
     metadata: Optional[Metadata]
     """Set of 16 key-value pairs that can be attached to an object.
 
@@ -85,6 +115,15 @@ class ResponseCreateParamsBase(TypedDict, total=False):
     a maximum length of 512 characters.
     """
 
+    model: ResponsesModel
+    """Model ID used to generate the response, like `gpt-4o` or `o3`.
+
+    OpenAI offers a wide range of models with different capabilities, performance
+    characteristics, and price points. Refer to the
+    [model guide](https://platform.openai.com/docs/models) to browse and compare
+    available models.
+    """
+
     parallel_tool_calls: Optional[bool]
     """Whether to allow the model to run tool calls in parallel."""
 
@@ -93,18 +132,71 @@ class ResponseCreateParamsBase(TypedDict, total=False):
 
     Use this to create multi-turn conversations. Learn more about
     [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+    Cannot be used in conjunction with `conversation`.
+    """
+
+    prompt: Optional[ResponsePromptParam]
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    prompt_cache_key: str
+    """
+    Used by OpenAI to cache responses for similar requests to optimize your cache
+    hit rates. Replaces the `user` field.
+    [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+    """
+
+    prompt_cache_retention: Optional[Literal["in-memory", "24h"]]
+    """The retention policy for the prompt cache.
+
+    Set to `24h` to enable extended prompt caching, which keeps cached prefixes
+    active for longer, up to a maximum of 24 hours.
+    [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
     """
 
     reasoning: Optional[Reasoning]
-    """**o-series models only**
+    """**gpt-5 and o-series models only**
 
     Configuration options for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning).
     """
 
+    safety_identifier: str
+    """
+    A stable identifier used to help detect users of your application that may be
+    violating OpenAI's usage policies. The IDs should be a string that uniquely
+    identifies each user. We recommend hashing their username or email address, in
+    order to avoid sending us any identifying information.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+    """
+
+    service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]]
+    """Specifies the processing type used for serving the request.
+
+    - If set to 'auto', then the request will be processed with the service tier
+      configured in the Project settings. Unless otherwise configured, the Project
+      will use 'default'.
+    - If set to 'default', then the request will be processed with the standard
+      pricing and performance for the selected model.
+    - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+      '[priority](https://openai.com/api-priority-processing/)', then the request
+      will be processed with the corresponding service tier.
+    - When not set, the default behavior is 'auto'.
+
+    When the `service_tier` parameter is set, the response body will include the
+    `service_tier` value based on the processing mode actually used to serve the
+    request. This response value may be different from the value set in the
+    parameter.
+    """
+
     store: Optional[bool]
     """Whether to store the generated model response for later retrieval via API."""
 
+    stream_options: Optional[StreamOptions]
+    """Options for streaming responses. Only set this when you set `stream: true`."""
+
     temperature: Optional[float]
     """What sampling temperature to use, between 0 and 2.
 
@@ -134,7 +226,7 @@ class ResponseCreateParamsBase(TypedDict, total=False):
 
     You can specify which tool to use by setting the `tool_choice` parameter.
 
-    The two categories of tools you can provide the model are:
+    We support the following categories of tools:
 
     - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
       capabilities, like
@@ -142,9 +234,20 @@ class ResponseCreateParamsBase(TypedDict, total=False):
       [file search](https://platform.openai.com/docs/guides/tools-file-search).
       Learn more about
       [built-in tools](https://platform.openai.com/docs/guides/tools).
+    - **MCP Tools**: Integrations with third-party systems via custom MCP servers or
+      predefined connectors such as Google Drive and SharePoint. Learn more about
+      [MCP Tools](https://platform.openai.com/docs/guides/tools-connectors-mcp).
     - **Function calls (custom tools)**: Functions that are defined by you, enabling
-      the model to call your own code. Learn more about
+      the model to call your own code with strongly typed arguments and outputs.
+      Learn more about
       [function calling](https://platform.openai.com/docs/guides/function-calling).
+      You can also use custom tools to call your own code.
+    """
+
+    top_logprobs: Optional[int]
+    """
+    An integer between 0 and 20 specifying the number of most likely tokens to
+    return at each token position, each with an associated log probability.
     """
 
     top_p: Optional[float]
@@ -159,22 +262,49 @@ class ResponseCreateParamsBase(TypedDict, total=False):
     truncation: Optional[Literal["auto", "disabled"]]
     """The truncation strategy to use for the model response.
 
-    - `auto`: If the context of this response and previous ones exceeds the model's
-      context window size, the model will truncate the response to fit the context
-      window by dropping input items in the middle of the conversation.
-    - `disabled` (default): If a model response will exceed the context window size
+    - `auto`: If the input to this Response exceeds the model's context window size,
+      the model will truncate the response to fit the context window by dropping
+      items from the beginning of the conversation.
+    - `disabled` (default): If the input size will exceed the context window size
       for a model, the request will fail with a 400 error.
     """
 
     user: str
+    """This field is being replaced by `safety_identifier` and `prompt_cache_key`.
+
+    Use `prompt_cache_key` instead to maintain caching optimizations. A stable
+    identifier for your end-users. Used to boost cache hit rates by better bucketing
+    similar requests and to help OpenAI detect and prevent abuse.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
     """
-    A unique identifier representing your end-user, which can help OpenAI to monitor
-    and detect abuse.
-    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+
+Conversation: TypeAlias = Union[str, ResponseConversationParam]
+
+
+class StreamOptions(TypedDict, total=False):
+    include_obfuscation: bool
+    """When true, stream obfuscation will be enabled.
+
+    Stream obfuscation adds random characters to an `obfuscation` field on streaming
+    delta events to normalize payload sizes as a mitigation to certain side-channel
+    attacks. These obfuscation fields are included by default, but add a small
+    amount of overhead to the data stream. You can set `include_obfuscation` to
+    false to optimize for bandwidth if you trust the network links between your
+    application and the OpenAI API.
     """
 
 
-ToolChoice: TypeAlias = Union[ToolChoiceOptions, ToolChoiceTypesParam, ToolChoiceFunctionParam]
+ToolChoice: TypeAlias = Union[
+    ToolChoiceOptions,
+    ToolChoiceAllowedParam,
+    ToolChoiceTypesParam,
+    ToolChoiceFunctionParam,
+    ToolChoiceMcpParam,
+    ToolChoiceCustomParam,
+    ToolChoiceApplyPatchParam,
+    ToolChoiceShellParam,
+]
 
 
 class ResponseCreateParamsNonStreaming(ResponseCreateParamsBase, total=False):
diff --git a/src/openai/types/responses/response_created_event.py b/src/openai/types/responses/response_created_event.py
index 7a524cec87..73a9d700d4 100644
--- a/src/openai/types/responses/response_created_event.py
+++ b/src/openai/types/responses/response_created_event.py
@@ -12,5 +12,8 @@ class ResponseCreatedEvent(BaseModel):
     response: Response
     """The response that was created."""
 
+    sequence_number: int
+    """The sequence number for this event."""
+
     type: Literal["response.created"]
     """The type of the event. Always `response.created`."""
diff --git a/src/openai/types/responses/response_custom_tool_call.py b/src/openai/types/responses/response_custom_tool_call.py
new file mode 100644
index 0000000000..38c650e662
--- /dev/null
+++ b/src/openai/types/responses/response_custom_tool_call.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseCustomToolCall"]
+
+
+class ResponseCustomToolCall(BaseModel):
+    call_id: str
+    """An identifier used to map this custom tool call to a tool call output."""
+
+    input: str
+    """The input for the custom tool call generated by the model."""
+
+    name: str
+    """The name of the custom tool being called."""
+
+    type: Literal["custom_tool_call"]
+    """The type of the custom tool call. Always `custom_tool_call`."""
+
+    id: Optional[str] = None
+    """The unique ID of the custom tool call in the OpenAI platform."""
diff --git a/src/openai/types/responses/response_custom_tool_call_input_delta_event.py b/src/openai/types/responses/response_custom_tool_call_input_delta_event.py
new file mode 100644
index 0000000000..6c33102d75
--- /dev/null
+++ b/src/openai/types/responses/response_custom_tool_call_input_delta_event.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseCustomToolCallInputDeltaEvent"]
+
+
+class ResponseCustomToolCallInputDeltaEvent(BaseModel):
+    delta: str
+    """The incremental input data (delta) for the custom tool call."""
+
+    item_id: str
+    """Unique identifier for the API item associated with this event."""
+
+    output_index: int
+    """The index of the output this delta applies to."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.custom_tool_call_input.delta"]
+    """The event type identifier."""
diff --git a/src/openai/types/responses/response_custom_tool_call_input_done_event.py b/src/openai/types/responses/response_custom_tool_call_input_done_event.py
new file mode 100644
index 0000000000..35a2fee22b
--- /dev/null
+++ b/src/openai/types/responses/response_custom_tool_call_input_done_event.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseCustomToolCallInputDoneEvent"]
+
+
+class ResponseCustomToolCallInputDoneEvent(BaseModel):
+    input: str
+    """The complete input data for the custom tool call."""
+
+    item_id: str
+    """Unique identifier for the API item associated with this event."""
+
+    output_index: int
+    """The index of the output this event applies to."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.custom_tool_call_input.done"]
+    """The event type identifier."""
diff --git a/src/openai/types/responses/response_custom_tool_call_output.py b/src/openai/types/responses/response_custom_tool_call_output.py
new file mode 100644
index 0000000000..9db9e7e5cf
--- /dev/null
+++ b/src/openai/types/responses/response_custom_tool_call_output.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .response_input_file import ResponseInputFile
+from .response_input_text import ResponseInputText
+from .response_input_image import ResponseInputImage
+
+__all__ = ["ResponseCustomToolCallOutput", "OutputOutputContentList"]
+
+OutputOutputContentList: TypeAlias = Annotated[
+    Union[ResponseInputText, ResponseInputImage, ResponseInputFile], PropertyInfo(discriminator="type")
+]
+
+
+class ResponseCustomToolCallOutput(BaseModel):
+    call_id: str
+    """The call ID, used to map this custom tool call output to a custom tool call."""
+
+    output: Union[str, List[OutputOutputContentList]]
+    """
+    The output from the custom tool call generated by your code. Can be a string or
+    an list of output content.
+    """
+
+    type: Literal["custom_tool_call_output"]
+    """The type of the custom tool call output. Always `custom_tool_call_output`."""
+
+    id: Optional[str] = None
+    """The unique ID of the custom tool call output in the OpenAI platform."""
diff --git a/src/openai/types/responses/response_custom_tool_call_output_param.py b/src/openai/types/responses/response_custom_tool_call_output_param.py
new file mode 100644
index 0000000000..e967a37cff
--- /dev/null
+++ b/src/openai/types/responses/response_custom_tool_call_output_param.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .response_input_file_param import ResponseInputFileParam
+from .response_input_text_param import ResponseInputTextParam
+from .response_input_image_param import ResponseInputImageParam
+
+__all__ = ["ResponseCustomToolCallOutputParam", "OutputOutputContentList"]
+
+OutputOutputContentList: TypeAlias = Union[ResponseInputTextParam, ResponseInputImageParam, ResponseInputFileParam]
+
+
+class ResponseCustomToolCallOutputParam(TypedDict, total=False):
+    call_id: Required[str]
+    """The call ID, used to map this custom tool call output to a custom tool call."""
+
+    output: Required[Union[str, Iterable[OutputOutputContentList]]]
+    """
+    The output from the custom tool call generated by your code. Can be a string or
+    an list of output content.
+    """
+
+    type: Required[Literal["custom_tool_call_output"]]
+    """The type of the custom tool call output. Always `custom_tool_call_output`."""
+
+    id: str
+    """The unique ID of the custom tool call output in the OpenAI platform."""
diff --git a/src/openai/types/responses/response_custom_tool_call_param.py b/src/openai/types/responses/response_custom_tool_call_param.py
new file mode 100644
index 0000000000..e15beac29f
--- /dev/null
+++ b/src/openai/types/responses/response_custom_tool_call_param.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ResponseCustomToolCallParam"]
+
+
+class ResponseCustomToolCallParam(TypedDict, total=False):
+    call_id: Required[str]
+    """An identifier used to map this custom tool call to a tool call output."""
+
+    input: Required[str]
+    """The input for the custom tool call generated by the model."""
+
+    name: Required[str]
+    """The name of the custom tool being called."""
+
+    type: Required[Literal["custom_tool_call"]]
+    """The type of the custom tool call. Always `custom_tool_call`."""
+
+    id: str
+    """The unique ID of the custom tool call in the OpenAI platform."""
diff --git a/src/openai/types/responses/response_error_event.py b/src/openai/types/responses/response_error_event.py
index 1b7e605d02..826c395125 100644
--- a/src/openai/types/responses/response_error_event.py
+++ b/src/openai/types/responses/response_error_event.py
@@ -18,5 +18,8 @@ class ResponseErrorEvent(BaseModel):
     param: Optional[str] = None
     """The error parameter."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["error"]
     """The type of the event. Always `error`."""
diff --git a/src/openai/types/responses/response_failed_event.py b/src/openai/types/responses/response_failed_event.py
index 3e8f75d8c4..cdd3d7d808 100644
--- a/src/openai/types/responses/response_failed_event.py
+++ b/src/openai/types/responses/response_failed_event.py
@@ -12,5 +12,8 @@ class ResponseFailedEvent(BaseModel):
     response: Response
     """The response that failed."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.failed"]
     """The type of the event. Always `response.failed`."""
diff --git a/src/openai/types/responses/response_file_search_call_completed_event.py b/src/openai/types/responses/response_file_search_call_completed_event.py
index 4b86083369..08e51b2d3f 100644
--- a/src/openai/types/responses/response_file_search_call_completed_event.py
+++ b/src/openai/types/responses/response_file_search_call_completed_event.py
@@ -14,5 +14,8 @@ class ResponseFileSearchCallCompletedEvent(BaseModel):
     output_index: int
     """The index of the output item that the file search call is initiated."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.file_search_call.completed"]
     """The type of the event. Always `response.file_search_call.completed`."""
diff --git a/src/openai/types/responses/response_file_search_call_in_progress_event.py b/src/openai/types/responses/response_file_search_call_in_progress_event.py
index eb42e3dad6..63840a649f 100644
--- a/src/openai/types/responses/response_file_search_call_in_progress_event.py
+++ b/src/openai/types/responses/response_file_search_call_in_progress_event.py
@@ -14,5 +14,8 @@ class ResponseFileSearchCallInProgressEvent(BaseModel):
     output_index: int
     """The index of the output item that the file search call is initiated."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.file_search_call.in_progress"]
     """The type of the event. Always `response.file_search_call.in_progress`."""
diff --git a/src/openai/types/responses/response_file_search_call_searching_event.py b/src/openai/types/responses/response_file_search_call_searching_event.py
index 3cd8905de6..706c8c57ad 100644
--- a/src/openai/types/responses/response_file_search_call_searching_event.py
+++ b/src/openai/types/responses/response_file_search_call_searching_event.py
@@ -14,5 +14,8 @@ class ResponseFileSearchCallSearchingEvent(BaseModel):
     output_index: int
     """The index of the output item that the file search call is searching."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.file_search_call.searching"]
     """The type of the event. Always `response.file_search_call.searching`."""
diff --git a/src/openai/types/responses/response_file_search_tool_call_param.py b/src/openai/types/responses/response_file_search_tool_call_param.py
index 9a4177cf81..4903dca4fb 100644
--- a/src/openai/types/responses/response_file_search_tool_call_param.py
+++ b/src/openai/types/responses/response_file_search_tool_call_param.py
@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Iterable, Optional
+from typing import Dict, Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["ResponseFileSearchToolCallParam", "Result"]
 
 
@@ -35,7 +37,7 @@ class ResponseFileSearchToolCallParam(TypedDict, total=False):
     id: Required[str]
     """The unique ID of the file search tool call."""
 
-    queries: Required[List[str]]
+    queries: Required[SequenceNotStr[str]]
     """The queries used to search for files."""
 
     status: Required[Literal["in_progress", "searching", "completed", "incomplete", "failed"]]
diff --git a/src/openai/types/responses/response_format_text_json_schema_config.py b/src/openai/types/responses/response_format_text_json_schema_config.py
index 3cf066370f..001fcf5bab 100644
--- a/src/openai/types/responses/response_format_text_json_schema_config.py
+++ b/src/openai/types/responses/response_format_text_json_schema_config.py
@@ -11,6 +11,13 @@
 
 
 class ResponseFormatTextJSONSchemaConfig(BaseModel):
+    name: str
+    """The name of the response format.
+
+    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
+    of 64.
+    """
+
     schema_: Dict[str, object] = FieldInfo(alias="schema")
     """
     The schema for the response format, described as a JSON Schema object. Learn how
@@ -26,13 +33,6 @@ class ResponseFormatTextJSONSchemaConfig(BaseModel):
     how to respond in the format.
     """
 
-    name: Optional[str] = None
-    """The name of the response format.
-
-    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
-    of 64.
-    """
-
     strict: Optional[bool] = None
     """
     Whether to enable strict schema adherence when generating the output. If set to
diff --git a/src/openai/types/responses/response_format_text_json_schema_config_param.py b/src/openai/types/responses/response_format_text_json_schema_config_param.py
index 211c5d1eff..f293a80c5a 100644
--- a/src/openai/types/responses/response_format_text_json_schema_config_param.py
+++ b/src/openai/types/responses/response_format_text_json_schema_config_param.py
@@ -9,6 +9,13 @@
 
 
 class ResponseFormatTextJSONSchemaConfigParam(TypedDict, total=False):
+    name: Required[str]
+    """The name of the response format.
+
+    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
+    of 64.
+    """
+
     schema: Required[Dict[str, object]]
     """
     The schema for the response format, described as a JSON Schema object. Learn how
@@ -24,13 +31,6 @@ class ResponseFormatTextJSONSchemaConfigParam(TypedDict, total=False):
     how to respond in the format.
     """
 
-    name: str
-    """The name of the response format.
-
-    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
-    of 64.
-    """
-
     strict: Optional[bool]
     """
     Whether to enable strict schema adherence when generating the output. If set to
diff --git a/src/openai/types/responses/response_function_call_arguments_delta_event.py b/src/openai/types/responses/response_function_call_arguments_delta_event.py
index 0989b7caeb..c6bc5dfad7 100644
--- a/src/openai/types/responses/response_function_call_arguments_delta_event.py
+++ b/src/openai/types/responses/response_function_call_arguments_delta_event.py
@@ -19,5 +19,8 @@ class ResponseFunctionCallArgumentsDeltaEvent(BaseModel):
     The index of the output item that the function-call arguments delta is added to.
     """
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.function_call_arguments.delta"]
     """The type of the event. Always `response.function_call_arguments.delta`."""
diff --git a/src/openai/types/responses/response_function_call_arguments_done_event.py b/src/openai/types/responses/response_function_call_arguments_done_event.py
index 1d805a57c6..4ee5ed7fe1 100644
--- a/src/openai/types/responses/response_function_call_arguments_done_event.py
+++ b/src/openai/types/responses/response_function_call_arguments_done_event.py
@@ -14,7 +14,13 @@ class ResponseFunctionCallArgumentsDoneEvent(BaseModel):
     item_id: str
     """The ID of the item."""
 
+    name: str
+    """The name of the function that was called."""
+
     output_index: int
     """The index of the output item."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.function_call_arguments.done"]
diff --git a/src/openai/types/responses/response_function_call_output_item.py b/src/openai/types/responses/response_function_call_output_item.py
new file mode 100644
index 0000000000..41898f9eda
--- /dev/null
+++ b/src/openai/types/responses/response_function_call_output_item.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .response_input_file_content import ResponseInputFileContent
+from .response_input_text_content import ResponseInputTextContent
+from .response_input_image_content import ResponseInputImageContent
+
+__all__ = ["ResponseFunctionCallOutputItem"]
+
+ResponseFunctionCallOutputItem: TypeAlias = Annotated[
+    Union[ResponseInputTextContent, ResponseInputImageContent, ResponseInputFileContent],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/responses/response_function_call_output_item_list.py b/src/openai/types/responses/response_function_call_output_item_list.py
new file mode 100644
index 0000000000..13db577160
--- /dev/null
+++ b/src/openai/types/responses/response_function_call_output_item_list.py
@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+from typing_extensions import TypeAlias
+
+from .response_function_call_output_item import ResponseFunctionCallOutputItem
+
+__all__ = ["ResponseFunctionCallOutputItemList"]
+
+ResponseFunctionCallOutputItemList: TypeAlias = List[ResponseFunctionCallOutputItem]
diff --git a/src/openai/types/responses/response_function_call_output_item_list_param.py b/src/openai/types/responses/response_function_call_output_item_list_param.py
new file mode 100644
index 0000000000..8c286d3cf0
--- /dev/null
+++ b/src/openai/types/responses/response_function_call_output_item_list_param.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from typing_extensions import TypeAlias
+
+from .response_input_file_content_param import ResponseInputFileContentParam
+from .response_input_text_content_param import ResponseInputTextContentParam
+from .response_input_image_content_param import ResponseInputImageContentParam
+
+__all__ = ["ResponseFunctionCallOutputItemListParam", "ResponseFunctionCallOutputItemParam"]
+
+ResponseFunctionCallOutputItemParam: TypeAlias = Union[
+    ResponseInputTextContentParam, ResponseInputImageContentParam, ResponseInputFileContentParam
+]
+
+ResponseFunctionCallOutputItemListParam: TypeAlias = List[ResponseFunctionCallOutputItemParam]
diff --git a/src/openai/types/responses/response_function_call_output_item_param.py b/src/openai/types/responses/response_function_call_output_item_param.py
new file mode 100644
index 0000000000..2a703cac1e
--- /dev/null
+++ b/src/openai/types/responses/response_function_call_output_item_param.py
@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import TypeAlias
+
+from .response_input_file_content_param import ResponseInputFileContentParam
+from .response_input_text_content_param import ResponseInputTextContentParam
+from .response_input_image_content_param import ResponseInputImageContentParam
+
+__all__ = ["ResponseFunctionCallOutputItemParam"]
+
+ResponseFunctionCallOutputItemParam: TypeAlias = Union[
+    ResponseInputTextContentParam, ResponseInputImageContentParam, ResponseInputFileContentParam
+]
diff --git a/src/openai/types/responses/response_function_shell_call_output_content.py b/src/openai/types/responses/response_function_shell_call_output_content.py
new file mode 100644
index 0000000000..1429ce9724
--- /dev/null
+++ b/src/openai/types/responses/response_function_shell_call_output_content.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = ["ResponseFunctionShellCallOutputContent", "Outcome", "OutcomeTimeout", "OutcomeExit"]
+
+
+class OutcomeTimeout(BaseModel):
+    type: Literal["timeout"]
+    """The outcome type. Always `timeout`."""
+
+
+class OutcomeExit(BaseModel):
+    exit_code: int
+    """The exit code returned by the shell process."""
+
+    type: Literal["exit"]
+    """The outcome type. Always `exit`."""
+
+
+Outcome: TypeAlias = Annotated[Union[OutcomeTimeout, OutcomeExit], PropertyInfo(discriminator="type")]
+
+
+class ResponseFunctionShellCallOutputContent(BaseModel):
+    outcome: Outcome
+    """The exit or timeout outcome associated with this chunk."""
+
+    stderr: str
+    """Captured stderr output for this chunk of the shell call."""
+
+    stdout: str
+    """Captured stdout output for this chunk of the shell call."""
diff --git a/src/openai/types/responses/response_function_shell_call_output_content_param.py b/src/openai/types/responses/response_function_shell_call_output_content_param.py
new file mode 100644
index 0000000000..6395541cf5
--- /dev/null
+++ b/src/openai/types/responses/response_function_shell_call_output_content_param.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["ResponseFunctionShellCallOutputContentParam", "Outcome", "OutcomeTimeout", "OutcomeExit"]
+
+
+class OutcomeTimeout(TypedDict, total=False):
+    type: Required[Literal["timeout"]]
+    """The outcome type. Always `timeout`."""
+
+
+class OutcomeExit(TypedDict, total=False):
+    exit_code: Required[int]
+    """The exit code returned by the shell process."""
+
+    type: Required[Literal["exit"]]
+    """The outcome type. Always `exit`."""
+
+
+Outcome: TypeAlias = Union[OutcomeTimeout, OutcomeExit]
+
+
+class ResponseFunctionShellCallOutputContentParam(TypedDict, total=False):
+    outcome: Required[Outcome]
+    """The exit or timeout outcome associated with this chunk."""
+
+    stderr: Required[str]
+    """Captured stderr output for this chunk of the shell call."""
+
+    stdout: Required[str]
+    """Captured stdout output for this chunk of the shell call."""
diff --git a/src/openai/types/responses/response_function_shell_tool_call.py b/src/openai/types/responses/response_function_shell_tool_call.py
new file mode 100644
index 0000000000..be0a5bcff8
--- /dev/null
+++ b/src/openai/types/responses/response_function_shell_tool_call.py
@@ -0,0 +1,44 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseFunctionShellToolCall", "Action"]
+
+
+class Action(BaseModel):
+    commands: List[str]
+
+    max_output_length: Optional[int] = None
+    """Optional maximum number of characters to return from each command."""
+
+    timeout_ms: Optional[int] = None
+    """Optional timeout in milliseconds for the commands."""
+
+
+class ResponseFunctionShellToolCall(BaseModel):
+    id: str
+    """The unique ID of the function shell tool call.
+
+    Populated when this item is returned via API.
+    """
+
+    action: Action
+    """The shell commands and limits that describe how to run the tool call."""
+
+    call_id: str
+    """The unique ID of the function shell tool call generated by the model."""
+
+    status: Literal["in_progress", "completed", "incomplete"]
+    """The status of the shell call.
+
+    One of `in_progress`, `completed`, or `incomplete`.
+    """
+
+    type: Literal["shell_call"]
+    """The type of the item. Always `shell_call`."""
+
+    created_by: Optional[str] = None
+    """The ID of the entity that created this tool call."""
diff --git a/src/openai/types/responses/response_function_shell_tool_call_output.py b/src/openai/types/responses/response_function_shell_tool_call_output.py
new file mode 100644
index 0000000000..e74927df41
--- /dev/null
+++ b/src/openai/types/responses/response_function_shell_tool_call_output.py
@@ -0,0 +1,70 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = [
+    "ResponseFunctionShellToolCallOutput",
+    "Output",
+    "OutputOutcome",
+    "OutputOutcomeTimeout",
+    "OutputOutcomeExit",
+]
+
+
+class OutputOutcomeTimeout(BaseModel):
+    type: Literal["timeout"]
+    """The outcome type. Always `timeout`."""
+
+
+class OutputOutcomeExit(BaseModel):
+    exit_code: int
+    """Exit code from the shell process."""
+
+    type: Literal["exit"]
+    """The outcome type. Always `exit`."""
+
+
+OutputOutcome: TypeAlias = Annotated[Union[OutputOutcomeTimeout, OutputOutcomeExit], PropertyInfo(discriminator="type")]
+
+
+class Output(BaseModel):
+    outcome: OutputOutcome
+    """
+    Represents either an exit outcome (with an exit code) or a timeout outcome for a
+    shell call output chunk.
+    """
+
+    stderr: str
+
+    stdout: str
+
+    created_by: Optional[str] = None
+
+
+class ResponseFunctionShellToolCallOutput(BaseModel):
+    id: str
+    """The unique ID of the shell call output.
+
+    Populated when this item is returned via API.
+    """
+
+    call_id: str
+    """The unique ID of the shell tool call generated by the model."""
+
+    max_output_length: Optional[int] = None
+    """The maximum length of the shell command output.
+
+    This is generated by the model and should be passed back with the raw output.
+    """
+
+    output: List[Output]
+    """An array of shell call output contents"""
+
+    type: Literal["shell_call_output"]
+    """The type of the shell call output. Always `shell_call_output`."""
+
+    created_by: Optional[str] = None
diff --git a/src/openai/types/responses/response_function_tool_call.py b/src/openai/types/responses/response_function_tool_call.py
index 5d82906cb7..2a8482204e 100644
--- a/src/openai/types/responses/response_function_tool_call.py
+++ b/src/openai/types/responses/response_function_tool_call.py
@@ -9,9 +9,6 @@
 
 
 class ResponseFunctionToolCall(BaseModel):
-    id: str
-    """The unique ID of the function tool call."""
-
     arguments: str
     """A JSON string of the arguments to pass to the function."""
 
@@ -24,6 +21,9 @@ class ResponseFunctionToolCall(BaseModel):
     type: Literal["function_call"]
     """The type of the function tool call. Always `function_call`."""
 
+    id: Optional[str] = None
+    """The unique ID of the function tool call."""
+
     status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
     """The status of the item.
 
diff --git a/src/openai/types/responses/response_function_tool_call_item.py b/src/openai/types/responses/response_function_tool_call_item.py
new file mode 100644
index 0000000000..762015a4b1
--- /dev/null
+++ b/src/openai/types/responses/response_function_tool_call_item.py
@@ -0,0 +1,10 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .response_function_tool_call import ResponseFunctionToolCall
+
+__all__ = ["ResponseFunctionToolCallItem"]
+
+
+class ResponseFunctionToolCallItem(ResponseFunctionToolCall):
+    id: str  # type: ignore
+    """The unique ID of the function tool call."""
diff --git a/src/openai/types/responses/response_function_tool_call_output_item.py b/src/openai/types/responses/response_function_tool_call_output_item.py
new file mode 100644
index 0000000000..1a2c848cb3
--- /dev/null
+++ b/src/openai/types/responses/response_function_tool_call_output_item.py
@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .response_input_file import ResponseInputFile
+from .response_input_text import ResponseInputText
+from .response_input_image import ResponseInputImage
+
+__all__ = ["ResponseFunctionToolCallOutputItem", "OutputOutputContentList"]
+
+OutputOutputContentList: TypeAlias = Annotated[
+    Union[ResponseInputText, ResponseInputImage, ResponseInputFile], PropertyInfo(discriminator="type")
+]
+
+
+class ResponseFunctionToolCallOutputItem(BaseModel):
+    id: str
+    """The unique ID of the function call tool output."""
+
+    call_id: str
+    """The unique ID of the function tool call generated by the model."""
+
+    output: Union[str, List[OutputOutputContentList]]
+    """
+    The output from the function call generated by your code. Can be a string or an
+    list of output content.
+    """
+
+    type: Literal["function_call_output"]
+    """The type of the function tool call output. Always `function_call_output`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the item.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
+    returned via API.
+    """
diff --git a/src/openai/types/responses/response_function_tool_call_param.py b/src/openai/types/responses/response_function_tool_call_param.py
index 51b947a764..eaa263cf67 100644
--- a/src/openai/types/responses/response_function_tool_call_param.py
+++ b/src/openai/types/responses/response_function_tool_call_param.py
@@ -8,9 +8,6 @@
 
 
 class ResponseFunctionToolCallParam(TypedDict, total=False):
-    id: Required[str]
-    """The unique ID of the function tool call."""
-
     arguments: Required[str]
     """A JSON string of the arguments to pass to the function."""
 
@@ -23,6 +20,9 @@ class ResponseFunctionToolCallParam(TypedDict, total=False):
     type: Required[Literal["function_call"]]
     """The type of the function tool call. Always `function_call`."""
 
+    id: str
+    """The unique ID of the function tool call."""
+
     status: Literal["in_progress", "completed", "incomplete"]
     """The status of the item.
 
diff --git a/src/openai/types/responses/response_function_web_search.py b/src/openai/types/responses/response_function_web_search.py
index 44734b681f..f3e80e6a8f 100644
--- a/src/openai/types/responses/response_function_web_search.py
+++ b/src/openai/types/responses/response_function_web_search.py
@@ -1,16 +1,65 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing_extensions import Literal
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
 
+from ..._utils import PropertyInfo
 from ..._models import BaseModel
 
-__all__ = ["ResponseFunctionWebSearch"]
+__all__ = ["ResponseFunctionWebSearch", "Action", "ActionSearch", "ActionSearchSource", "ActionOpenPage", "ActionFind"]
+
+
+class ActionSearchSource(BaseModel):
+    type: Literal["url"]
+    """The type of source. Always `url`."""
+
+    url: str
+    """The URL of the source."""
+
+
+class ActionSearch(BaseModel):
+    query: str
+    """The search query."""
+
+    type: Literal["search"]
+    """The action type."""
+
+    sources: Optional[List[ActionSearchSource]] = None
+    """The sources used in the search."""
+
+
+class ActionOpenPage(BaseModel):
+    type: Literal["open_page"]
+    """The action type."""
+
+    url: str
+    """The URL opened by the model."""
+
+
+class ActionFind(BaseModel):
+    pattern: str
+    """The pattern or text to search for within the page."""
+
+    type: Literal["find"]
+    """The action type."""
+
+    url: str
+    """The URL of the page searched for the pattern."""
+
+
+Action: TypeAlias = Annotated[Union[ActionSearch, ActionOpenPage, ActionFind], PropertyInfo(discriminator="type")]
 
 
 class ResponseFunctionWebSearch(BaseModel):
     id: str
     """The unique ID of the web search tool call."""
 
+    action: Action
+    """
+    An object describing the specific action taken in this web search call. Includes
+    details on how the model used the web (search, open_page, find).
+    """
+
     status: Literal["in_progress", "searching", "completed", "failed"]
     """The status of the web search tool call."""
 
diff --git a/src/openai/types/responses/response_function_web_search_param.py b/src/openai/types/responses/response_function_web_search_param.py
index d413e60b12..fc019d3eb7 100644
--- a/src/openai/types/responses/response_function_web_search_param.py
+++ b/src/openai/types/responses/response_function_web_search_param.py
@@ -2,15 +2,70 @@
 
 from __future__ import annotations
 
-from typing_extensions import Literal, Required, TypedDict
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
-__all__ = ["ResponseFunctionWebSearchParam"]
+__all__ = [
+    "ResponseFunctionWebSearchParam",
+    "Action",
+    "ActionSearch",
+    "ActionSearchSource",
+    "ActionOpenPage",
+    "ActionFind",
+]
+
+
+class ActionSearchSource(TypedDict, total=False):
+    type: Required[Literal["url"]]
+    """The type of source. Always `url`."""
+
+    url: Required[str]
+    """The URL of the source."""
+
+
+class ActionSearch(TypedDict, total=False):
+    query: Required[str]
+    """The search query."""
+
+    type: Required[Literal["search"]]
+    """The action type."""
+
+    sources: Iterable[ActionSearchSource]
+    """The sources used in the search."""
+
+
+class ActionOpenPage(TypedDict, total=False):
+    type: Required[Literal["open_page"]]
+    """The action type."""
+
+    url: Required[str]
+    """The URL opened by the model."""
+
+
+class ActionFind(TypedDict, total=False):
+    pattern: Required[str]
+    """The pattern or text to search for within the page."""
+
+    type: Required[Literal["find"]]
+    """The action type."""
+
+    url: Required[str]
+    """The URL of the page searched for the pattern."""
+
+
+Action: TypeAlias = Union[ActionSearch, ActionOpenPage, ActionFind]
 
 
 class ResponseFunctionWebSearchParam(TypedDict, total=False):
     id: Required[str]
     """The unique ID of the web search tool call."""
 
+    action: Required[Action]
+    """
+    An object describing the specific action taken in this web search call. Includes
+    details on how the model used the web (search, open_page, find).
+    """
+
     status: Required[Literal["in_progress", "searching", "completed", "failed"]]
     """The status of the web search tool call."""
 
diff --git a/src/openai/types/responses/response_image_gen_call_completed_event.py b/src/openai/types/responses/response_image_gen_call_completed_event.py
new file mode 100644
index 0000000000..a554273ed0
--- /dev/null
+++ b/src/openai/types/responses/response_image_gen_call_completed_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseImageGenCallCompletedEvent"]
+
+
+class ResponseImageGenCallCompletedEvent(BaseModel):
+    item_id: str
+    """The unique identifier of the image generation item being processed."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.image_generation_call.completed"]
+    """The type of the event. Always 'response.image_generation_call.completed'."""
diff --git a/src/openai/types/responses/response_image_gen_call_generating_event.py b/src/openai/types/responses/response_image_gen_call_generating_event.py
new file mode 100644
index 0000000000..74b4f57333
--- /dev/null
+++ b/src/openai/types/responses/response_image_gen_call_generating_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseImageGenCallGeneratingEvent"]
+
+
+class ResponseImageGenCallGeneratingEvent(BaseModel):
+    item_id: str
+    """The unique identifier of the image generation item being processed."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    sequence_number: int
+    """The sequence number of the image generation item being processed."""
+
+    type: Literal["response.image_generation_call.generating"]
+    """The type of the event. Always 'response.image_generation_call.generating'."""
diff --git a/src/openai/types/responses/response_image_gen_call_in_progress_event.py b/src/openai/types/responses/response_image_gen_call_in_progress_event.py
new file mode 100644
index 0000000000..b36ff5fa47
--- /dev/null
+++ b/src/openai/types/responses/response_image_gen_call_in_progress_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseImageGenCallInProgressEvent"]
+
+
+class ResponseImageGenCallInProgressEvent(BaseModel):
+    item_id: str
+    """The unique identifier of the image generation item being processed."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    sequence_number: int
+    """The sequence number of the image generation item being processed."""
+
+    type: Literal["response.image_generation_call.in_progress"]
+    """The type of the event. Always 'response.image_generation_call.in_progress'."""
diff --git a/src/openai/types/responses/response_image_gen_call_partial_image_event.py b/src/openai/types/responses/response_image_gen_call_partial_image_event.py
new file mode 100644
index 0000000000..e69c95fb33
--- /dev/null
+++ b/src/openai/types/responses/response_image_gen_call_partial_image_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseImageGenCallPartialImageEvent"]
+
+
+class ResponseImageGenCallPartialImageEvent(BaseModel):
+    item_id: str
+    """The unique identifier of the image generation item being processed."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    partial_image_b64: str
+    """Base64-encoded partial image data, suitable for rendering as an image."""
+
+    partial_image_index: int
+    """
+    0-based index for the partial image (backend is 1-based, but this is 0-based for
+    the user).
+    """
+
+    sequence_number: int
+    """The sequence number of the image generation item being processed."""
+
+    type: Literal["response.image_generation_call.partial_image"]
+    """The type of the event. Always 'response.image_generation_call.partial_image'."""
diff --git a/src/openai/types/responses/response_in_progress_event.py b/src/openai/types/responses/response_in_progress_event.py
index 7d96cbb8ad..b82e10b357 100644
--- a/src/openai/types/responses/response_in_progress_event.py
+++ b/src/openai/types/responses/response_in_progress_event.py
@@ -12,5 +12,8 @@ class ResponseInProgressEvent(BaseModel):
     response: Response
     """The response that is in progress."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.in_progress"]
     """The type of the event. Always `response.in_progress`."""
diff --git a/src/openai/types/responses/response_includable.py b/src/openai/types/responses/response_includable.py
index 83489fa7f1..675c83405a 100644
--- a/src/openai/types/responses/response_includable.py
+++ b/src/openai/types/responses/response_includable.py
@@ -5,5 +5,12 @@
 __all__ = ["ResponseIncludable"]
 
 ResponseIncludable: TypeAlias = Literal[
-    "file_search_call.results", "message.input_image.image_url", "computer_call_output.output.image_url"
+    "file_search_call.results",
+    "web_search_call.results",
+    "web_search_call.action.sources",
+    "message.input_image.image_url",
+    "computer_call_output.output.image_url",
+    "code_interpreter_call.outputs",
+    "reasoning.encrypted_content",
+    "message.output_text.logprobs",
 ]
diff --git a/src/openai/types/responses/response_incomplete_event.py b/src/openai/types/responses/response_incomplete_event.py
index 742b789c7e..63c969a428 100644
--- a/src/openai/types/responses/response_incomplete_event.py
+++ b/src/openai/types/responses/response_incomplete_event.py
@@ -12,5 +12,8 @@ class ResponseIncompleteEvent(BaseModel):
     response: Response
     """The response that was incomplete."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.incomplete"]
     """The type of the event. Always `response.incomplete`."""
diff --git a/src/openai/types/responses/response_input_audio.py b/src/openai/types/responses/response_input_audio.py
new file mode 100644
index 0000000000..9fef6de0fd
--- /dev/null
+++ b/src/openai/types/responses/response_input_audio.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseInputAudio", "InputAudio"]
+
+
+class InputAudio(BaseModel):
+    data: str
+    """Base64-encoded audio data."""
+
+    format: Literal["mp3", "wav"]
+    """The format of the audio data. Currently supported formats are `mp3` and `wav`."""
+
+
+class ResponseInputAudio(BaseModel):
+    input_audio: InputAudio
+
+    type: Literal["input_audio"]
+    """The type of the input item. Always `input_audio`."""
diff --git a/src/openai/types/responses/response_input_audio_param.py b/src/openai/types/responses/response_input_audio_param.py
new file mode 100644
index 0000000000..f3fc913cca
--- /dev/null
+++ b/src/openai/types/responses/response_input_audio_param.py
@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ResponseInputAudioParam", "InputAudio"]
+
+
+class InputAudio(TypedDict, total=False):
+    data: Required[str]
+    """Base64-encoded audio data."""
+
+    format: Required[Literal["mp3", "wav"]]
+    """The format of the audio data. Currently supported formats are `mp3` and `wav`."""
+
+
+class ResponseInputAudioParam(TypedDict, total=False):
+    input_audio: Required[InputAudio]
+
+    type: Required[Literal["input_audio"]]
+    """The type of the input item. Always `input_audio`."""
diff --git a/src/openai/types/responses/response_input_file.py b/src/openai/types/responses/response_input_file.py
index 00b35dc844..1eecd6a2b6 100644
--- a/src/openai/types/responses/response_input_file.py
+++ b/src/openai/types/responses/response_input_file.py
@@ -18,5 +18,8 @@ class ResponseInputFile(BaseModel):
     file_id: Optional[str] = None
     """The ID of the file to be sent to the model."""
 
+    file_url: Optional[str] = None
+    """The URL of the file to be sent to the model."""
+
     filename: Optional[str] = None
     """The name of the file to be sent to the model."""
diff --git a/src/openai/types/responses/response_input_file_content.py b/src/openai/types/responses/response_input_file_content.py
new file mode 100644
index 0000000000..d832bb0e26
--- /dev/null
+++ b/src/openai/types/responses/response_input_file_content.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseInputFileContent"]
+
+
+class ResponseInputFileContent(BaseModel):
+    type: Literal["input_file"]
+    """The type of the input item. Always `input_file`."""
+
+    file_data: Optional[str] = None
+    """The base64-encoded data of the file to be sent to the model."""
+
+    file_id: Optional[str] = None
+    """The ID of the file to be sent to the model."""
+
+    file_url: Optional[str] = None
+    """The URL of the file to be sent to the model."""
+
+    filename: Optional[str] = None
+    """The name of the file to be sent to the model."""
diff --git a/src/openai/types/responses/response_input_file_content_param.py b/src/openai/types/responses/response_input_file_content_param.py
new file mode 100644
index 0000000000..71f7b3a281
--- /dev/null
+++ b/src/openai/types/responses/response_input_file_content_param.py
@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ResponseInputFileContentParam"]
+
+
+class ResponseInputFileContentParam(TypedDict, total=False):
+    type: Required[Literal["input_file"]]
+    """The type of the input item. Always `input_file`."""
+
+    file_data: Optional[str]
+    """The base64-encoded data of the file to be sent to the model."""
+
+    file_id: Optional[str]
+    """The ID of the file to be sent to the model."""
+
+    file_url: Optional[str]
+    """The URL of the file to be sent to the model."""
+
+    filename: Optional[str]
+    """The name of the file to be sent to the model."""
diff --git a/src/openai/types/responses/response_input_file_param.py b/src/openai/types/responses/response_input_file_param.py
index dc06a4ea2d..0b5f513ec6 100644
--- a/src/openai/types/responses/response_input_file_param.py
+++ b/src/openai/types/responses/response_input_file_param.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from typing import Optional
 from typing_extensions import Literal, Required, TypedDict
 
 __all__ = ["ResponseInputFileParam"]
@@ -14,8 +15,11 @@ class ResponseInputFileParam(TypedDict, total=False):
     file_data: str
     """The content of the file to be sent to the model."""
 
-    file_id: str
+    file_id: Optional[str]
     """The ID of the file to be sent to the model."""
 
+    file_url: str
+    """The URL of the file to be sent to the model."""
+
     filename: str
     """The name of the file to be sent to the model."""
diff --git a/src/openai/types/responses/response_input_image.py b/src/openai/types/responses/response_input_image.py
index d719f44e9b..f2d760b25e 100644
--- a/src/openai/types/responses/response_input_image.py
+++ b/src/openai/types/responses/response_input_image.py
@@ -9,7 +9,7 @@
 
 
 class ResponseInputImage(BaseModel):
-    detail: Literal["high", "low", "auto"]
+    detail: Literal["low", "high", "auto"]
     """The detail level of the image to be sent to the model.
 
     One of `high`, `low`, or `auto`. Defaults to `auto`.
diff --git a/src/openai/types/responses/response_input_image_content.py b/src/openai/types/responses/response_input_image_content.py
new file mode 100644
index 0000000000..fb90cb57eb
--- /dev/null
+++ b/src/openai/types/responses/response_input_image_content.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseInputImageContent"]
+
+
+class ResponseInputImageContent(BaseModel):
+    type: Literal["input_image"]
+    """The type of the input item. Always `input_image`."""
+
+    detail: Optional[Literal["low", "high", "auto"]] = None
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+    file_id: Optional[str] = None
+    """The ID of the file to be sent to the model."""
+
+    image_url: Optional[str] = None
+    """The URL of the image to be sent to the model.
+
+    A fully qualified URL or base64 encoded image in a data URL.
+    """
diff --git a/src/openai/types/responses/response_input_image_content_param.py b/src/openai/types/responses/response_input_image_content_param.py
new file mode 100644
index 0000000000..c51509a3f3
--- /dev/null
+++ b/src/openai/types/responses/response_input_image_content_param.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ResponseInputImageContentParam"]
+
+
+class ResponseInputImageContentParam(TypedDict, total=False):
+    type: Required[Literal["input_image"]]
+    """The type of the input item. Always `input_image`."""
+
+    detail: Optional[Literal["low", "high", "auto"]]
+    """The detail level of the image to be sent to the model.
+
+    One of `high`, `low`, or `auto`. Defaults to `auto`.
+    """
+
+    file_id: Optional[str]
+    """The ID of the file to be sent to the model."""
+
+    image_url: Optional[str]
+    """The URL of the image to be sent to the model.
+
+    A fully qualified URL or base64 encoded image in a data URL.
+    """
diff --git a/src/openai/types/responses/response_input_image_param.py b/src/openai/types/responses/response_input_image_param.py
index 5dd4db2b5d..bc17e4f1c2 100644
--- a/src/openai/types/responses/response_input_image_param.py
+++ b/src/openai/types/responses/response_input_image_param.py
@@ -9,7 +9,7 @@
 
 
 class ResponseInputImageParam(TypedDict, total=False):
-    detail: Required[Literal["high", "low", "auto"]]
+    detail: Required[Literal["low", "high", "auto"]]
     """The detail level of the image to be sent to the model.
 
     One of `high`, `low`, or `auto`. Defaults to `auto`.
diff --git a/src/openai/types/responses/response_input_item.py b/src/openai/types/responses/response_input_item.py
new file mode 100644
index 0000000000..eaf5396087
--- /dev/null
+++ b/src/openai/types/responses/response_input_item.py
@@ -0,0 +1,482 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .easy_input_message import EasyInputMessage
+from .response_output_message import ResponseOutputMessage
+from .response_reasoning_item import ResponseReasoningItem
+from .response_custom_tool_call import ResponseCustomToolCall
+from .response_computer_tool_call import ResponseComputerToolCall
+from .response_function_tool_call import ResponseFunctionToolCall
+from .response_function_web_search import ResponseFunctionWebSearch
+from .response_file_search_tool_call import ResponseFileSearchToolCall
+from .response_custom_tool_call_output import ResponseCustomToolCallOutput
+from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
+from .response_input_message_content_list import ResponseInputMessageContentList
+from .response_function_call_output_item_list import ResponseFunctionCallOutputItemList
+from .response_function_shell_call_output_content import ResponseFunctionShellCallOutputContent
+from .response_computer_tool_call_output_screenshot import ResponseComputerToolCallOutputScreenshot
+
+__all__ = [
+    "ResponseInputItem",
+    "Message",
+    "ComputerCallOutput",
+    "ComputerCallOutputAcknowledgedSafetyCheck",
+    "FunctionCallOutput",
+    "ImageGenerationCall",
+    "LocalShellCall",
+    "LocalShellCallAction",
+    "LocalShellCallOutput",
+    "ShellCall",
+    "ShellCallAction",
+    "ShellCallOutput",
+    "ApplyPatchCall",
+    "ApplyPatchCallOperation",
+    "ApplyPatchCallOperationCreateFile",
+    "ApplyPatchCallOperationDeleteFile",
+    "ApplyPatchCallOperationUpdateFile",
+    "ApplyPatchCallOutput",
+    "McpListTools",
+    "McpListToolsTool",
+    "McpApprovalRequest",
+    "McpApprovalResponse",
+    "McpCall",
+    "ItemReference",
+]
+
+
+class Message(BaseModel):
+    content: ResponseInputMessageContentList
+    """
+    A list of one or many input items to the model, containing different content
+    types.
+    """
+
+    role: Literal["user", "system", "developer"]
+    """The role of the message input. One of `user`, `system`, or `developer`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of item.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
+    returned via API.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always set to `message`."""
+
+
+class ComputerCallOutputAcknowledgedSafetyCheck(BaseModel):
+    id: str
+    """The ID of the pending safety check."""
+
+    code: Optional[str] = None
+    """The type of the pending safety check."""
+
+    message: Optional[str] = None
+    """Details about the pending safety check."""
+
+
+class ComputerCallOutput(BaseModel):
+    call_id: str
+    """The ID of the computer tool call that produced the output."""
+
+    output: ResponseComputerToolCallOutputScreenshot
+    """A computer screenshot image used with the computer use tool."""
+
+    type: Literal["computer_call_output"]
+    """The type of the computer tool call output. Always `computer_call_output`."""
+
+    id: Optional[str] = None
+    """The ID of the computer tool call output."""
+
+    acknowledged_safety_checks: Optional[List[ComputerCallOutputAcknowledgedSafetyCheck]] = None
+    """
+    The safety checks reported by the API that have been acknowledged by the
+    developer.
+    """
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the message input.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when input items
+    are returned via API.
+    """
+
+
+class FunctionCallOutput(BaseModel):
+    call_id: str
+    """The unique ID of the function tool call generated by the model."""
+
+    output: Union[str, ResponseFunctionCallOutputItemList]
+    """Text, image, or file output of the function tool call."""
+
+    type: Literal["function_call_output"]
+    """The type of the function tool call output. Always `function_call_output`."""
+
+    id: Optional[str] = None
+    """The unique ID of the function tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the item.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
+    returned via API.
+    """
+
+
+class ImageGenerationCall(BaseModel):
+    id: str
+    """The unique ID of the image generation call."""
+
+    result: Optional[str] = None
+    """The generated image encoded in base64."""
+
+    status: Literal["in_progress", "completed", "generating", "failed"]
+    """The status of the image generation call."""
+
+    type: Literal["image_generation_call"]
+    """The type of the image generation call. Always `image_generation_call`."""
+
+
+class LocalShellCallAction(BaseModel):
+    command: List[str]
+    """The command to run."""
+
+    env: Dict[str, str]
+    """Environment variables to set for the command."""
+
+    type: Literal["exec"]
+    """The type of the local shell action. Always `exec`."""
+
+    timeout_ms: Optional[int] = None
+    """Optional timeout in milliseconds for the command."""
+
+    user: Optional[str] = None
+    """Optional user to run the command as."""
+
+    working_directory: Optional[str] = None
+    """Optional working directory to run the command in."""
+
+
+class LocalShellCall(BaseModel):
+    id: str
+    """The unique ID of the local shell call."""
+
+    action: LocalShellCallAction
+    """Execute a shell command on the server."""
+
+    call_id: str
+    """The unique ID of the local shell tool call generated by the model."""
+
+    status: Literal["in_progress", "completed", "incomplete"]
+    """The status of the local shell call."""
+
+    type: Literal["local_shell_call"]
+    """The type of the local shell call. Always `local_shell_call`."""
+
+
+class LocalShellCallOutput(BaseModel):
+    id: str
+    """The unique ID of the local shell tool call generated by the model."""
+
+    output: str
+    """A JSON string of the output of the local shell tool call."""
+
+    type: Literal["local_shell_call_output"]
+    """The type of the local shell tool call output. Always `local_shell_call_output`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the item. One of `in_progress`, `completed`, or `incomplete`."""
+
+
+class ShellCallAction(BaseModel):
+    commands: List[str]
+    """Ordered shell commands for the execution environment to run."""
+
+    max_output_length: Optional[int] = None
+    """
+    Maximum number of UTF-8 characters to capture from combined stdout and stderr
+    output.
+    """
+
+    timeout_ms: Optional[int] = None
+    """Maximum wall-clock time in milliseconds to allow the shell commands to run."""
+
+
+class ShellCall(BaseModel):
+    action: ShellCallAction
+    """The shell commands and limits that describe how to run the tool call."""
+
+    call_id: str
+    """The unique ID of the function shell tool call generated by the model."""
+
+    type: Literal["shell_call"]
+    """The type of the item. Always `function_shell_call`."""
+
+    id: Optional[str] = None
+    """The unique ID of the function shell tool call.
+
+    Populated when this item is returned via API.
+    """
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the shell call.
+
+    One of `in_progress`, `completed`, or `incomplete`.
+    """
+
+
+class ShellCallOutput(BaseModel):
+    call_id: str
+    """The unique ID of the function shell tool call generated by the model."""
+
+    output: List[ResponseFunctionShellCallOutputContent]
+    """
+    Captured chunks of stdout and stderr output, along with their associated
+    outcomes.
+    """
+
+    type: Literal["shell_call_output"]
+    """The type of the item. Always `function_shell_call_output`."""
+
+    id: Optional[str] = None
+    """The unique ID of the function shell tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    max_output_length: Optional[int] = None
+    """
+    The maximum number of UTF-8 characters captured for this shell call's combined
+    output.
+    """
+
+
+class ApplyPatchCallOperationCreateFile(BaseModel):
+    diff: str
+    """Unified diff content to apply when creating the file."""
+
+    path: str
+    """Path of the file to create relative to the workspace root."""
+
+    type: Literal["create_file"]
+    """The operation type. Always `create_file`."""
+
+
+class ApplyPatchCallOperationDeleteFile(BaseModel):
+    path: str
+    """Path of the file to delete relative to the workspace root."""
+
+    type: Literal["delete_file"]
+    """The operation type. Always `delete_file`."""
+
+
+class ApplyPatchCallOperationUpdateFile(BaseModel):
+    diff: str
+    """Unified diff content to apply to the existing file."""
+
+    path: str
+    """Path of the file to update relative to the workspace root."""
+
+    type: Literal["update_file"]
+    """The operation type. Always `update_file`."""
+
+
+ApplyPatchCallOperation: TypeAlias = Annotated[
+    Union[ApplyPatchCallOperationCreateFile, ApplyPatchCallOperationDeleteFile, ApplyPatchCallOperationUpdateFile],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class ApplyPatchCall(BaseModel):
+    call_id: str
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    operation: ApplyPatchCallOperation
+    """
+    The specific create, delete, or update instruction for the apply_patch tool
+    call.
+    """
+
+    status: Literal["in_progress", "completed"]
+    """The status of the apply patch tool call. One of `in_progress` or `completed`."""
+
+    type: Literal["apply_patch_call"]
+    """The type of the item. Always `apply_patch_call`."""
+
+    id: Optional[str] = None
+    """The unique ID of the apply patch tool call.
+
+    Populated when this item is returned via API.
+    """
+
+
+class ApplyPatchCallOutput(BaseModel):
+    call_id: str
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    status: Literal["completed", "failed"]
+    """The status of the apply patch tool call output. One of `completed` or `failed`."""
+
+    type: Literal["apply_patch_call_output"]
+    """The type of the item. Always `apply_patch_call_output`."""
+
+    id: Optional[str] = None
+    """The unique ID of the apply patch tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    output: Optional[str] = None
+    """
+    Optional human-readable log text from the apply patch tool (e.g., patch results
+    or errors).
+    """
+
+
+class McpListToolsTool(BaseModel):
+    input_schema: object
+    """The JSON schema describing the tool's input."""
+
+    name: str
+    """The name of the tool."""
+
+    annotations: Optional[object] = None
+    """Additional annotations about the tool."""
+
+    description: Optional[str] = None
+    """The description of the tool."""
+
+
+class McpListTools(BaseModel):
+    id: str
+    """The unique ID of the list."""
+
+    server_label: str
+    """The label of the MCP server."""
+
+    tools: List[McpListToolsTool]
+    """The tools available on the server."""
+
+    type: Literal["mcp_list_tools"]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    error: Optional[str] = None
+    """Error message if the server could not list tools."""
+
+
+class McpApprovalRequest(BaseModel):
+    id: str
+    """The unique ID of the approval request."""
+
+    arguments: str
+    """A JSON string of arguments for the tool."""
+
+    name: str
+    """The name of the tool to run."""
+
+    server_label: str
+    """The label of the MCP server making the request."""
+
+    type: Literal["mcp_approval_request"]
+    """The type of the item. Always `mcp_approval_request`."""
+
+
+class McpApprovalResponse(BaseModel):
+    approval_request_id: str
+    """The ID of the approval request being answered."""
+
+    approve: bool
+    """Whether the request was approved."""
+
+    type: Literal["mcp_approval_response"]
+    """The type of the item. Always `mcp_approval_response`."""
+
+    id: Optional[str] = None
+    """The unique ID of the approval response"""
+
+    reason: Optional[str] = None
+    """Optional reason for the decision."""
+
+
+class McpCall(BaseModel):
+    id: str
+    """The unique ID of the tool call."""
+
+    arguments: str
+    """A JSON string of the arguments passed to the tool."""
+
+    name: str
+    """The name of the tool that was run."""
+
+    server_label: str
+    """The label of the MCP server running the tool."""
+
+    type: Literal["mcp_call"]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str] = None
+    """
+    Unique identifier for the MCP tool call approval request. Include this value in
+    a subsequent `mcp_approval_response` input to approve or reject the
+    corresponding tool call.
+    """
+
+    error: Optional[str] = None
+    """The error from the tool call, if any."""
+
+    output: Optional[str] = None
+    """The output from the tool call."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete", "calling", "failed"]] = None
+    """The status of the tool call.
+
+    One of `in_progress`, `completed`, `incomplete`, `calling`, or `failed`.
+    """
+
+
+class ItemReference(BaseModel):
+    id: str
+    """The ID of the item to reference."""
+
+    type: Optional[Literal["item_reference"]] = None
+    """The type of item to reference. Always `item_reference`."""
+
+
+ResponseInputItem: TypeAlias = Annotated[
+    Union[
+        EasyInputMessage,
+        Message,
+        ResponseOutputMessage,
+        ResponseFileSearchToolCall,
+        ResponseComputerToolCall,
+        ComputerCallOutput,
+        ResponseFunctionWebSearch,
+        ResponseFunctionToolCall,
+        FunctionCallOutput,
+        ResponseReasoningItem,
+        ImageGenerationCall,
+        ResponseCodeInterpreterToolCall,
+        LocalShellCall,
+        LocalShellCallOutput,
+        ShellCall,
+        ShellCallOutput,
+        ApplyPatchCall,
+        ApplyPatchCallOutput,
+        McpListTools,
+        McpApprovalRequest,
+        McpApprovalResponse,
+        McpCall,
+        ResponseCustomToolCallOutput,
+        ResponseCustomToolCall,
+        ItemReference,
+    ],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/responses/response_input_item_param.py b/src/openai/types/responses/response_input_item_param.py
index 32ac13cabb..5c2e81c4de 100644
--- a/src/openai/types/responses/response_input_item_param.py
+++ b/src/openai/types/responses/response_input_item_param.py
@@ -2,25 +2,49 @@
 
 from __future__ import annotations
 
-from typing import Union, Iterable
+from typing import Dict, Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from .easy_input_message_param import EasyInputMessageParam
 from .response_output_message_param import ResponseOutputMessageParam
 from .response_reasoning_item_param import ResponseReasoningItemParam
+from .response_custom_tool_call_param import ResponseCustomToolCallParam
 from .response_computer_tool_call_param import ResponseComputerToolCallParam
 from .response_function_tool_call_param import ResponseFunctionToolCallParam
 from .response_function_web_search_param import ResponseFunctionWebSearchParam
 from .response_file_search_tool_call_param import ResponseFileSearchToolCallParam
+from .response_custom_tool_call_output_param import ResponseCustomToolCallOutputParam
+from .response_code_interpreter_tool_call_param import ResponseCodeInterpreterToolCallParam
 from .response_input_message_content_list_param import ResponseInputMessageContentListParam
+from .response_function_call_output_item_list_param import ResponseFunctionCallOutputItemListParam
+from .response_function_shell_call_output_content_param import ResponseFunctionShellCallOutputContentParam
+from .response_computer_tool_call_output_screenshot_param import ResponseComputerToolCallOutputScreenshotParam
 
 __all__ = [
     "ResponseInputItemParam",
     "Message",
     "ComputerCallOutput",
-    "ComputerCallOutputOutput",
     "ComputerCallOutputAcknowledgedSafetyCheck",
     "FunctionCallOutput",
+    "ImageGenerationCall",
+    "LocalShellCall",
+    "LocalShellCallAction",
+    "LocalShellCallOutput",
+    "ShellCall",
+    "ShellCallAction",
+    "ShellCallOutput",
+    "ApplyPatchCall",
+    "ApplyPatchCallOperation",
+    "ApplyPatchCallOperationCreateFile",
+    "ApplyPatchCallOperationDeleteFile",
+    "ApplyPatchCallOperationUpdateFile",
+    "ApplyPatchCallOutput",
+    "McpListTools",
+    "McpListToolsTool",
+    "McpApprovalRequest",
+    "McpApprovalResponse",
+    "McpCall",
     "ItemReference",
 ]
 
@@ -46,28 +70,14 @@ class Message(TypedDict, total=False):
     """The type of the message input. Always set to `message`."""
 
 
-class ComputerCallOutputOutput(TypedDict, total=False):
-    type: Required[Literal["computer_screenshot"]]
-    """Specifies the event type.
-
-    For a computer screenshot, this property is always set to `computer_screenshot`.
-    """
-
-    file_id: str
-    """The identifier of an uploaded file that contains the screenshot."""
-
-    image_url: str
-    """The URL of the screenshot image."""
-
-
 class ComputerCallOutputAcknowledgedSafetyCheck(TypedDict, total=False):
     id: Required[str]
     """The ID of the pending safety check."""
 
-    code: Required[str]
+    code: Optional[str]
     """The type of the pending safety check."""
 
-    message: Required[str]
+    message: Optional[str]
     """Details about the pending safety check."""
 
 
@@ -75,22 +85,22 @@ class ComputerCallOutput(TypedDict, total=False):
     call_id: Required[str]
     """The ID of the computer tool call that produced the output."""
 
-    output: Required[ComputerCallOutputOutput]
+    output: Required[ResponseComputerToolCallOutputScreenshotParam]
     """A computer screenshot image used with the computer use tool."""
 
     type: Required[Literal["computer_call_output"]]
     """The type of the computer tool call output. Always `computer_call_output`."""
 
-    id: str
+    id: Optional[str]
     """The ID of the computer tool call output."""
 
-    acknowledged_safety_checks: Iterable[ComputerCallOutputAcknowledgedSafetyCheck]
+    acknowledged_safety_checks: Optional[Iterable[ComputerCallOutputAcknowledgedSafetyCheck]]
     """
     The safety checks reported by the API that have been acknowledged by the
     developer.
     """
 
-    status: Literal["in_progress", "completed", "incomplete"]
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
     """The status of the message input.
 
     One of `in_progress`, `completed`, or `incomplete`. Populated when input items
@@ -102,19 +112,19 @@ class FunctionCallOutput(TypedDict, total=False):
     call_id: Required[str]
     """The unique ID of the function tool call generated by the model."""
 
-    output: Required[str]
-    """A JSON string of the output of the function tool call."""
+    output: Required[Union[str, ResponseFunctionCallOutputItemListParam]]
+    """Text, image, or file output of the function tool call."""
 
     type: Required[Literal["function_call_output"]]
     """The type of the function tool call output. Always `function_call_output`."""
 
-    id: str
+    id: Optional[str]
     """The unique ID of the function tool call output.
 
     Populated when this item is returned via API.
     """
 
-    status: Literal["in_progress", "completed", "incomplete"]
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
     """The status of the item.
 
     One of `in_progress`, `completed`, or `incomplete`. Populated when items are
@@ -122,11 +132,321 @@ class FunctionCallOutput(TypedDict, total=False):
     """
 
 
+class ImageGenerationCall(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the image generation call."""
+
+    result: Required[Optional[str]]
+    """The generated image encoded in base64."""
+
+    status: Required[Literal["in_progress", "completed", "generating", "failed"]]
+    """The status of the image generation call."""
+
+    type: Required[Literal["image_generation_call"]]
+    """The type of the image generation call. Always `image_generation_call`."""
+
+
+class LocalShellCallAction(TypedDict, total=False):
+    command: Required[SequenceNotStr[str]]
+    """The command to run."""
+
+    env: Required[Dict[str, str]]
+    """Environment variables to set for the command."""
+
+    type: Required[Literal["exec"]]
+    """The type of the local shell action. Always `exec`."""
+
+    timeout_ms: Optional[int]
+    """Optional timeout in milliseconds for the command."""
+
+    user: Optional[str]
+    """Optional user to run the command as."""
+
+    working_directory: Optional[str]
+    """Optional working directory to run the command in."""
+
+
+class LocalShellCall(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the local shell call."""
+
+    action: Required[LocalShellCallAction]
+    """Execute a shell command on the server."""
+
+    call_id: Required[str]
+    """The unique ID of the local shell tool call generated by the model."""
+
+    status: Required[Literal["in_progress", "completed", "incomplete"]]
+    """The status of the local shell call."""
+
+    type: Required[Literal["local_shell_call"]]
+    """The type of the local shell call. Always `local_shell_call`."""
+
+
+class LocalShellCallOutput(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the local shell tool call generated by the model."""
+
+    output: Required[str]
+    """A JSON string of the output of the local shell tool call."""
+
+    type: Required[Literal["local_shell_call_output"]]
+    """The type of the local shell tool call output. Always `local_shell_call_output`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
+    """The status of the item. One of `in_progress`, `completed`, or `incomplete`."""
+
+
+class ShellCallAction(TypedDict, total=False):
+    commands: Required[SequenceNotStr[str]]
+    """Ordered shell commands for the execution environment to run."""
+
+    max_output_length: Optional[int]
+    """
+    Maximum number of UTF-8 characters to capture from combined stdout and stderr
+    output.
+    """
+
+    timeout_ms: Optional[int]
+    """Maximum wall-clock time in milliseconds to allow the shell commands to run."""
+
+
+class ShellCall(TypedDict, total=False):
+    action: Required[ShellCallAction]
+    """The shell commands and limits that describe how to run the tool call."""
+
+    call_id: Required[str]
+    """The unique ID of the function shell tool call generated by the model."""
+
+    type: Required[Literal["shell_call"]]
+    """The type of the item. Always `function_shell_call`."""
+
+    id: Optional[str]
+    """The unique ID of the function shell tool call.
+
+    Populated when this item is returned via API.
+    """
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
+    """The status of the shell call.
+
+    One of `in_progress`, `completed`, or `incomplete`.
+    """
+
+
+class ShellCallOutput(TypedDict, total=False):
+    call_id: Required[str]
+    """The unique ID of the function shell tool call generated by the model."""
+
+    output: Required[Iterable[ResponseFunctionShellCallOutputContentParam]]
+    """
+    Captured chunks of stdout and stderr output, along with their associated
+    outcomes.
+    """
+
+    type: Required[Literal["shell_call_output"]]
+    """The type of the item. Always `function_shell_call_output`."""
+
+    id: Optional[str]
+    """The unique ID of the function shell tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    max_output_length: Optional[int]
+    """
+    The maximum number of UTF-8 characters captured for this shell call's combined
+    output.
+    """
+
+
+class ApplyPatchCallOperationCreateFile(TypedDict, total=False):
+    diff: Required[str]
+    """Unified diff content to apply when creating the file."""
+
+    path: Required[str]
+    """Path of the file to create relative to the workspace root."""
+
+    type: Required[Literal["create_file"]]
+    """The operation type. Always `create_file`."""
+
+
+class ApplyPatchCallOperationDeleteFile(TypedDict, total=False):
+    path: Required[str]
+    """Path of the file to delete relative to the workspace root."""
+
+    type: Required[Literal["delete_file"]]
+    """The operation type. Always `delete_file`."""
+
+
+class ApplyPatchCallOperationUpdateFile(TypedDict, total=False):
+    diff: Required[str]
+    """Unified diff content to apply to the existing file."""
+
+    path: Required[str]
+    """Path of the file to update relative to the workspace root."""
+
+    type: Required[Literal["update_file"]]
+    """The operation type. Always `update_file`."""
+
+
+ApplyPatchCallOperation: TypeAlias = Union[
+    ApplyPatchCallOperationCreateFile, ApplyPatchCallOperationDeleteFile, ApplyPatchCallOperationUpdateFile
+]
+
+
+class ApplyPatchCall(TypedDict, total=False):
+    call_id: Required[str]
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    operation: Required[ApplyPatchCallOperation]
+    """
+    The specific create, delete, or update instruction for the apply_patch tool
+    call.
+    """
+
+    status: Required[Literal["in_progress", "completed"]]
+    """The status of the apply patch tool call. One of `in_progress` or `completed`."""
+
+    type: Required[Literal["apply_patch_call"]]
+    """The type of the item. Always `apply_patch_call`."""
+
+    id: Optional[str]
+    """The unique ID of the apply patch tool call.
+
+    Populated when this item is returned via API.
+    """
+
+
+class ApplyPatchCallOutput(TypedDict, total=False):
+    call_id: Required[str]
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    status: Required[Literal["completed", "failed"]]
+    """The status of the apply patch tool call output. One of `completed` or `failed`."""
+
+    type: Required[Literal["apply_patch_call_output"]]
+    """The type of the item. Always `apply_patch_call_output`."""
+
+    id: Optional[str]
+    """The unique ID of the apply patch tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    output: Optional[str]
+    """
+    Optional human-readable log text from the apply patch tool (e.g., patch results
+    or errors).
+    """
+
+
+class McpListToolsTool(TypedDict, total=False):
+    input_schema: Required[object]
+    """The JSON schema describing the tool's input."""
+
+    name: Required[str]
+    """The name of the tool."""
+
+    annotations: Optional[object]
+    """Additional annotations about the tool."""
+
+    description: Optional[str]
+    """The description of the tool."""
+
+
+class McpListTools(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the list."""
+
+    server_label: Required[str]
+    """The label of the MCP server."""
+
+    tools: Required[Iterable[McpListToolsTool]]
+    """The tools available on the server."""
+
+    type: Required[Literal["mcp_list_tools"]]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    error: Optional[str]
+    """Error message if the server could not list tools."""
+
+
+class McpApprovalRequest(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the approval request."""
+
+    arguments: Required[str]
+    """A JSON string of arguments for the tool."""
+
+    name: Required[str]
+    """The name of the tool to run."""
+
+    server_label: Required[str]
+    """The label of the MCP server making the request."""
+
+    type: Required[Literal["mcp_approval_request"]]
+    """The type of the item. Always `mcp_approval_request`."""
+
+
+class McpApprovalResponse(TypedDict, total=False):
+    approval_request_id: Required[str]
+    """The ID of the approval request being answered."""
+
+    approve: Required[bool]
+    """Whether the request was approved."""
+
+    type: Required[Literal["mcp_approval_response"]]
+    """The type of the item. Always `mcp_approval_response`."""
+
+    id: Optional[str]
+    """The unique ID of the approval response"""
+
+    reason: Optional[str]
+    """Optional reason for the decision."""
+
+
+class McpCall(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the tool call."""
+
+    arguments: Required[str]
+    """A JSON string of the arguments passed to the tool."""
+
+    name: Required[str]
+    """The name of the tool that was run."""
+
+    server_label: Required[str]
+    """The label of the MCP server running the tool."""
+
+    type: Required[Literal["mcp_call"]]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str]
+    """
+    Unique identifier for the MCP tool call approval request. Include this value in
+    a subsequent `mcp_approval_response` input to approve or reject the
+    corresponding tool call.
+    """
+
+    error: Optional[str]
+    """The error from the tool call, if any."""
+
+    output: Optional[str]
+    """The output from the tool call."""
+
+    status: Literal["in_progress", "completed", "incomplete", "calling", "failed"]
+    """The status of the tool call.
+
+    One of `in_progress`, `completed`, `incomplete`, `calling`, or `failed`.
+    """
+
+
 class ItemReference(TypedDict, total=False):
     id: Required[str]
     """The ID of the item to reference."""
 
-    type: Required[Literal["item_reference"]]
+    type: Optional[Literal["item_reference"]]
     """The type of item to reference. Always `item_reference`."""
 
 
@@ -141,5 +461,19 @@ class ItemReference(TypedDict, total=False):
     ResponseFunctionToolCallParam,
     FunctionCallOutput,
     ResponseReasoningItemParam,
+    ImageGenerationCall,
+    ResponseCodeInterpreterToolCallParam,
+    LocalShellCall,
+    LocalShellCallOutput,
+    ShellCall,
+    ShellCallOutput,
+    ApplyPatchCall,
+    ApplyPatchCallOutput,
+    McpListTools,
+    McpApprovalRequest,
+    McpApprovalResponse,
+    McpCall,
+    ResponseCustomToolCallOutputParam,
+    ResponseCustomToolCallParam,
     ItemReference,
 ]
diff --git a/src/openai/types/responses/response_input_message_item.py b/src/openai/types/responses/response_input_message_item.py
new file mode 100644
index 0000000000..6a788e7fa4
--- /dev/null
+++ b/src/openai/types/responses/response_input_message_item.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .response_input_message_content_list import ResponseInputMessageContentList
+
+__all__ = ["ResponseInputMessageItem"]
+
+
+class ResponseInputMessageItem(BaseModel):
+    id: str
+    """The unique ID of the message input."""
+
+    content: ResponseInputMessageContentList
+    """
+    A list of one or many input items to the model, containing different content
+    types.
+    """
+
+    role: Literal["user", "system", "developer"]
+    """The role of the message input. One of `user`, `system`, or `developer`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of item.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
+    returned via API.
+    """
+
+    type: Optional[Literal["message"]] = None
+    """The type of the message input. Always set to `message`."""
diff --git a/src/openai/types/responses/response_input_param.py b/src/openai/types/responses/response_input_param.py
index b942f4868a..365c6b3d7b 100644
--- a/src/openai/types/responses/response_input_param.py
+++ b/src/openai/types/responses/response_input_param.py
@@ -2,26 +2,50 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable
+from typing import Dict, List, Union, Iterable, Optional
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from .easy_input_message_param import EasyInputMessageParam
 from .response_output_message_param import ResponseOutputMessageParam
 from .response_reasoning_item_param import ResponseReasoningItemParam
+from .response_custom_tool_call_param import ResponseCustomToolCallParam
 from .response_computer_tool_call_param import ResponseComputerToolCallParam
 from .response_function_tool_call_param import ResponseFunctionToolCallParam
 from .response_function_web_search_param import ResponseFunctionWebSearchParam
 from .response_file_search_tool_call_param import ResponseFileSearchToolCallParam
+from .response_custom_tool_call_output_param import ResponseCustomToolCallOutputParam
+from .response_code_interpreter_tool_call_param import ResponseCodeInterpreterToolCallParam
 from .response_input_message_content_list_param import ResponseInputMessageContentListParam
+from .response_function_call_output_item_list_param import ResponseFunctionCallOutputItemListParam
+from .response_function_shell_call_output_content_param import ResponseFunctionShellCallOutputContentParam
+from .response_computer_tool_call_output_screenshot_param import ResponseComputerToolCallOutputScreenshotParam
 
 __all__ = [
     "ResponseInputParam",
     "ResponseInputItemParam",
     "Message",
     "ComputerCallOutput",
-    "ComputerCallOutputOutput",
     "ComputerCallOutputAcknowledgedSafetyCheck",
     "FunctionCallOutput",
+    "ImageGenerationCall",
+    "LocalShellCall",
+    "LocalShellCallAction",
+    "LocalShellCallOutput",
+    "ShellCall",
+    "ShellCallAction",
+    "ShellCallOutput",
+    "ApplyPatchCall",
+    "ApplyPatchCallOperation",
+    "ApplyPatchCallOperationCreateFile",
+    "ApplyPatchCallOperationDeleteFile",
+    "ApplyPatchCallOperationUpdateFile",
+    "ApplyPatchCallOutput",
+    "McpListTools",
+    "McpListToolsTool",
+    "McpApprovalRequest",
+    "McpApprovalResponse",
+    "McpCall",
     "ItemReference",
 ]
 
@@ -47,28 +71,14 @@ class Message(TypedDict, total=False):
     """The type of the message input. Always set to `message`."""
 
 
-class ComputerCallOutputOutput(TypedDict, total=False):
-    type: Required[Literal["computer_screenshot"]]
-    """Specifies the event type.
-
-    For a computer screenshot, this property is always set to `computer_screenshot`.
-    """
-
-    file_id: str
-    """The identifier of an uploaded file that contains the screenshot."""
-
-    image_url: str
-    """The URL of the screenshot image."""
-
-
 class ComputerCallOutputAcknowledgedSafetyCheck(TypedDict, total=False):
     id: Required[str]
     """The ID of the pending safety check."""
 
-    code: Required[str]
+    code: Optional[str]
     """The type of the pending safety check."""
 
-    message: Required[str]
+    message: Optional[str]
     """Details about the pending safety check."""
 
 
@@ -76,22 +86,22 @@ class ComputerCallOutput(TypedDict, total=False):
     call_id: Required[str]
     """The ID of the computer tool call that produced the output."""
 
-    output: Required[ComputerCallOutputOutput]
+    output: Required[ResponseComputerToolCallOutputScreenshotParam]
     """A computer screenshot image used with the computer use tool."""
 
     type: Required[Literal["computer_call_output"]]
     """The type of the computer tool call output. Always `computer_call_output`."""
 
-    id: str
+    id: Optional[str]
     """The ID of the computer tool call output."""
 
-    acknowledged_safety_checks: Iterable[ComputerCallOutputAcknowledgedSafetyCheck]
+    acknowledged_safety_checks: Optional[Iterable[ComputerCallOutputAcknowledgedSafetyCheck]]
     """
     The safety checks reported by the API that have been acknowledged by the
     developer.
     """
 
-    status: Literal["in_progress", "completed", "incomplete"]
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
     """The status of the message input.
 
     One of `in_progress`, `completed`, or `incomplete`. Populated when input items
@@ -103,19 +113,19 @@ class FunctionCallOutput(TypedDict, total=False):
     call_id: Required[str]
     """The unique ID of the function tool call generated by the model."""
 
-    output: Required[str]
-    """A JSON string of the output of the function tool call."""
+    output: Required[Union[str, ResponseFunctionCallOutputItemListParam]]
+    """Text, image, or file output of the function tool call."""
 
     type: Required[Literal["function_call_output"]]
     """The type of the function tool call output. Always `function_call_output`."""
 
-    id: str
+    id: Optional[str]
     """The unique ID of the function tool call output.
 
     Populated when this item is returned via API.
     """
 
-    status: Literal["in_progress", "completed", "incomplete"]
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
     """The status of the item.
 
     One of `in_progress`, `completed`, or `incomplete`. Populated when items are
@@ -123,11 +133,321 @@ class FunctionCallOutput(TypedDict, total=False):
     """
 
 
+class ImageGenerationCall(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the image generation call."""
+
+    result: Required[Optional[str]]
+    """The generated image encoded in base64."""
+
+    status: Required[Literal["in_progress", "completed", "generating", "failed"]]
+    """The status of the image generation call."""
+
+    type: Required[Literal["image_generation_call"]]
+    """The type of the image generation call. Always `image_generation_call`."""
+
+
+class LocalShellCallAction(TypedDict, total=False):
+    command: Required[SequenceNotStr[str]]
+    """The command to run."""
+
+    env: Required[Dict[str, str]]
+    """Environment variables to set for the command."""
+
+    type: Required[Literal["exec"]]
+    """The type of the local shell action. Always `exec`."""
+
+    timeout_ms: Optional[int]
+    """Optional timeout in milliseconds for the command."""
+
+    user: Optional[str]
+    """Optional user to run the command as."""
+
+    working_directory: Optional[str]
+    """Optional working directory to run the command in."""
+
+
+class LocalShellCall(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the local shell call."""
+
+    action: Required[LocalShellCallAction]
+    """Execute a shell command on the server."""
+
+    call_id: Required[str]
+    """The unique ID of the local shell tool call generated by the model."""
+
+    status: Required[Literal["in_progress", "completed", "incomplete"]]
+    """The status of the local shell call."""
+
+    type: Required[Literal["local_shell_call"]]
+    """The type of the local shell call. Always `local_shell_call`."""
+
+
+class LocalShellCallOutput(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the local shell tool call generated by the model."""
+
+    output: Required[str]
+    """A JSON string of the output of the local shell tool call."""
+
+    type: Required[Literal["local_shell_call_output"]]
+    """The type of the local shell tool call output. Always `local_shell_call_output`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
+    """The status of the item. One of `in_progress`, `completed`, or `incomplete`."""
+
+
+class ShellCallAction(TypedDict, total=False):
+    commands: Required[SequenceNotStr[str]]
+    """Ordered shell commands for the execution environment to run."""
+
+    max_output_length: Optional[int]
+    """
+    Maximum number of UTF-8 characters to capture from combined stdout and stderr
+    output.
+    """
+
+    timeout_ms: Optional[int]
+    """Maximum wall-clock time in milliseconds to allow the shell commands to run."""
+
+
+class ShellCall(TypedDict, total=False):
+    action: Required[ShellCallAction]
+    """The shell commands and limits that describe how to run the tool call."""
+
+    call_id: Required[str]
+    """The unique ID of the function shell tool call generated by the model."""
+
+    type: Required[Literal["shell_call"]]
+    """The type of the item. Always `function_shell_call`."""
+
+    id: Optional[str]
+    """The unique ID of the function shell tool call.
+
+    Populated when this item is returned via API.
+    """
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]]
+    """The status of the shell call.
+
+    One of `in_progress`, `completed`, or `incomplete`.
+    """
+
+
+class ShellCallOutput(TypedDict, total=False):
+    call_id: Required[str]
+    """The unique ID of the function shell tool call generated by the model."""
+
+    output: Required[Iterable[ResponseFunctionShellCallOutputContentParam]]
+    """
+    Captured chunks of stdout and stderr output, along with their associated
+    outcomes.
+    """
+
+    type: Required[Literal["shell_call_output"]]
+    """The type of the item. Always `function_shell_call_output`."""
+
+    id: Optional[str]
+    """The unique ID of the function shell tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    max_output_length: Optional[int]
+    """
+    The maximum number of UTF-8 characters captured for this shell call's combined
+    output.
+    """
+
+
+class ApplyPatchCallOperationCreateFile(TypedDict, total=False):
+    diff: Required[str]
+    """Unified diff content to apply when creating the file."""
+
+    path: Required[str]
+    """Path of the file to create relative to the workspace root."""
+
+    type: Required[Literal["create_file"]]
+    """The operation type. Always `create_file`."""
+
+
+class ApplyPatchCallOperationDeleteFile(TypedDict, total=False):
+    path: Required[str]
+    """Path of the file to delete relative to the workspace root."""
+
+    type: Required[Literal["delete_file"]]
+    """The operation type. Always `delete_file`."""
+
+
+class ApplyPatchCallOperationUpdateFile(TypedDict, total=False):
+    diff: Required[str]
+    """Unified diff content to apply to the existing file."""
+
+    path: Required[str]
+    """Path of the file to update relative to the workspace root."""
+
+    type: Required[Literal["update_file"]]
+    """The operation type. Always `update_file`."""
+
+
+ApplyPatchCallOperation: TypeAlias = Union[
+    ApplyPatchCallOperationCreateFile, ApplyPatchCallOperationDeleteFile, ApplyPatchCallOperationUpdateFile
+]
+
+
+class ApplyPatchCall(TypedDict, total=False):
+    call_id: Required[str]
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    operation: Required[ApplyPatchCallOperation]
+    """
+    The specific create, delete, or update instruction for the apply_patch tool
+    call.
+    """
+
+    status: Required[Literal["in_progress", "completed"]]
+    """The status of the apply patch tool call. One of `in_progress` or `completed`."""
+
+    type: Required[Literal["apply_patch_call"]]
+    """The type of the item. Always `apply_patch_call`."""
+
+    id: Optional[str]
+    """The unique ID of the apply patch tool call.
+
+    Populated when this item is returned via API.
+    """
+
+
+class ApplyPatchCallOutput(TypedDict, total=False):
+    call_id: Required[str]
+    """The unique ID of the apply patch tool call generated by the model."""
+
+    status: Required[Literal["completed", "failed"]]
+    """The status of the apply patch tool call output. One of `completed` or `failed`."""
+
+    type: Required[Literal["apply_patch_call_output"]]
+    """The type of the item. Always `apply_patch_call_output`."""
+
+    id: Optional[str]
+    """The unique ID of the apply patch tool call output.
+
+    Populated when this item is returned via API.
+    """
+
+    output: Optional[str]
+    """
+    Optional human-readable log text from the apply patch tool (e.g., patch results
+    or errors).
+    """
+
+
+class McpListToolsTool(TypedDict, total=False):
+    input_schema: Required[object]
+    """The JSON schema describing the tool's input."""
+
+    name: Required[str]
+    """The name of the tool."""
+
+    annotations: Optional[object]
+    """Additional annotations about the tool."""
+
+    description: Optional[str]
+    """The description of the tool."""
+
+
+class McpListTools(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the list."""
+
+    server_label: Required[str]
+    """The label of the MCP server."""
+
+    tools: Required[Iterable[McpListToolsTool]]
+    """The tools available on the server."""
+
+    type: Required[Literal["mcp_list_tools"]]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    error: Optional[str]
+    """Error message if the server could not list tools."""
+
+
+class McpApprovalRequest(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the approval request."""
+
+    arguments: Required[str]
+    """A JSON string of arguments for the tool."""
+
+    name: Required[str]
+    """The name of the tool to run."""
+
+    server_label: Required[str]
+    """The label of the MCP server making the request."""
+
+    type: Required[Literal["mcp_approval_request"]]
+    """The type of the item. Always `mcp_approval_request`."""
+
+
+class McpApprovalResponse(TypedDict, total=False):
+    approval_request_id: Required[str]
+    """The ID of the approval request being answered."""
+
+    approve: Required[bool]
+    """Whether the request was approved."""
+
+    type: Required[Literal["mcp_approval_response"]]
+    """The type of the item. Always `mcp_approval_response`."""
+
+    id: Optional[str]
+    """The unique ID of the approval response"""
+
+    reason: Optional[str]
+    """Optional reason for the decision."""
+
+
+class McpCall(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the tool call."""
+
+    arguments: Required[str]
+    """A JSON string of the arguments passed to the tool."""
+
+    name: Required[str]
+    """The name of the tool that was run."""
+
+    server_label: Required[str]
+    """The label of the MCP server running the tool."""
+
+    type: Required[Literal["mcp_call"]]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str]
+    """
+    Unique identifier for the MCP tool call approval request. Include this value in
+    a subsequent `mcp_approval_response` input to approve or reject the
+    corresponding tool call.
+    """
+
+    error: Optional[str]
+    """The error from the tool call, if any."""
+
+    output: Optional[str]
+    """The output from the tool call."""
+
+    status: Literal["in_progress", "completed", "incomplete", "calling", "failed"]
+    """The status of the tool call.
+
+    One of `in_progress`, `completed`, `incomplete`, `calling`, or `failed`.
+    """
+
+
 class ItemReference(TypedDict, total=False):
     id: Required[str]
     """The ID of the item to reference."""
 
-    type: Required[Literal["item_reference"]]
+    type: Optional[Literal["item_reference"]]
     """The type of item to reference. Always `item_reference`."""
 
 
@@ -142,6 +462,20 @@ class ItemReference(TypedDict, total=False):
     ResponseFunctionToolCallParam,
     FunctionCallOutput,
     ResponseReasoningItemParam,
+    ImageGenerationCall,
+    ResponseCodeInterpreterToolCallParam,
+    LocalShellCall,
+    LocalShellCallOutput,
+    ShellCall,
+    ShellCallOutput,
+    ApplyPatchCall,
+    ApplyPatchCallOutput,
+    McpListTools,
+    McpApprovalRequest,
+    McpApprovalResponse,
+    McpCall,
+    ResponseCustomToolCallOutputParam,
+    ResponseCustomToolCallParam,
     ItemReference,
 ]
 
diff --git a/src/openai/types/responses/response_input_text_content.py b/src/openai/types/responses/response_input_text_content.py
new file mode 100644
index 0000000000..2cce849855
--- /dev/null
+++ b/src/openai/types/responses/response_input_text_content.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseInputTextContent"]
+
+
+class ResponseInputTextContent(BaseModel):
+    text: str
+    """The text input to the model."""
+
+    type: Literal["input_text"]
+    """The type of the input item. Always `input_text`."""
diff --git a/src/openai/types/responses/response_input_text_content_param.py b/src/openai/types/responses/response_input_text_content_param.py
new file mode 100644
index 0000000000..85b57df2bd
--- /dev/null
+++ b/src/openai/types/responses/response_input_text_content_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ResponseInputTextContentParam"]
+
+
+class ResponseInputTextContentParam(TypedDict, total=False):
+    text: Required[str]
+    """The text input to the model."""
+
+    type: Required[Literal["input_text"]]
+    """The type of the input item. Always `input_text`."""
diff --git a/src/openai/types/responses/response_item.py b/src/openai/types/responses/response_item.py
new file mode 100644
index 0000000000..5ae2405988
--- /dev/null
+++ b/src/openai/types/responses/response_item.py
@@ -0,0 +1,226 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .response_output_message import ResponseOutputMessage
+from .response_computer_tool_call import ResponseComputerToolCall
+from .response_input_message_item import ResponseInputMessageItem
+from .response_function_web_search import ResponseFunctionWebSearch
+from .response_apply_patch_tool_call import ResponseApplyPatchToolCall
+from .response_file_search_tool_call import ResponseFileSearchToolCall
+from .response_function_tool_call_item import ResponseFunctionToolCallItem
+from .response_function_shell_tool_call import ResponseFunctionShellToolCall
+from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
+from .response_apply_patch_tool_call_output import ResponseApplyPatchToolCallOutput
+from .response_computer_tool_call_output_item import ResponseComputerToolCallOutputItem
+from .response_function_tool_call_output_item import ResponseFunctionToolCallOutputItem
+from .response_function_shell_tool_call_output import ResponseFunctionShellToolCallOutput
+
+__all__ = [
+    "ResponseItem",
+    "ImageGenerationCall",
+    "LocalShellCall",
+    "LocalShellCallAction",
+    "LocalShellCallOutput",
+    "McpListTools",
+    "McpListToolsTool",
+    "McpApprovalRequest",
+    "McpApprovalResponse",
+    "McpCall",
+]
+
+
+class ImageGenerationCall(BaseModel):
+    id: str
+    """The unique ID of the image generation call."""
+
+    result: Optional[str] = None
+    """The generated image encoded in base64."""
+
+    status: Literal["in_progress", "completed", "generating", "failed"]
+    """The status of the image generation call."""
+
+    type: Literal["image_generation_call"]
+    """The type of the image generation call. Always `image_generation_call`."""
+
+
+class LocalShellCallAction(BaseModel):
+    command: List[str]
+    """The command to run."""
+
+    env: Dict[str, str]
+    """Environment variables to set for the command."""
+
+    type: Literal["exec"]
+    """The type of the local shell action. Always `exec`."""
+
+    timeout_ms: Optional[int] = None
+    """Optional timeout in milliseconds for the command."""
+
+    user: Optional[str] = None
+    """Optional user to run the command as."""
+
+    working_directory: Optional[str] = None
+    """Optional working directory to run the command in."""
+
+
+class LocalShellCall(BaseModel):
+    id: str
+    """The unique ID of the local shell call."""
+
+    action: LocalShellCallAction
+    """Execute a shell command on the server."""
+
+    call_id: str
+    """The unique ID of the local shell tool call generated by the model."""
+
+    status: Literal["in_progress", "completed", "incomplete"]
+    """The status of the local shell call."""
+
+    type: Literal["local_shell_call"]
+    """The type of the local shell call. Always `local_shell_call`."""
+
+
+class LocalShellCallOutput(BaseModel):
+    id: str
+    """The unique ID of the local shell tool call generated by the model."""
+
+    output: str
+    """A JSON string of the output of the local shell tool call."""
+
+    type: Literal["local_shell_call_output"]
+    """The type of the local shell tool call output. Always `local_shell_call_output`."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the item. One of `in_progress`, `completed`, or `incomplete`."""
+
+
+class McpListToolsTool(BaseModel):
+    input_schema: object
+    """The JSON schema describing the tool's input."""
+
+    name: str
+    """The name of the tool."""
+
+    annotations: Optional[object] = None
+    """Additional annotations about the tool."""
+
+    description: Optional[str] = None
+    """The description of the tool."""
+
+
+class McpListTools(BaseModel):
+    id: str
+    """The unique ID of the list."""
+
+    server_label: str
+    """The label of the MCP server."""
+
+    tools: List[McpListToolsTool]
+    """The tools available on the server."""
+
+    type: Literal["mcp_list_tools"]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    error: Optional[str] = None
+    """Error message if the server could not list tools."""
+
+
+class McpApprovalRequest(BaseModel):
+    id: str
+    """The unique ID of the approval request."""
+
+    arguments: str
+    """A JSON string of arguments for the tool."""
+
+    name: str
+    """The name of the tool to run."""
+
+    server_label: str
+    """The label of the MCP server making the request."""
+
+    type: Literal["mcp_approval_request"]
+    """The type of the item. Always `mcp_approval_request`."""
+
+
+class McpApprovalResponse(BaseModel):
+    id: str
+    """The unique ID of the approval response"""
+
+    approval_request_id: str
+    """The ID of the approval request being answered."""
+
+    approve: bool
+    """Whether the request was approved."""
+
+    type: Literal["mcp_approval_response"]
+    """The type of the item. Always `mcp_approval_response`."""
+
+    reason: Optional[str] = None
+    """Optional reason for the decision."""
+
+
+class McpCall(BaseModel):
+    id: str
+    """The unique ID of the tool call."""
+
+    arguments: str
+    """A JSON string of the arguments passed to the tool."""
+
+    name: str
+    """The name of the tool that was run."""
+
+    server_label: str
+    """The label of the MCP server running the tool."""
+
+    type: Literal["mcp_call"]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str] = None
+    """
+    Unique identifier for the MCP tool call approval request. Include this value in
+    a subsequent `mcp_approval_response` input to approve or reject the
+    corresponding tool call.
+    """
+
+    error: Optional[str] = None
+    """The error from the tool call, if any."""
+
+    output: Optional[str] = None
+    """The output from the tool call."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete", "calling", "failed"]] = None
+    """The status of the tool call.
+
+    One of `in_progress`, `completed`, `incomplete`, `calling`, or `failed`.
+    """
+
+
+ResponseItem: TypeAlias = Annotated[
+    Union[
+        ResponseInputMessageItem,
+        ResponseOutputMessage,
+        ResponseFileSearchToolCall,
+        ResponseComputerToolCall,
+        ResponseComputerToolCallOutputItem,
+        ResponseFunctionWebSearch,
+        ResponseFunctionToolCallItem,
+        ResponseFunctionToolCallOutputItem,
+        ImageGenerationCall,
+        ResponseCodeInterpreterToolCall,
+        LocalShellCall,
+        LocalShellCallOutput,
+        ResponseFunctionShellToolCall,
+        ResponseFunctionShellToolCallOutput,
+        ResponseApplyPatchToolCall,
+        ResponseApplyPatchToolCallOutput,
+        McpListTools,
+        McpApprovalRequest,
+        McpApprovalResponse,
+        McpCall,
+    ],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/src/openai/types/responses/response_item_list.py b/src/openai/types/responses/response_item_list.py
index 7c3e4d7f82..b43eacdb51 100644
--- a/src/openai/types/responses/response_item_list.py
+++ b/src/openai/types/responses/response_item_list.py
@@ -1,142 +1,16 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Union, Optional
-from typing_extensions import Literal, Annotated, TypeAlias
+from typing import List
+from typing_extensions import Literal
 
-from ..._utils import PropertyInfo
 from ..._models import BaseModel
-from .response_output_message import ResponseOutputMessage
-from .response_computer_tool_call import ResponseComputerToolCall
-from .response_function_tool_call import ResponseFunctionToolCall
-from .response_function_web_search import ResponseFunctionWebSearch
-from .response_file_search_tool_call import ResponseFileSearchToolCall
-from .response_input_message_content_list import ResponseInputMessageContentList
+from .response_item import ResponseItem
 
-__all__ = [
-    "ResponseItemList",
-    "Data",
-    "DataMessage",
-    "DataComputerCallOutput",
-    "DataComputerCallOutputOutput",
-    "DataComputerCallOutputAcknowledgedSafetyCheck",
-    "DataFunctionCallOutput",
-]
-
-
-class DataMessage(BaseModel):
-    id: str
-    """The unique ID of the message input."""
-
-    content: ResponseInputMessageContentList
-    """
-    A list of one or many input items to the model, containing different content
-    types.
-    """
-
-    role: Literal["user", "system", "developer"]
-    """The role of the message input. One of `user`, `system`, or `developer`."""
-
-    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
-    """The status of item.
-
-    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
-    returned via API.
-    """
-
-    type: Optional[Literal["message"]] = None
-    """The type of the message input. Always set to `message`."""
-
-
-class DataComputerCallOutputOutput(BaseModel):
-    type: Literal["computer_screenshot"]
-    """Specifies the event type.
-
-    For a computer screenshot, this property is always set to `computer_screenshot`.
-    """
-
-    file_id: Optional[str] = None
-    """The identifier of an uploaded file that contains the screenshot."""
-
-    image_url: Optional[str] = None
-    """The URL of the screenshot image."""
-
-
-class DataComputerCallOutputAcknowledgedSafetyCheck(BaseModel):
-    id: str
-    """The ID of the pending safety check."""
-
-    code: str
-    """The type of the pending safety check."""
-
-    message: str
-    """Details about the pending safety check."""
-
-
-class DataComputerCallOutput(BaseModel):
-    id: str
-    """The unique ID of the computer call tool output."""
-
-    call_id: str
-    """The ID of the computer tool call that produced the output."""
-
-    output: DataComputerCallOutputOutput
-    """A computer screenshot image used with the computer use tool."""
-
-    type: Literal["computer_call_output"]
-    """The type of the computer tool call output. Always `computer_call_output`."""
-
-    acknowledged_safety_checks: Optional[List[DataComputerCallOutputAcknowledgedSafetyCheck]] = None
-    """
-    The safety checks reported by the API that have been acknowledged by the
-    developer.
-    """
-
-    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
-    """The status of the message input.
-
-    One of `in_progress`, `completed`, or `incomplete`. Populated when input items
-    are returned via API.
-    """
-
-
-class DataFunctionCallOutput(BaseModel):
-    id: str
-    """The unique ID of the function call tool output."""
-
-    call_id: str
-    """The unique ID of the function tool call generated by the model."""
-
-    output: str
-    """A JSON string of the output of the function tool call."""
-
-    type: Literal["function_call_output"]
-    """The type of the function tool call output. Always `function_call_output`."""
-
-    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
-    """The status of the item.
-
-    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
-    returned via API.
-    """
-
-
-Data: TypeAlias = Annotated[
-    Union[
-        DataMessage,
-        ResponseOutputMessage,
-        ResponseFileSearchToolCall,
-        ResponseComputerToolCall,
-        DataComputerCallOutput,
-        ResponseFunctionWebSearch,
-        ResponseFunctionToolCall,
-        DataFunctionCallOutput,
-    ],
-    PropertyInfo(discriminator="type"),
-]
+__all__ = ["ResponseItemList"]
 
 
 class ResponseItemList(BaseModel):
-    data: List[Data]
+    data: List[ResponseItem]
     """A list of items used to generate this response."""
 
     first_id: str
diff --git a/src/openai/types/responses/response_mcp_call_arguments_delta_event.py b/src/openai/types/responses/response_mcp_call_arguments_delta_event.py
new file mode 100644
index 0000000000..54eff38373
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_call_arguments_delta_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallArgumentsDeltaEvent"]
+
+
+class ResponseMcpCallArgumentsDeltaEvent(BaseModel):
+    delta: str
+    """
+    A JSON string containing the partial update to the arguments for the MCP tool
+    call.
+    """
+
+    item_id: str
+    """The unique identifier of the MCP tool call item being processed."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_call_arguments.delta"]
+    """The type of the event. Always 'response.mcp_call_arguments.delta'."""
diff --git a/src/openai/types/responses/response_mcp_call_arguments_done_event.py b/src/openai/types/responses/response_mcp_call_arguments_done_event.py
new file mode 100644
index 0000000000..59ce9bc944
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_call_arguments_done_event.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallArgumentsDoneEvent"]
+
+
+class ResponseMcpCallArgumentsDoneEvent(BaseModel):
+    arguments: str
+    """A JSON string containing the finalized arguments for the MCP tool call."""
+
+    item_id: str
+    """The unique identifier of the MCP tool call item being processed."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_call_arguments.done"]
+    """The type of the event. Always 'response.mcp_call_arguments.done'."""
diff --git a/src/openai/types/responses/response_mcp_call_completed_event.py b/src/openai/types/responses/response_mcp_call_completed_event.py
new file mode 100644
index 0000000000..2fee5dff81
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_call_completed_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallCompletedEvent"]
+
+
+class ResponseMcpCallCompletedEvent(BaseModel):
+    item_id: str
+    """The ID of the MCP tool call item that completed."""
+
+    output_index: int
+    """The index of the output item that completed."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_call.completed"]
+    """The type of the event. Always 'response.mcp_call.completed'."""
diff --git a/src/openai/types/responses/response_mcp_call_failed_event.py b/src/openai/types/responses/response_mcp_call_failed_event.py
new file mode 100644
index 0000000000..ca41ab7159
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_call_failed_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallFailedEvent"]
+
+
+class ResponseMcpCallFailedEvent(BaseModel):
+    item_id: str
+    """The ID of the MCP tool call item that failed."""
+
+    output_index: int
+    """The index of the output item that failed."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_call.failed"]
+    """The type of the event. Always 'response.mcp_call.failed'."""
diff --git a/src/openai/types/responses/response_mcp_call_in_progress_event.py b/src/openai/types/responses/response_mcp_call_in_progress_event.py
new file mode 100644
index 0000000000..401c316851
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_call_in_progress_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpCallInProgressEvent"]
+
+
+class ResponseMcpCallInProgressEvent(BaseModel):
+    item_id: str
+    """The unique identifier of the MCP tool call item being processed."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_call.in_progress"]
+    """The type of the event. Always 'response.mcp_call.in_progress'."""
diff --git a/src/openai/types/responses/response_mcp_list_tools_completed_event.py b/src/openai/types/responses/response_mcp_list_tools_completed_event.py
new file mode 100644
index 0000000000..c60ad88ee5
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_list_tools_completed_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpListToolsCompletedEvent"]
+
+
+class ResponseMcpListToolsCompletedEvent(BaseModel):
+    item_id: str
+    """The ID of the MCP tool call item that produced this output."""
+
+    output_index: int
+    """The index of the output item that was processed."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_list_tools.completed"]
+    """The type of the event. Always 'response.mcp_list_tools.completed'."""
diff --git a/src/openai/types/responses/response_mcp_list_tools_failed_event.py b/src/openai/types/responses/response_mcp_list_tools_failed_event.py
new file mode 100644
index 0000000000..0c966c447a
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_list_tools_failed_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpListToolsFailedEvent"]
+
+
+class ResponseMcpListToolsFailedEvent(BaseModel):
+    item_id: str
+    """The ID of the MCP tool call item that failed."""
+
+    output_index: int
+    """The index of the output item that failed."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_list_tools.failed"]
+    """The type of the event. Always 'response.mcp_list_tools.failed'."""
diff --git a/src/openai/types/responses/response_mcp_list_tools_in_progress_event.py b/src/openai/types/responses/response_mcp_list_tools_in_progress_event.py
new file mode 100644
index 0000000000..f451db1ed5
--- /dev/null
+++ b/src/openai/types/responses/response_mcp_list_tools_in_progress_event.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseMcpListToolsInProgressEvent"]
+
+
+class ResponseMcpListToolsInProgressEvent(BaseModel):
+    item_id: str
+    """The ID of the MCP tool call item that is being processed."""
+
+    output_index: int
+    """The index of the output item that is being processed."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.mcp_list_tools.in_progress"]
+    """The type of the event. Always 'response.mcp_list_tools.in_progress'."""
diff --git a/src/openai/types/responses/response_output_item.py b/src/openai/types/responses/response_output_item.py
index f1e9693195..906ddbb25e 100644
--- a/src/openai/types/responses/response_output_item.py
+++ b/src/openai/types/responses/response_output_item.py
@@ -1,17 +1,169 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Union
-from typing_extensions import Annotated, TypeAlias
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
 
 from ..._utils import PropertyInfo
+from ..._models import BaseModel
 from .response_output_message import ResponseOutputMessage
 from .response_reasoning_item import ResponseReasoningItem
+from .response_custom_tool_call import ResponseCustomToolCall
 from .response_computer_tool_call import ResponseComputerToolCall
 from .response_function_tool_call import ResponseFunctionToolCall
 from .response_function_web_search import ResponseFunctionWebSearch
+from .response_apply_patch_tool_call import ResponseApplyPatchToolCall
 from .response_file_search_tool_call import ResponseFileSearchToolCall
+from .response_function_shell_tool_call import ResponseFunctionShellToolCall
+from .response_code_interpreter_tool_call import ResponseCodeInterpreterToolCall
+from .response_apply_patch_tool_call_output import ResponseApplyPatchToolCallOutput
+from .response_function_shell_tool_call_output import ResponseFunctionShellToolCallOutput
+
+__all__ = [
+    "ResponseOutputItem",
+    "ImageGenerationCall",
+    "LocalShellCall",
+    "LocalShellCallAction",
+    "McpCall",
+    "McpListTools",
+    "McpListToolsTool",
+    "McpApprovalRequest",
+]
+
+
+class ImageGenerationCall(BaseModel):
+    id: str
+    """The unique ID of the image generation call."""
+
+    result: Optional[str] = None
+    """The generated image encoded in base64."""
+
+    status: Literal["in_progress", "completed", "generating", "failed"]
+    """The status of the image generation call."""
+
+    type: Literal["image_generation_call"]
+    """The type of the image generation call. Always `image_generation_call`."""
+
+
+class LocalShellCallAction(BaseModel):
+    command: List[str]
+    """The command to run."""
+
+    env: Dict[str, str]
+    """Environment variables to set for the command."""
+
+    type: Literal["exec"]
+    """The type of the local shell action. Always `exec`."""
+
+    timeout_ms: Optional[int] = None
+    """Optional timeout in milliseconds for the command."""
+
+    user: Optional[str] = None
+    """Optional user to run the command as."""
+
+    working_directory: Optional[str] = None
+    """Optional working directory to run the command in."""
+
+
+class LocalShellCall(BaseModel):
+    id: str
+    """The unique ID of the local shell call."""
+
+    action: LocalShellCallAction
+    """Execute a shell command on the server."""
+
+    call_id: str
+    """The unique ID of the local shell tool call generated by the model."""
+
+    status: Literal["in_progress", "completed", "incomplete"]
+    """The status of the local shell call."""
+
+    type: Literal["local_shell_call"]
+    """The type of the local shell call. Always `local_shell_call`."""
+
+
+class McpCall(BaseModel):
+    id: str
+    """The unique ID of the tool call."""
+
+    arguments: str
+    """A JSON string of the arguments passed to the tool."""
+
+    name: str
+    """The name of the tool that was run."""
+
+    server_label: str
+    """The label of the MCP server running the tool."""
+
+    type: Literal["mcp_call"]
+    """The type of the item. Always `mcp_call`."""
+
+    approval_request_id: Optional[str] = None
+    """
+    Unique identifier for the MCP tool call approval request. Include this value in
+    a subsequent `mcp_approval_response` input to approve or reject the
+    corresponding tool call.
+    """
+
+    error: Optional[str] = None
+    """The error from the tool call, if any."""
+
+    output: Optional[str] = None
+    """The output from the tool call."""
+
+    status: Optional[Literal["in_progress", "completed", "incomplete", "calling", "failed"]] = None
+    """The status of the tool call.
+
+    One of `in_progress`, `completed`, `incomplete`, `calling`, or `failed`.
+    """
+
+
+class McpListToolsTool(BaseModel):
+    input_schema: object
+    """The JSON schema describing the tool's input."""
+
+    name: str
+    """The name of the tool."""
+
+    annotations: Optional[object] = None
+    """Additional annotations about the tool."""
+
+    description: Optional[str] = None
+    """The description of the tool."""
+
+
+class McpListTools(BaseModel):
+    id: str
+    """The unique ID of the list."""
+
+    server_label: str
+    """The label of the MCP server."""
+
+    tools: List[McpListToolsTool]
+    """The tools available on the server."""
+
+    type: Literal["mcp_list_tools"]
+    """The type of the item. Always `mcp_list_tools`."""
+
+    error: Optional[str] = None
+    """Error message if the server could not list tools."""
+
+
+class McpApprovalRequest(BaseModel):
+    id: str
+    """The unique ID of the approval request."""
+
+    arguments: str
+    """A JSON string of arguments for the tool."""
+
+    name: str
+    """The name of the tool to run."""
+
+    server_label: str
+    """The label of the MCP server making the request."""
+
+    type: Literal["mcp_approval_request"]
+    """The type of the item. Always `mcp_approval_request`."""
 
-__all__ = ["ResponseOutputItem"]
 
 ResponseOutputItem: TypeAlias = Annotated[
     Union[
@@ -21,6 +173,17 @@
         ResponseFunctionWebSearch,
         ResponseComputerToolCall,
         ResponseReasoningItem,
+        ImageGenerationCall,
+        ResponseCodeInterpreterToolCall,
+        LocalShellCall,
+        ResponseFunctionShellToolCall,
+        ResponseFunctionShellToolCallOutput,
+        ResponseApplyPatchToolCall,
+        ResponseApplyPatchToolCallOutput,
+        McpCall,
+        McpListTools,
+        McpApprovalRequest,
+        ResponseCustomToolCall,
     ],
     PropertyInfo(discriminator="type"),
 ]
diff --git a/src/openai/types/responses/response_output_item_added_event.py b/src/openai/types/responses/response_output_item_added_event.py
index 7344fb9a6c..7cd2a3946d 100644
--- a/src/openai/types/responses/response_output_item_added_event.py
+++ b/src/openai/types/responses/response_output_item_added_event.py
@@ -15,5 +15,8 @@ class ResponseOutputItemAddedEvent(BaseModel):
     output_index: int
     """The index of the output item that was added."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.output_item.added"]
     """The type of the event. Always `response.output_item.added`."""
diff --git a/src/openai/types/responses/response_output_item_done_event.py b/src/openai/types/responses/response_output_item_done_event.py
index a0a871a019..37d3694cf7 100644
--- a/src/openai/types/responses/response_output_item_done_event.py
+++ b/src/openai/types/responses/response_output_item_done_event.py
@@ -15,5 +15,8 @@ class ResponseOutputItemDoneEvent(BaseModel):
     output_index: int
     """The index of the output item that was marked done."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.output_item.done"]
     """The type of the event. Always `response.output_item.done`."""
diff --git a/src/openai/types/responses/response_output_refusal.py b/src/openai/types/responses/response_output_refusal.py
index eba581070d..685c8722a6 100644
--- a/src/openai/types/responses/response_output_refusal.py
+++ b/src/openai/types/responses/response_output_refusal.py
@@ -9,7 +9,7 @@
 
 class ResponseOutputRefusal(BaseModel):
     refusal: str
-    """The refusal explanationfrom the model."""
+    """The refusal explanation from the model."""
 
     type: Literal["refusal"]
     """The type of the refusal. Always `refusal`."""
diff --git a/src/openai/types/responses/response_output_refusal_param.py b/src/openai/types/responses/response_output_refusal_param.py
index 53140a6080..54cfaf0791 100644
--- a/src/openai/types/responses/response_output_refusal_param.py
+++ b/src/openai/types/responses/response_output_refusal_param.py
@@ -9,7 +9,7 @@
 
 class ResponseOutputRefusalParam(TypedDict, total=False):
     refusal: Required[str]
-    """The refusal explanationfrom the model."""
+    """The refusal explanation from the model."""
 
     type: Required[Literal["refusal"]]
     """The type of the refusal. Always `refusal`."""
diff --git a/src/openai/types/responses/response_output_text.py b/src/openai/types/responses/response_output_text.py
index fa653cd1af..aa97b629f0 100644
--- a/src/openai/types/responses/response_output_text.py
+++ b/src/openai/types/responses/response_output_text.py
@@ -1,18 +1,30 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Union
+from typing import List, Union, Optional
 from typing_extensions import Literal, Annotated, TypeAlias
 
 from ..._utils import PropertyInfo
 from ..._models import BaseModel
 
-__all__ = ["ResponseOutputText", "Annotation", "AnnotationFileCitation", "AnnotationURLCitation", "AnnotationFilePath"]
+__all__ = [
+    "ResponseOutputText",
+    "Annotation",
+    "AnnotationFileCitation",
+    "AnnotationURLCitation",
+    "AnnotationContainerFileCitation",
+    "AnnotationFilePath",
+    "Logprob",
+    "LogprobTopLogprob",
+]
 
 
 class AnnotationFileCitation(BaseModel):
     file_id: str
     """The ID of the file."""
 
+    filename: str
+    """The filename of the file cited."""
+
     index: int
     """The index of the file in the list of files."""
 
@@ -37,6 +49,26 @@ class AnnotationURLCitation(BaseModel):
     """The URL of the web resource."""
 
 
+class AnnotationContainerFileCitation(BaseModel):
+    container_id: str
+    """The ID of the container file."""
+
+    end_index: int
+    """The index of the last character of the container file citation in the message."""
+
+    file_id: str
+    """The ID of the file."""
+
+    filename: str
+    """The filename of the container file cited."""
+
+    start_index: int
+    """The index of the first character of the container file citation in the message."""
+
+    type: Literal["container_file_citation"]
+    """The type of the container file citation. Always `container_file_citation`."""
+
+
 class AnnotationFilePath(BaseModel):
     file_id: str
     """The ID of the file."""
@@ -49,10 +81,29 @@ class AnnotationFilePath(BaseModel):
 
 
 Annotation: TypeAlias = Annotated[
-    Union[AnnotationFileCitation, AnnotationURLCitation, AnnotationFilePath], PropertyInfo(discriminator="type")
+    Union[AnnotationFileCitation, AnnotationURLCitation, AnnotationContainerFileCitation, AnnotationFilePath],
+    PropertyInfo(discriminator="type"),
 ]
 
 
+class LogprobTopLogprob(BaseModel):
+    token: str
+
+    bytes: List[int]
+
+    logprob: float
+
+
+class Logprob(BaseModel):
+    token: str
+
+    bytes: List[int]
+
+    logprob: float
+
+    top_logprobs: List[LogprobTopLogprob]
+
+
 class ResponseOutputText(BaseModel):
     annotations: List[Annotation]
     """The annotations of the text output."""
@@ -62,3 +113,5 @@ class ResponseOutputText(BaseModel):
 
     type: Literal["output_text"]
     """The type of the output text. Always `output_text`."""
+
+    logprobs: Optional[List[Logprob]] = None
diff --git a/src/openai/types/responses/response_output_text_annotation_added_event.py b/src/openai/types/responses/response_output_text_annotation_added_event.py
new file mode 100644
index 0000000000..62d8f72863
--- /dev/null
+++ b/src/openai/types/responses/response_output_text_annotation_added_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseOutputTextAnnotationAddedEvent"]
+
+
+class ResponseOutputTextAnnotationAddedEvent(BaseModel):
+    annotation: object
+    """The annotation object being added. (See annotation schema for details.)"""
+
+    annotation_index: int
+    """The index of the annotation within the content part."""
+
+    content_index: int
+    """The index of the content part within the output item."""
+
+    item_id: str
+    """The unique identifier of the item to which the annotation is being added."""
+
+    output_index: int
+    """The index of the output item in the response's output array."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.output_text.annotation.added"]
+    """The type of the event. Always 'response.output_text.annotation.added'."""
diff --git a/src/openai/types/responses/response_output_text_param.py b/src/openai/types/responses/response_output_text_param.py
index 1f0967285f..63d2d394a8 100644
--- a/src/openai/types/responses/response_output_text_param.py
+++ b/src/openai/types/responses/response_output_text_param.py
@@ -10,7 +10,10 @@
     "Annotation",
     "AnnotationFileCitation",
     "AnnotationURLCitation",
+    "AnnotationContainerFileCitation",
     "AnnotationFilePath",
+    "Logprob",
+    "LogprobTopLogprob",
 ]
 
 
@@ -18,6 +21,9 @@ class AnnotationFileCitation(TypedDict, total=False):
     file_id: Required[str]
     """The ID of the file."""
 
+    filename: Required[str]
+    """The filename of the file cited."""
+
     index: Required[int]
     """The index of the file in the list of files."""
 
@@ -42,6 +48,26 @@ class AnnotationURLCitation(TypedDict, total=False):
     """The URL of the web resource."""
 
 
+class AnnotationContainerFileCitation(TypedDict, total=False):
+    container_id: Required[str]
+    """The ID of the container file."""
+
+    end_index: Required[int]
+    """The index of the last character of the container file citation in the message."""
+
+    file_id: Required[str]
+    """The ID of the file."""
+
+    filename: Required[str]
+    """The filename of the container file cited."""
+
+    start_index: Required[int]
+    """The index of the first character of the container file citation in the message."""
+
+    type: Required[Literal["container_file_citation"]]
+    """The type of the container file citation. Always `container_file_citation`."""
+
+
 class AnnotationFilePath(TypedDict, total=False):
     file_id: Required[str]
     """The ID of the file."""
@@ -53,7 +79,27 @@ class AnnotationFilePath(TypedDict, total=False):
     """The type of the file path. Always `file_path`."""
 
 
-Annotation: TypeAlias = Union[AnnotationFileCitation, AnnotationURLCitation, AnnotationFilePath]
+Annotation: TypeAlias = Union[
+    AnnotationFileCitation, AnnotationURLCitation, AnnotationContainerFileCitation, AnnotationFilePath
+]
+
+
+class LogprobTopLogprob(TypedDict, total=False):
+    token: Required[str]
+
+    bytes: Required[Iterable[int]]
+
+    logprob: Required[float]
+
+
+class Logprob(TypedDict, total=False):
+    token: Required[str]
+
+    bytes: Required[Iterable[int]]
+
+    logprob: Required[float]
+
+    top_logprobs: Required[Iterable[LogprobTopLogprob]]
 
 
 class ResponseOutputTextParam(TypedDict, total=False):
@@ -65,3 +111,5 @@ class ResponseOutputTextParam(TypedDict, total=False):
 
     type: Required[Literal["output_text"]]
     """The type of the output text. Always `output_text`."""
+
+    logprobs: Iterable[Logprob]
diff --git a/src/openai/types/responses/response_prompt.py b/src/openai/types/responses/response_prompt.py
new file mode 100644
index 0000000000..537c2f8fbc
--- /dev/null
+++ b/src/openai/types/responses/response_prompt.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Union, Optional
+from typing_extensions import TypeAlias
+
+from ..._models import BaseModel
+from .response_input_file import ResponseInputFile
+from .response_input_text import ResponseInputText
+from .response_input_image import ResponseInputImage
+
+__all__ = ["ResponsePrompt", "Variables"]
+
+Variables: TypeAlias = Union[str, ResponseInputText, ResponseInputImage, ResponseInputFile]
+
+
+class ResponsePrompt(BaseModel):
+    id: str
+    """The unique identifier of the prompt template to use."""
+
+    variables: Optional[Dict[str, Variables]] = None
+    """Optional map of values to substitute in for variables in your prompt.
+
+    The substitution values can either be strings, or other Response input types
+    like images or files.
+    """
+
+    version: Optional[str] = None
+    """Optional version of the prompt template."""
diff --git a/src/openai/types/responses/response_prompt_param.py b/src/openai/types/responses/response_prompt_param.py
new file mode 100644
index 0000000000..d935fa5191
--- /dev/null
+++ b/src/openai/types/responses/response_prompt_param.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from .response_input_file_param import ResponseInputFileParam
+from .response_input_text_param import ResponseInputTextParam
+from .response_input_image_param import ResponseInputImageParam
+
+__all__ = ["ResponsePromptParam", "Variables"]
+
+Variables: TypeAlias = Union[str, ResponseInputTextParam, ResponseInputImageParam, ResponseInputFileParam]
+
+
+class ResponsePromptParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique identifier of the prompt template to use."""
+
+    variables: Optional[Dict[str, Variables]]
+    """Optional map of values to substitute in for variables in your prompt.
+
+    The substitution values can either be strings, or other Response input types
+    like images or files.
+    """
+
+    version: Optional[str]
+    """Optional version of the prompt template."""
diff --git a/src/openai/types/responses/response_queued_event.py b/src/openai/types/responses/response_queued_event.py
new file mode 100644
index 0000000000..40257408a4
--- /dev/null
+++ b/src/openai/types/responses/response_queued_event.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .response import Response
+from ..._models import BaseModel
+
+__all__ = ["ResponseQueuedEvent"]
+
+
+class ResponseQueuedEvent(BaseModel):
+    response: Response
+    """The full response object that is queued."""
+
+    sequence_number: int
+    """The sequence number for this event."""
+
+    type: Literal["response.queued"]
+    """The type of the event. Always 'response.queued'."""
diff --git a/src/openai/types/responses/response_reasoning_item.py b/src/openai/types/responses/response_reasoning_item.py
index 57e5fbfe6d..fc582cf7c5 100644
--- a/src/openai/types/responses/response_reasoning_item.py
+++ b/src/openai/types/responses/response_reasoning_item.py
@@ -5,29 +5,44 @@
 
 from ..._models import BaseModel
 
-__all__ = ["ResponseReasoningItem", "Summary"]
+__all__ = ["ResponseReasoningItem", "Summary", "Content"]
 
 
 class Summary(BaseModel):
     text: str
-    """
-    A short summary of the reasoning used by the model when generating the response.
-    """
+    """A summary of the reasoning output from the model so far."""
 
     type: Literal["summary_text"]
     """The type of the object. Always `summary_text`."""
 
 
+class Content(BaseModel):
+    text: str
+    """The reasoning text from the model."""
+
+    type: Literal["reasoning_text"]
+    """The type of the reasoning text. Always `reasoning_text`."""
+
+
 class ResponseReasoningItem(BaseModel):
     id: str
     """The unique identifier of the reasoning content."""
 
     summary: List[Summary]
-    """Reasoning text contents."""
+    """Reasoning summary content."""
 
     type: Literal["reasoning"]
     """The type of the object. Always `reasoning`."""
 
+    content: Optional[List[Content]] = None
+    """Reasoning text content."""
+
+    encrypted_content: Optional[str] = None
+    """
+    The encrypted content of the reasoning item - populated when a response is
+    generated with `reasoning.encrypted_content` in the `include` parameter.
+    """
+
     status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
     """The status of the item.
 
diff --git a/src/openai/types/responses/response_reasoning_item_param.py b/src/openai/types/responses/response_reasoning_item_param.py
index adb49d6402..56e88ba28d 100644
--- a/src/openai/types/responses/response_reasoning_item_param.py
+++ b/src/openai/types/responses/response_reasoning_item_param.py
@@ -2,32 +2,47 @@
 
 from __future__ import annotations
 
-from typing import Iterable
+from typing import Iterable, Optional
 from typing_extensions import Literal, Required, TypedDict
 
-__all__ = ["ResponseReasoningItemParam", "Summary"]
+__all__ = ["ResponseReasoningItemParam", "Summary", "Content"]
 
 
 class Summary(TypedDict, total=False):
     text: Required[str]
-    """
-    A short summary of the reasoning used by the model when generating the response.
-    """
+    """A summary of the reasoning output from the model so far."""
 
     type: Required[Literal["summary_text"]]
     """The type of the object. Always `summary_text`."""
 
 
+class Content(TypedDict, total=False):
+    text: Required[str]
+    """The reasoning text from the model."""
+
+    type: Required[Literal["reasoning_text"]]
+    """The type of the reasoning text. Always `reasoning_text`."""
+
+
 class ResponseReasoningItemParam(TypedDict, total=False):
     id: Required[str]
     """The unique identifier of the reasoning content."""
 
     summary: Required[Iterable[Summary]]
-    """Reasoning text contents."""
+    """Reasoning summary content."""
 
     type: Required[Literal["reasoning"]]
     """The type of the object. Always `reasoning`."""
 
+    content: Iterable[Content]
+    """Reasoning text content."""
+
+    encrypted_content: Optional[str]
+    """
+    The encrypted content of the reasoning item - populated when a response is
+    generated with `reasoning.encrypted_content` in the `include` parameter.
+    """
+
     status: Literal["in_progress", "completed", "incomplete"]
     """The status of the item.
 
diff --git a/src/openai/types/responses/response_reasoning_summary_part_added_event.py b/src/openai/types/responses/response_reasoning_summary_part_added_event.py
new file mode 100644
index 0000000000..dc755b253a
--- /dev/null
+++ b/src/openai/types/responses/response_reasoning_summary_part_added_event.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseReasoningSummaryPartAddedEvent", "Part"]
+
+
+class Part(BaseModel):
+    text: str
+    """The text of the summary part."""
+
+    type: Literal["summary_text"]
+    """The type of the summary part. Always `summary_text`."""
+
+
+class ResponseReasoningSummaryPartAddedEvent(BaseModel):
+    item_id: str
+    """The ID of the item this summary part is associated with."""
+
+    output_index: int
+    """The index of the output item this summary part is associated with."""
+
+    part: Part
+    """The summary part that was added."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    summary_index: int
+    """The index of the summary part within the reasoning summary."""
+
+    type: Literal["response.reasoning_summary_part.added"]
+    """The type of the event. Always `response.reasoning_summary_part.added`."""
diff --git a/src/openai/types/responses/response_reasoning_summary_part_done_event.py b/src/openai/types/responses/response_reasoning_summary_part_done_event.py
new file mode 100644
index 0000000000..7cc0b56d66
--- /dev/null
+++ b/src/openai/types/responses/response_reasoning_summary_part_done_event.py
@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseReasoningSummaryPartDoneEvent", "Part"]
+
+
+class Part(BaseModel):
+    text: str
+    """The text of the summary part."""
+
+    type: Literal["summary_text"]
+    """The type of the summary part. Always `summary_text`."""
+
+
+class ResponseReasoningSummaryPartDoneEvent(BaseModel):
+    item_id: str
+    """The ID of the item this summary part is associated with."""
+
+    output_index: int
+    """The index of the output item this summary part is associated with."""
+
+    part: Part
+    """The completed summary part."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    summary_index: int
+    """The index of the summary part within the reasoning summary."""
+
+    type: Literal["response.reasoning_summary_part.done"]
+    """The type of the event. Always `response.reasoning_summary_part.done`."""
diff --git a/src/openai/types/responses/response_reasoning_summary_text_delta_event.py b/src/openai/types/responses/response_reasoning_summary_text_delta_event.py
new file mode 100644
index 0000000000..96652991b6
--- /dev/null
+++ b/src/openai/types/responses/response_reasoning_summary_text_delta_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseReasoningSummaryTextDeltaEvent"]
+
+
+class ResponseReasoningSummaryTextDeltaEvent(BaseModel):
+    delta: str
+    """The text delta that was added to the summary."""
+
+    item_id: str
+    """The ID of the item this summary text delta is associated with."""
+
+    output_index: int
+    """The index of the output item this summary text delta is associated with."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    summary_index: int
+    """The index of the summary part within the reasoning summary."""
+
+    type: Literal["response.reasoning_summary_text.delta"]
+    """The type of the event. Always `response.reasoning_summary_text.delta`."""
diff --git a/src/openai/types/responses/response_reasoning_summary_text_done_event.py b/src/openai/types/responses/response_reasoning_summary_text_done_event.py
new file mode 100644
index 0000000000..b35b82316a
--- /dev/null
+++ b/src/openai/types/responses/response_reasoning_summary_text_done_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseReasoningSummaryTextDoneEvent"]
+
+
+class ResponseReasoningSummaryTextDoneEvent(BaseModel):
+    item_id: str
+    """The ID of the item this summary text is associated with."""
+
+    output_index: int
+    """The index of the output item this summary text is associated with."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    summary_index: int
+    """The index of the summary part within the reasoning summary."""
+
+    text: str
+    """The full text of the completed reasoning summary."""
+
+    type: Literal["response.reasoning_summary_text.done"]
+    """The type of the event. Always `response.reasoning_summary_text.done`."""
diff --git a/src/openai/types/responses/response_reasoning_text_delta_event.py b/src/openai/types/responses/response_reasoning_text_delta_event.py
new file mode 100644
index 0000000000..e1df893bac
--- /dev/null
+++ b/src/openai/types/responses/response_reasoning_text_delta_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseReasoningTextDeltaEvent"]
+
+
+class ResponseReasoningTextDeltaEvent(BaseModel):
+    content_index: int
+    """The index of the reasoning content part this delta is associated with."""
+
+    delta: str
+    """The text delta that was added to the reasoning content."""
+
+    item_id: str
+    """The ID of the item this reasoning text delta is associated with."""
+
+    output_index: int
+    """The index of the output item this reasoning text delta is associated with."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    type: Literal["response.reasoning_text.delta"]
+    """The type of the event. Always `response.reasoning_text.delta`."""
diff --git a/src/openai/types/responses/response_reasoning_text_done_event.py b/src/openai/types/responses/response_reasoning_text_done_event.py
new file mode 100644
index 0000000000..d22d984e47
--- /dev/null
+++ b/src/openai/types/responses/response_reasoning_text_done_event.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseReasoningTextDoneEvent"]
+
+
+class ResponseReasoningTextDoneEvent(BaseModel):
+    content_index: int
+    """The index of the reasoning content part."""
+
+    item_id: str
+    """The ID of the item this reasoning text is associated with."""
+
+    output_index: int
+    """The index of the output item this reasoning text is associated with."""
+
+    sequence_number: int
+    """The sequence number of this event."""
+
+    text: str
+    """The full text of the completed reasoning content."""
+
+    type: Literal["response.reasoning_text.done"]
+    """The type of the event. Always `response.reasoning_text.done`."""
diff --git a/src/openai/types/responses/response_refusal_delta_event.py b/src/openai/types/responses/response_refusal_delta_event.py
index 04dcdf1c8c..03c903ed28 100644
--- a/src/openai/types/responses/response_refusal_delta_event.py
+++ b/src/openai/types/responses/response_refusal_delta_event.py
@@ -20,5 +20,8 @@ class ResponseRefusalDeltaEvent(BaseModel):
     output_index: int
     """The index of the output item that the refusal text is added to."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.refusal.delta"]
     """The type of the event. Always `response.refusal.delta`."""
diff --git a/src/openai/types/responses/response_refusal_done_event.py b/src/openai/types/responses/response_refusal_done_event.py
index a9b6f4b055..61fd51aab0 100644
--- a/src/openai/types/responses/response_refusal_done_event.py
+++ b/src/openai/types/responses/response_refusal_done_event.py
@@ -20,5 +20,8 @@ class ResponseRefusalDoneEvent(BaseModel):
     refusal: str
     """The refusal text that is finalized."""
 
+    sequence_number: int
+    """The sequence number of this event."""
+
     type: Literal["response.refusal.done"]
     """The type of the event. Always `response.refusal.done`."""
diff --git a/src/openai/types/responses/response_retrieve_params.py b/src/openai/types/responses/response_retrieve_params.py
index 137bf4dcee..4013db85ce 100644
--- a/src/openai/types/responses/response_retrieve_params.py
+++ b/src/openai/types/responses/response_retrieve_params.py
@@ -2,17 +2,58 @@
 
 from __future__ import annotations
 
-from typing import List
-from typing_extensions import TypedDict
+from typing import List, Union
+from typing_extensions import Literal, Required, TypedDict
 
 from .response_includable import ResponseIncludable
 
-__all__ = ["ResponseRetrieveParams"]
+__all__ = ["ResponseRetrieveParamsBase", "ResponseRetrieveParamsNonStreaming", "ResponseRetrieveParamsStreaming"]
 
 
-class ResponseRetrieveParams(TypedDict, total=False):
+class ResponseRetrieveParamsBase(TypedDict, total=False):
     include: List[ResponseIncludable]
     """Additional fields to include in the response.
 
     See the `include` parameter for Response creation above for more information.
     """
+
+    include_obfuscation: bool
+    """When true, stream obfuscation will be enabled.
+
+    Stream obfuscation adds random characters to an `obfuscation` field on streaming
+    delta events to normalize payload sizes as a mitigation to certain side-channel
+    attacks. These obfuscation fields are included by default, but add a small
+    amount of overhead to the data stream. You can set `include_obfuscation` to
+    false to optimize for bandwidth if you trust the network links between your
+    application and the OpenAI API.
+    """
+
+    starting_after: int
+    """The sequence number of the event after which to start streaming."""
+
+
+class ResponseRetrieveParamsNonStreaming(ResponseRetrieveParamsBase, total=False):
+    stream: Literal[False]
+    """
+    If set to true, the model response data will be streamed to the client as it is
+    generated using
+    [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+    See the
+    [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+    for more information.
+    """
+
+
+class ResponseRetrieveParamsStreaming(ResponseRetrieveParamsBase):
+    stream: Required[Literal[True]]
+    """
+    If set to true, the model response data will be streamed to the client as it is
+    generated using
+    [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+    See the
+    [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
+    for more information.
+    """
+
+
+ResponseRetrieveParams = Union[ResponseRetrieveParamsNonStreaming, ResponseRetrieveParamsStreaming]
diff --git a/src/openai/types/responses/response_status.py b/src/openai/types/responses/response_status.py
index 934d17cda3..a7887b92d2 100644
--- a/src/openai/types/responses/response_status.py
+++ b/src/openai/types/responses/response_status.py
@@ -4,4 +4,4 @@
 
 __all__ = ["ResponseStatus"]
 
-ResponseStatus: TypeAlias = Literal["completed", "failed", "in_progress", "incomplete"]
+ResponseStatus: TypeAlias = Literal["completed", "failed", "in_progress", "cancelled", "queued", "incomplete"]
diff --git a/src/openai/types/responses/response_stream_event.py b/src/openai/types/responses/response_stream_event.py
index 446863b175..c0a317cd9d 100644
--- a/src/openai/types/responses/response_stream_event.py
+++ b/src/openai/types/responses/response_stream_event.py
@@ -6,6 +6,7 @@
 from ..._utils import PropertyInfo
 from .response_error_event import ResponseErrorEvent
 from .response_failed_event import ResponseFailedEvent
+from .response_queued_event import ResponseQueuedEvent
 from .response_created_event import ResponseCreatedEvent
 from .response_completed_event import ResponseCompletedEvent
 from .response_text_done_event import ResponseTextDoneEvent
@@ -16,20 +17,40 @@
 from .response_in_progress_event import ResponseInProgressEvent
 from .response_refusal_done_event import ResponseRefusalDoneEvent
 from .response_refusal_delta_event import ResponseRefusalDeltaEvent
+from .response_mcp_call_failed_event import ResponseMcpCallFailedEvent
 from .response_output_item_done_event import ResponseOutputItemDoneEvent
 from .response_content_part_done_event import ResponseContentPartDoneEvent
 from .response_output_item_added_event import ResponseOutputItemAddedEvent
 from .response_content_part_added_event import ResponseContentPartAddedEvent
+from .response_mcp_call_completed_event import ResponseMcpCallCompletedEvent
+from .response_reasoning_text_done_event import ResponseReasoningTextDoneEvent
+from .response_mcp_call_in_progress_event import ResponseMcpCallInProgressEvent
+from .response_reasoning_text_delta_event import ResponseReasoningTextDeltaEvent
 from .response_audio_transcript_done_event import ResponseAudioTranscriptDoneEvent
-from .response_text_annotation_delta_event import ResponseTextAnnotationDeltaEvent
+from .response_mcp_list_tools_failed_event import ResponseMcpListToolsFailedEvent
 from .response_audio_transcript_delta_event import ResponseAudioTranscriptDeltaEvent
+from .response_mcp_call_arguments_done_event import ResponseMcpCallArgumentsDoneEvent
+from .response_image_gen_call_completed_event import ResponseImageGenCallCompletedEvent
+from .response_mcp_call_arguments_delta_event import ResponseMcpCallArgumentsDeltaEvent
+from .response_mcp_list_tools_completed_event import ResponseMcpListToolsCompletedEvent
+from .response_image_gen_call_generating_event import ResponseImageGenCallGeneratingEvent
 from .response_web_search_call_completed_event import ResponseWebSearchCallCompletedEvent
 from .response_web_search_call_searching_event import ResponseWebSearchCallSearchingEvent
 from .response_file_search_call_completed_event import ResponseFileSearchCallCompletedEvent
 from .response_file_search_call_searching_event import ResponseFileSearchCallSearchingEvent
+from .response_image_gen_call_in_progress_event import ResponseImageGenCallInProgressEvent
+from .response_mcp_list_tools_in_progress_event import ResponseMcpListToolsInProgressEvent
+from .response_custom_tool_call_input_done_event import ResponseCustomToolCallInputDoneEvent
+from .response_reasoning_summary_part_done_event import ResponseReasoningSummaryPartDoneEvent
+from .response_reasoning_summary_text_done_event import ResponseReasoningSummaryTextDoneEvent
 from .response_web_search_call_in_progress_event import ResponseWebSearchCallInProgressEvent
+from .response_custom_tool_call_input_delta_event import ResponseCustomToolCallInputDeltaEvent
 from .response_file_search_call_in_progress_event import ResponseFileSearchCallInProgressEvent
 from .response_function_call_arguments_done_event import ResponseFunctionCallArgumentsDoneEvent
+from .response_image_gen_call_partial_image_event import ResponseImageGenCallPartialImageEvent
+from .response_output_text_annotation_added_event import ResponseOutputTextAnnotationAddedEvent
+from .response_reasoning_summary_part_added_event import ResponseReasoningSummaryPartAddedEvent
+from .response_reasoning_summary_text_delta_event import ResponseReasoningSummaryTextDeltaEvent
 from .response_function_call_arguments_delta_event import ResponseFunctionCallArgumentsDeltaEvent
 from .response_code_interpreter_call_code_done_event import ResponseCodeInterpreterCallCodeDoneEvent
 from .response_code_interpreter_call_completed_event import ResponseCodeInterpreterCallCompletedEvent
@@ -65,14 +86,35 @@
         ResponseIncompleteEvent,
         ResponseOutputItemAddedEvent,
         ResponseOutputItemDoneEvent,
+        ResponseReasoningSummaryPartAddedEvent,
+        ResponseReasoningSummaryPartDoneEvent,
+        ResponseReasoningSummaryTextDeltaEvent,
+        ResponseReasoningSummaryTextDoneEvent,
+        ResponseReasoningTextDeltaEvent,
+        ResponseReasoningTextDoneEvent,
         ResponseRefusalDeltaEvent,
         ResponseRefusalDoneEvent,
-        ResponseTextAnnotationDeltaEvent,
         ResponseTextDeltaEvent,
         ResponseTextDoneEvent,
         ResponseWebSearchCallCompletedEvent,
         ResponseWebSearchCallInProgressEvent,
         ResponseWebSearchCallSearchingEvent,
+        ResponseImageGenCallCompletedEvent,
+        ResponseImageGenCallGeneratingEvent,
+        ResponseImageGenCallInProgressEvent,
+        ResponseImageGenCallPartialImageEvent,
+        ResponseMcpCallArgumentsDeltaEvent,
+        ResponseMcpCallArgumentsDoneEvent,
+        ResponseMcpCallCompletedEvent,
+        ResponseMcpCallFailedEvent,
+        ResponseMcpCallInProgressEvent,
+        ResponseMcpListToolsCompletedEvent,
+        ResponseMcpListToolsFailedEvent,
+        ResponseMcpListToolsInProgressEvent,
+        ResponseOutputTextAnnotationAddedEvent,
+        ResponseQueuedEvent,
+        ResponseCustomToolCallInputDeltaEvent,
+        ResponseCustomToolCallInputDoneEvent,
     ],
     PropertyInfo(discriminator="type"),
 ]
diff --git a/src/openai/types/responses/response_text_annotation_delta_event.py b/src/openai/types/responses/response_text_annotation_delta_event.py
deleted file mode 100644
index 4f2582282a..0000000000
--- a/src/openai/types/responses/response_text_annotation_delta_event.py
+++ /dev/null
@@ -1,79 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from typing import Union
-from typing_extensions import Literal, Annotated, TypeAlias
-
-from ..._utils import PropertyInfo
-from ..._models import BaseModel
-
-__all__ = [
-    "ResponseTextAnnotationDeltaEvent",
-    "Annotation",
-    "AnnotationFileCitation",
-    "AnnotationURLCitation",
-    "AnnotationFilePath",
-]
-
-
-class AnnotationFileCitation(BaseModel):
-    file_id: str
-    """The ID of the file."""
-
-    index: int
-    """The index of the file in the list of files."""
-
-    type: Literal["file_citation"]
-    """The type of the file citation. Always `file_citation`."""
-
-
-class AnnotationURLCitation(BaseModel):
-    end_index: int
-    """The index of the last character of the URL citation in the message."""
-
-    start_index: int
-    """The index of the first character of the URL citation in the message."""
-
-    title: str
-    """The title of the web resource."""
-
-    type: Literal["url_citation"]
-    """The type of the URL citation. Always `url_citation`."""
-
-    url: str
-    """The URL of the web resource."""
-
-
-class AnnotationFilePath(BaseModel):
-    file_id: str
-    """The ID of the file."""
-
-    index: int
-    """The index of the file in the list of files."""
-
-    type: Literal["file_path"]
-    """The type of the file path. Always `file_path`."""
-
-
-Annotation: TypeAlias = Annotated[
-    Union[AnnotationFileCitation, AnnotationURLCitation, AnnotationFilePath], PropertyInfo(discriminator="type")
-]
-
-
-class ResponseTextAnnotationDeltaEvent(BaseModel):
-    annotation: Annotation
-    """A citation to a file."""
-
-    annotation_index: int
-    """The index of the annotation that was added."""
-
-    content_index: int
-    """The index of the content part that the text annotation was added to."""
-
-    item_id: str
-    """The ID of the output item that the text annotation was added to."""
-
-    output_index: int
-    """The index of the output item that the text annotation was added to."""
-
-    type: Literal["response.output_text.annotation.added"]
-    """The type of the event. Always `response.output_text.annotation.added`."""
diff --git a/src/openai/types/responses/response_text_config.py b/src/openai/types/responses/response_text_config.py
index a1894a9176..c53546da6d 100644
--- a/src/openai/types/responses/response_text_config.py
+++ b/src/openai/types/responses/response_text_config.py
@@ -1,6 +1,7 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import Optional
+from typing_extensions import Literal
 
 from ..._models import BaseModel
 from .response_format_text_config import ResponseFormatTextConfig
@@ -24,3 +25,11 @@ class ResponseTextConfig(BaseModel):
     ensures the message the model generates is valid JSON. Using `json_schema` is
     preferred for models that support it.
     """
+
+    verbosity: Optional[Literal["low", "medium", "high"]] = None
+    """Constrains the verbosity of the model's response.
+
+    Lower values will result in more concise responses, while higher values will
+    result in more verbose responses. Currently supported values are `low`,
+    `medium`, and `high`.
+    """
diff --git a/src/openai/types/responses/response_text_config_param.py b/src/openai/types/responses/response_text_config_param.py
index aec064bf89..1229fce35b 100644
--- a/src/openai/types/responses/response_text_config_param.py
+++ b/src/openai/types/responses/response_text_config_param.py
@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing_extensions import TypedDict
+from typing import Optional
+from typing_extensions import Literal, TypedDict
 
 from .response_format_text_config_param import ResponseFormatTextConfigParam
 
@@ -25,3 +26,11 @@ class ResponseTextConfigParam(TypedDict, total=False):
     ensures the message the model generates is valid JSON. Using `json_schema` is
     preferred for models that support it.
     """
+
+    verbosity: Optional[Literal["low", "medium", "high"]]
+    """Constrains the verbosity of the model's response.
+
+    Lower values will result in more concise responses, while higher values will
+    result in more verbose responses. Currently supported values are `low`,
+    `medium`, and `high`.
+    """
diff --git a/src/openai/types/responses/response_text_delta_event.py b/src/openai/types/responses/response_text_delta_event.py
index 751a5e2a19..b5379b7ac3 100644
--- a/src/openai/types/responses/response_text_delta_event.py
+++ b/src/openai/types/responses/response_text_delta_event.py
@@ -1,10 +1,30 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import List, Optional
 from typing_extensions import Literal
 
 from ..._models import BaseModel
 
-__all__ = ["ResponseTextDeltaEvent"]
+__all__ = ["ResponseTextDeltaEvent", "Logprob", "LogprobTopLogprob"]
+
+
+class LogprobTopLogprob(BaseModel):
+    token: Optional[str] = None
+    """A possible text token."""
+
+    logprob: Optional[float] = None
+    """The log probability of this token."""
+
+
+class Logprob(BaseModel):
+    token: str
+    """A possible text token."""
+
+    logprob: float
+    """The log probability of this token."""
+
+    top_logprobs: Optional[List[LogprobTopLogprob]] = None
+    """The log probability of the top 20 most likely tokens."""
 
 
 class ResponseTextDeltaEvent(BaseModel):
@@ -17,8 +37,14 @@ class ResponseTextDeltaEvent(BaseModel):
     item_id: str
     """The ID of the output item that the text delta was added to."""
 
+    logprobs: List[Logprob]
+    """The log probabilities of the tokens in the delta."""
+
     output_index: int
     """The index of the output item that the text delta was added to."""
 
+    sequence_number: int
+    """The sequence number for this event."""
+
     type: Literal["response.output_text.delta"]
     """The type of the event. Always `response.output_text.delta`."""
diff --git a/src/openai/types/responses/response_text_done_event.py b/src/openai/types/responses/response_text_done_event.py
index 9b5c5e020c..d9776a1844 100644
--- a/src/openai/types/responses/response_text_done_event.py
+++ b/src/openai/types/responses/response_text_done_event.py
@@ -1,10 +1,30 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from typing import List, Optional
 from typing_extensions import Literal
 
 from ..._models import BaseModel
 
-__all__ = ["ResponseTextDoneEvent"]
+__all__ = ["ResponseTextDoneEvent", "Logprob", "LogprobTopLogprob"]
+
+
+class LogprobTopLogprob(BaseModel):
+    token: Optional[str] = None
+    """A possible text token."""
+
+    logprob: Optional[float] = None
+    """The log probability of this token."""
+
+
+class Logprob(BaseModel):
+    token: str
+    """A possible text token."""
+
+    logprob: float
+    """The log probability of this token."""
+
+    top_logprobs: Optional[List[LogprobTopLogprob]] = None
+    """The log probability of the top 20 most likely tokens."""
 
 
 class ResponseTextDoneEvent(BaseModel):
@@ -14,9 +34,15 @@ class ResponseTextDoneEvent(BaseModel):
     item_id: str
     """The ID of the output item that the text content is finalized."""
 
+    logprobs: List[Logprob]
+    """The log probabilities of the tokens in the delta."""
+
     output_index: int
     """The index of the output item that the text content is finalized."""
 
+    sequence_number: int
+    """The sequence number for this event."""
+
     text: str
     """The text content that is finalized."""
 
diff --git a/src/openai/types/responses/response_usage.py b/src/openai/types/responses/response_usage.py
index ef631c5882..52b93ac578 100644
--- a/src/openai/types/responses/response_usage.py
+++ b/src/openai/types/responses/response_usage.py
@@ -1,9 +1,16 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from ..._models import BaseModel
 
-__all__ = ["ResponseUsage", "OutputTokensDetails"]
+__all__ = ["ResponseUsage", "InputTokensDetails", "OutputTokensDetails"]
+
+
+class InputTokensDetails(BaseModel):
+    cached_tokens: int
+    """The number of tokens that were retrieved from the cache.
+
+    [More on prompt caching](https://platform.openai.com/docs/guides/prompt-caching).
+    """
 
 
 class OutputTokensDetails(BaseModel):
@@ -15,6 +22,9 @@ class ResponseUsage(BaseModel):
     input_tokens: int
     """The number of input tokens."""
 
+    input_tokens_details: InputTokensDetails
+    """A detailed breakdown of the input tokens."""
+
     output_tokens: int
     """The number of output tokens."""
 
diff --git a/src/openai/types/responses/response_web_search_call_completed_event.py b/src/openai/types/responses/response_web_search_call_completed_event.py
index 76f26766a1..497f7bfe35 100644
--- a/src/openai/types/responses/response_web_search_call_completed_event.py
+++ b/src/openai/types/responses/response_web_search_call_completed_event.py
@@ -14,5 +14,8 @@ class ResponseWebSearchCallCompletedEvent(BaseModel):
     output_index: int
     """The index of the output item that the web search call is associated with."""
 
+    sequence_number: int
+    """The sequence number of the web search call being processed."""
+
     type: Literal["response.web_search_call.completed"]
     """The type of the event. Always `response.web_search_call.completed`."""
diff --git a/src/openai/types/responses/response_web_search_call_in_progress_event.py b/src/openai/types/responses/response_web_search_call_in_progress_event.py
index 681ce6d94b..da8b3fe404 100644
--- a/src/openai/types/responses/response_web_search_call_in_progress_event.py
+++ b/src/openai/types/responses/response_web_search_call_in_progress_event.py
@@ -14,5 +14,8 @@ class ResponseWebSearchCallInProgressEvent(BaseModel):
     output_index: int
     """The index of the output item that the web search call is associated with."""
 
+    sequence_number: int
+    """The sequence number of the web search call being processed."""
+
     type: Literal["response.web_search_call.in_progress"]
     """The type of the event. Always `response.web_search_call.in_progress`."""
diff --git a/src/openai/types/responses/response_web_search_call_searching_event.py b/src/openai/types/responses/response_web_search_call_searching_event.py
index c885d98918..42df9cb298 100644
--- a/src/openai/types/responses/response_web_search_call_searching_event.py
+++ b/src/openai/types/responses/response_web_search_call_searching_event.py
@@ -14,5 +14,8 @@ class ResponseWebSearchCallSearchingEvent(BaseModel):
     output_index: int
     """The index of the output item that the web search call is associated with."""
 
+    sequence_number: int
+    """The sequence number of the web search call being processed."""
+
     type: Literal["response.web_search_call.searching"]
     """The type of the event. Always `response.web_search_call.searching`."""
diff --git a/src/openai/types/responses/tool.py b/src/openai/types/responses/tool.py
index de5d5524d4..ae8b34b1f4 100644
--- a/src/openai/types/responses/tool.py
+++ b/src/openai/types/responses/tool.py
@@ -1,16 +1,271 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Union
-from typing_extensions import Annotated, TypeAlias
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
 
+from . import web_search_tool
 from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .custom_tool import CustomTool
 from .computer_tool import ComputerTool
 from .function_tool import FunctionTool
 from .web_search_tool import WebSearchTool
+from .apply_patch_tool import ApplyPatchTool
 from .file_search_tool import FileSearchTool
+from .function_shell_tool import FunctionShellTool
+from .web_search_preview_tool import WebSearchPreviewTool
+
+__all__ = [
+    "Tool",
+    "WebSearchTool",
+    "Mcp",
+    "McpAllowedTools",
+    "McpAllowedToolsMcpToolFilter",
+    "McpRequireApproval",
+    "McpRequireApprovalMcpToolApprovalFilter",
+    "McpRequireApprovalMcpToolApprovalFilterAlways",
+    "McpRequireApprovalMcpToolApprovalFilterNever",
+    "CodeInterpreter",
+    "CodeInterpreterContainer",
+    "CodeInterpreterContainerCodeInterpreterToolAuto",
+    "ImageGeneration",
+    "ImageGenerationInputImageMask",
+    "LocalShell",
+]
+
+WebSearchToolFilters = web_search_tool.Filters
+WebSearchToolUserLocation = web_search_tool.UserLocation
+
+
+class McpAllowedToolsMcpToolFilter(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+McpAllowedTools: TypeAlias = Union[List[str], McpAllowedToolsMcpToolFilter, None]
+
+
+class McpRequireApprovalMcpToolApprovalFilterAlways(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilterNever(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilter(BaseModel):
+    always: Optional[McpRequireApprovalMcpToolApprovalFilterAlways] = None
+    """A filter object to specify which tools are allowed."""
+
+    never: Optional[McpRequireApprovalMcpToolApprovalFilterNever] = None
+    """A filter object to specify which tools are allowed."""
+
+
+McpRequireApproval: TypeAlias = Union[McpRequireApprovalMcpToolApprovalFilter, Literal["always", "never"], None]
+
+
+class Mcp(BaseModel):
+    server_label: str
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Literal["mcp"]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[McpAllowedTools] = None
+    """List of allowed tool names or a filter object."""
+
+    authorization: Optional[str] = None
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Optional[
+        Literal[
+            "connector_dropbox",
+            "connector_gmail",
+            "connector_googlecalendar",
+            "connector_googledrive",
+            "connector_microsoftteams",
+            "connector_outlookcalendar",
+            "connector_outlookemail",
+            "connector_sharepoint",
+        ]
+    ] = None
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]] = None
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[McpRequireApproval] = None
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: Optional[str] = None
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: Optional[str] = None
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
+
+
+class CodeInterpreterContainerCodeInterpreterToolAuto(BaseModel):
+    type: Literal["auto"]
+    """Always `auto`."""
+
+    file_ids: Optional[List[str]] = None
+    """An optional list of uploaded files to make available to your code."""
+
+    memory_limit: Optional[Literal["1g", "4g", "16g", "64g"]] = None
+
+
+CodeInterpreterContainer: TypeAlias = Union[str, CodeInterpreterContainerCodeInterpreterToolAuto]
+
+
+class CodeInterpreter(BaseModel):
+    container: CodeInterpreterContainer
+    """The code interpreter container.
+
+    Can be a container ID or an object that specifies uploaded file IDs to make
+    available to your code.
+    """
+
+    type: Literal["code_interpreter"]
+    """The type of the code interpreter tool. Always `code_interpreter`."""
+
+
+class ImageGenerationInputImageMask(BaseModel):
+    file_id: Optional[str] = None
+    """File ID for the mask image."""
+
+    image_url: Optional[str] = None
+    """Base64-encoded mask image."""
+
+
+class ImageGeneration(BaseModel):
+    type: Literal["image_generation"]
+    """The type of the image generation tool. Always `image_generation`."""
+
+    background: Optional[Literal["transparent", "opaque", "auto"]] = None
+    """Background type for the generated image.
+
+    One of `transparent`, `opaque`, or `auto`. Default: `auto`.
+    """
+
+    input_fidelity: Optional[Literal["high", "low"]] = None
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+    `low`. Defaults to `low`.
+    """
+
+    input_image_mask: Optional[ImageGenerationInputImageMask] = None
+    """Optional mask for inpainting.
+
+    Contains `image_url` (string, optional) and `file_id` (string, optional).
+    """
+
+    model: Optional[Literal["gpt-image-1", "gpt-image-1-mini"]] = None
+    """The image generation model to use. Default: `gpt-image-1`."""
+
+    moderation: Optional[Literal["auto", "low"]] = None
+    """Moderation level for the generated image. Default: `auto`."""
+
+    output_compression: Optional[int] = None
+    """Compression level for the output image. Default: 100."""
+
+    output_format: Optional[Literal["png", "webp", "jpeg"]] = None
+    """The output format of the generated image.
+
+    One of `png`, `webp`, or `jpeg`. Default: `png`.
+    """
+
+    partial_images: Optional[int] = None
+    """
+    Number of partial images to generate in streaming mode, from 0 (default value)
+    to 3.
+    """
+
+    quality: Optional[Literal["low", "medium", "high", "auto"]] = None
+    """The quality of the generated image.
+
+    One of `low`, `medium`, `high`, or `auto`. Default: `auto`.
+    """
+
+    size: Optional[Literal["1024x1024", "1024x1536", "1536x1024", "auto"]] = None
+    """The size of the generated image.
+
+    One of `1024x1024`, `1024x1536`, `1536x1024`, or `auto`. Default: `auto`.
+    """
+
+
+class LocalShell(BaseModel):
+    type: Literal["local_shell"]
+    """The type of the local shell tool. Always `local_shell`."""
 
-__all__ = ["Tool"]
 
 Tool: TypeAlias = Annotated[
-    Union[FileSearchTool, FunctionTool, ComputerTool, WebSearchTool], PropertyInfo(discriminator="type")
+    Union[
+        FunctionTool,
+        FileSearchTool,
+        ComputerTool,
+        WebSearchTool,
+        Mcp,
+        CodeInterpreter,
+        ImageGeneration,
+        LocalShell,
+        FunctionShellTool,
+        CustomTool,
+        WebSearchPreviewTool,
+        ApplyPatchTool,
+    ],
+    PropertyInfo(discriminator="type"),
 ]
diff --git a/src/openai/types/responses/tool_choice_allowed.py b/src/openai/types/responses/tool_choice_allowed.py
new file mode 100644
index 0000000000..d7921dcb2a
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_allowed.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ToolChoiceAllowed"]
+
+
+class ToolChoiceAllowed(BaseModel):
+    mode: Literal["auto", "required"]
+    """Constrains the tools available to the model to a pre-defined set.
+
+    `auto` allows the model to pick from among the allowed tools and generate a
+    message.
+
+    `required` requires the model to call one or more of the allowed tools.
+    """
+
+    tools: List[Dict[str, object]]
+    """A list of tool definitions that the model should be allowed to call.
+
+    For the Responses API, the list of tool definitions might look like:
+
+    ```json
+    [
+      { "type": "function", "name": "get_weather" },
+      { "type": "mcp", "server_label": "deepwiki" },
+      { "type": "image_generation" }
+    ]
+    ```
+    """
+
+    type: Literal["allowed_tools"]
+    """Allowed tool configuration type. Always `allowed_tools`."""
diff --git a/src/openai/types/responses/tool_choice_allowed_param.py b/src/openai/types/responses/tool_choice_allowed_param.py
new file mode 100644
index 0000000000..0712cab43b
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_allowed_param.py
@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ToolChoiceAllowedParam"]
+
+
+class ToolChoiceAllowedParam(TypedDict, total=False):
+    mode: Required[Literal["auto", "required"]]
+    """Constrains the tools available to the model to a pre-defined set.
+
+    `auto` allows the model to pick from among the allowed tools and generate a
+    message.
+
+    `required` requires the model to call one or more of the allowed tools.
+    """
+
+    tools: Required[Iterable[Dict[str, object]]]
+    """A list of tool definitions that the model should be allowed to call.
+
+    For the Responses API, the list of tool definitions might look like:
+
+    ```json
+    [
+      { "type": "function", "name": "get_weather" },
+      { "type": "mcp", "server_label": "deepwiki" },
+      { "type": "image_generation" }
+    ]
+    ```
+    """
+
+    type: Required[Literal["allowed_tools"]]
+    """Allowed tool configuration type. Always `allowed_tools`."""
diff --git a/src/openai/types/responses/tool_choice_apply_patch.py b/src/openai/types/responses/tool_choice_apply_patch.py
new file mode 100644
index 0000000000..7f815aa1a1
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_apply_patch.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ToolChoiceApplyPatch"]
+
+
+class ToolChoiceApplyPatch(BaseModel):
+    type: Literal["apply_patch"]
+    """The tool to call. Always `apply_patch`."""
diff --git a/src/openai/types/responses/tool_choice_apply_patch_param.py b/src/openai/types/responses/tool_choice_apply_patch_param.py
new file mode 100644
index 0000000000..00d4b25f0e
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_apply_patch_param.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ToolChoiceApplyPatchParam"]
+
+
+class ToolChoiceApplyPatchParam(TypedDict, total=False):
+    type: Required[Literal["apply_patch"]]
+    """The tool to call. Always `apply_patch`."""
diff --git a/src/openai/types/responses/tool_choice_custom.py b/src/openai/types/responses/tool_choice_custom.py
new file mode 100644
index 0000000000..d600e53616
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_custom.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ToolChoiceCustom"]
+
+
+class ToolChoiceCustom(BaseModel):
+    name: str
+    """The name of the custom tool to call."""
+
+    type: Literal["custom"]
+    """For custom tool calling, the type is always `custom`."""
diff --git a/src/openai/types/responses/tool_choice_custom_param.py b/src/openai/types/responses/tool_choice_custom_param.py
new file mode 100644
index 0000000000..55bc53b730
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_custom_param.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ToolChoiceCustomParam"]
+
+
+class ToolChoiceCustomParam(TypedDict, total=False):
+    name: Required[str]
+    """The name of the custom tool to call."""
+
+    type: Required[Literal["custom"]]
+    """For custom tool calling, the type is always `custom`."""
diff --git a/src/openai/types/responses/tool_choice_mcp.py b/src/openai/types/responses/tool_choice_mcp.py
new file mode 100644
index 0000000000..8763d81635
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_mcp.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ToolChoiceMcp"]
+
+
+class ToolChoiceMcp(BaseModel):
+    server_label: str
+    """The label of the MCP server to use."""
+
+    type: Literal["mcp"]
+    """For MCP tools, the type is always `mcp`."""
+
+    name: Optional[str] = None
+    """The name of the tool to call on the server."""
diff --git a/src/openai/types/responses/tool_choice_mcp_param.py b/src/openai/types/responses/tool_choice_mcp_param.py
new file mode 100644
index 0000000000..afcceb8cc5
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_mcp_param.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ToolChoiceMcpParam"]
+
+
+class ToolChoiceMcpParam(TypedDict, total=False):
+    server_label: Required[str]
+    """The label of the MCP server to use."""
+
+    type: Required[Literal["mcp"]]
+    """For MCP tools, the type is always `mcp`."""
+
+    name: Optional[str]
+    """The name of the tool to call on the server."""
diff --git a/src/openai/types/responses/tool_choice_shell.py b/src/openai/types/responses/tool_choice_shell.py
new file mode 100644
index 0000000000..1ad21c58f3
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_shell.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ToolChoiceShell"]
+
+
+class ToolChoiceShell(BaseModel):
+    type: Literal["shell"]
+    """The tool to call. Always `shell`."""
diff --git a/src/openai/types/responses/tool_choice_shell_param.py b/src/openai/types/responses/tool_choice_shell_param.py
new file mode 100644
index 0000000000..2b04c00d56
--- /dev/null
+++ b/src/openai/types/responses/tool_choice_shell_param.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ToolChoiceShellParam"]
+
+
+class ToolChoiceShellParam(TypedDict, total=False):
+    type: Required[Literal["shell"]]
+    """The tool to call. Always `shell`."""
diff --git a/src/openai/types/responses/tool_choice_types.py b/src/openai/types/responses/tool_choice_types.py
index 4942808f14..b31a826051 100644
--- a/src/openai/types/responses/tool_choice_types.py
+++ b/src/openai/types/responses/tool_choice_types.py
@@ -8,7 +8,14 @@
 
 
 class ToolChoiceTypes(BaseModel):
-    type: Literal["file_search", "web_search_preview", "computer_use_preview", "web_search_preview_2025_03_11"]
+    type: Literal[
+        "file_search",
+        "web_search_preview",
+        "computer_use_preview",
+        "web_search_preview_2025_03_11",
+        "image_generation",
+        "code_interpreter",
+    ]
     """The type of hosted tool the model should to use.
 
     Learn more about
@@ -19,4 +26,6 @@ class ToolChoiceTypes(BaseModel):
     - `file_search`
     - `web_search_preview`
     - `computer_use_preview`
+    - `code_interpreter`
+    - `image_generation`
     """
diff --git a/src/openai/types/responses/tool_choice_types_param.py b/src/openai/types/responses/tool_choice_types_param.py
index b14f2a9eb0..15e0357471 100644
--- a/src/openai/types/responses/tool_choice_types_param.py
+++ b/src/openai/types/responses/tool_choice_types_param.py
@@ -9,7 +9,14 @@
 
 class ToolChoiceTypesParam(TypedDict, total=False):
     type: Required[
-        Literal["file_search", "web_search_preview", "computer_use_preview", "web_search_preview_2025_03_11"]
+        Literal[
+            "file_search",
+            "web_search_preview",
+            "computer_use_preview",
+            "web_search_preview_2025_03_11",
+            "image_generation",
+            "code_interpreter",
+        ]
     ]
     """The type of hosted tool the model should to use.
 
@@ -21,4 +28,6 @@ class ToolChoiceTypesParam(TypedDict, total=False):
     - `file_search`
     - `web_search_preview`
     - `computer_use_preview`
+    - `code_interpreter`
+    - `image_generation`
     """
diff --git a/src/openai/types/responses/tool_param.py b/src/openai/types/responses/tool_param.py
index be1cf82452..18b044ab8c 100644
--- a/src/openai/types/responses/tool_param.py
+++ b/src/openai/types/responses/tool_param.py
@@ -2,17 +2,270 @@
 
 from __future__ import annotations
 
-from typing import Union
-from typing_extensions import TypeAlias
+from typing import Dict, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from . import web_search_tool_param
+from ..chat import ChatCompletionFunctionToolParam
+from ..._types import SequenceNotStr
+from .custom_tool_param import CustomToolParam
 from .computer_tool_param import ComputerToolParam
 from .function_tool_param import FunctionToolParam
 from .web_search_tool_param import WebSearchToolParam
+from .apply_patch_tool_param import ApplyPatchToolParam
 from .file_search_tool_param import FileSearchToolParam
-from ..chat.chat_completion_tool_param import ChatCompletionToolParam
+from .function_shell_tool_param import FunctionShellToolParam
+from .web_search_preview_tool_param import WebSearchPreviewToolParam
 
-__all__ = ["ToolParam"]
+__all__ = [
+    "ToolParam",
+    "Mcp",
+    "McpAllowedTools",
+    "McpAllowedToolsMcpToolFilter",
+    "McpRequireApproval",
+    "McpRequireApprovalMcpToolApprovalFilter",
+    "McpRequireApprovalMcpToolApprovalFilterAlways",
+    "McpRequireApprovalMcpToolApprovalFilterNever",
+    "CodeInterpreter",
+    "CodeInterpreterContainer",
+    "CodeInterpreterContainerCodeInterpreterToolAuto",
+    "ImageGeneration",
+    "ImageGenerationInputImageMask",
+    "LocalShell",
+]
 
-ToolParam: TypeAlias = Union[FileSearchToolParam, FunctionToolParam, ComputerToolParam, WebSearchToolParam]
+WebSearchTool = web_search_tool_param.WebSearchToolParam
+WebSearchToolFilters = web_search_tool_param.Filters
+WebSearchToolUserLocation = web_search_tool_param.UserLocation
 
-ParseableToolParam: TypeAlias = Union[ToolParam, ChatCompletionToolParam]
+
+class McpAllowedToolsMcpToolFilter(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+McpAllowedTools: TypeAlias = Union[SequenceNotStr[str], McpAllowedToolsMcpToolFilter]
+
+
+class McpRequireApprovalMcpToolApprovalFilterAlways(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilterNever(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""
+
+
+class McpRequireApprovalMcpToolApprovalFilter(TypedDict, total=False):
+    always: McpRequireApprovalMcpToolApprovalFilterAlways
+    """A filter object to specify which tools are allowed."""
+
+    never: McpRequireApprovalMcpToolApprovalFilterNever
+    """A filter object to specify which tools are allowed."""
+
+
+McpRequireApproval: TypeAlias = Union[McpRequireApprovalMcpToolApprovalFilter, Literal["always", "never"]]
+
+
+class Mcp(TypedDict, total=False):
+    server_label: Required[str]
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Required[Literal["mcp"]]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[McpAllowedTools]
+    """List of allowed tool names or a filter object."""
+
+    authorization: str
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Literal[
+        "connector_dropbox",
+        "connector_gmail",
+        "connector_googlecalendar",
+        "connector_googledrive",
+        "connector_microsoftteams",
+        "connector_outlookcalendar",
+        "connector_outlookemail",
+        "connector_sharepoint",
+    ]
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]]
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[McpRequireApproval]
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: str
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: str
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
+
+
+class CodeInterpreterContainerCodeInterpreterToolAuto(TypedDict, total=False):
+    type: Required[Literal["auto"]]
+    """Always `auto`."""
+
+    file_ids: SequenceNotStr[str]
+    """An optional list of uploaded files to make available to your code."""
+
+    memory_limit: Optional[Literal["1g", "4g", "16g", "64g"]]
+
+
+CodeInterpreterContainer: TypeAlias = Union[str, CodeInterpreterContainerCodeInterpreterToolAuto]
+
+
+class CodeInterpreter(TypedDict, total=False):
+    container: Required[CodeInterpreterContainer]
+    """The code interpreter container.
+
+    Can be a container ID or an object that specifies uploaded file IDs to make
+    available to your code.
+    """
+
+    type: Required[Literal["code_interpreter"]]
+    """The type of the code interpreter tool. Always `code_interpreter`."""
+
+
+class ImageGenerationInputImageMask(TypedDict, total=False):
+    file_id: str
+    """File ID for the mask image."""
+
+    image_url: str
+    """Base64-encoded mask image."""
+
+
+class ImageGeneration(TypedDict, total=False):
+    type: Required[Literal["image_generation"]]
+    """The type of the image generation tool. Always `image_generation`."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """Background type for the generated image.
+
+    One of `transparent`, `opaque`, or `auto`. Default: `auto`.
+    """
+
+    input_fidelity: Optional[Literal["high", "low"]]
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+    `low`. Defaults to `low`.
+    """
+
+    input_image_mask: ImageGenerationInputImageMask
+    """Optional mask for inpainting.
+
+    Contains `image_url` (string, optional) and `file_id` (string, optional).
+    """
+
+    model: Literal["gpt-image-1", "gpt-image-1-mini"]
+    """The image generation model to use. Default: `gpt-image-1`."""
+
+    moderation: Literal["auto", "low"]
+    """Moderation level for the generated image. Default: `auto`."""
+
+    output_compression: int
+    """Compression level for the output image. Default: 100."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format of the generated image.
+
+    One of `png`, `webp`, or `jpeg`. Default: `png`.
+    """
+
+    partial_images: int
+    """
+    Number of partial images to generate in streaming mode, from 0 (default value)
+    to 3.
+    """
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality of the generated image.
+
+    One of `low`, `medium`, `high`, or `auto`. Default: `auto`.
+    """
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the generated image.
+
+    One of `1024x1024`, `1024x1536`, `1536x1024`, or `auto`. Default: `auto`.
+    """
+
+
+class LocalShell(TypedDict, total=False):
+    type: Required[Literal["local_shell"]]
+    """The type of the local shell tool. Always `local_shell`."""
+
+
+ToolParam: TypeAlias = Union[
+    FunctionToolParam,
+    FileSearchToolParam,
+    ComputerToolParam,
+    WebSearchToolParam,
+    Mcp,
+    CodeInterpreter,
+    ImageGeneration,
+    LocalShell,
+    FunctionShellToolParam,
+    CustomToolParam,
+    WebSearchPreviewToolParam,
+    ApplyPatchToolParam,
+]
+
+
+ParseableToolParam: TypeAlias = Union[ToolParam, ChatCompletionFunctionToolParam]
diff --git a/src/openai/types/responses/web_search_preview_tool.py b/src/openai/types/responses/web_search_preview_tool.py
new file mode 100644
index 0000000000..66d6a24679
--- /dev/null
+++ b/src/openai/types/responses/web_search_preview_tool.py
@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["WebSearchPreviewTool", "UserLocation"]
+
+
+class UserLocation(BaseModel):
+    type: Literal["approximate"]
+    """The type of location approximation. Always `approximate`."""
+
+    city: Optional[str] = None
+    """Free text input for the city of the user, e.g. `San Francisco`."""
+
+    country: Optional[str] = None
+    """
+    The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of
+    the user, e.g. `US`.
+    """
+
+    region: Optional[str] = None
+    """Free text input for the region of the user, e.g. `California`."""
+
+    timezone: Optional[str] = None
+    """
+    The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the
+    user, e.g. `America/Los_Angeles`.
+    """
+
+
+class WebSearchPreviewTool(BaseModel):
+    type: Literal["web_search_preview", "web_search_preview_2025_03_11"]
+    """The type of the web search tool.
+
+    One of `web_search_preview` or `web_search_preview_2025_03_11`.
+    """
+
+    search_context_size: Optional[Literal["low", "medium", "high"]] = None
+    """High level guidance for the amount of context window space to use for the
+    search.
+
+    One of `low`, `medium`, or `high`. `medium` is the default.
+    """
+
+    user_location: Optional[UserLocation] = None
+    """The user's location."""
diff --git a/src/openai/types/responses/web_search_preview_tool_param.py b/src/openai/types/responses/web_search_preview_tool_param.py
new file mode 100644
index 0000000000..ec2173f8e8
--- /dev/null
+++ b/src/openai/types/responses/web_search_preview_tool_param.py
@@ -0,0 +1,49 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["WebSearchPreviewToolParam", "UserLocation"]
+
+
+class UserLocation(TypedDict, total=False):
+    type: Required[Literal["approximate"]]
+    """The type of location approximation. Always `approximate`."""
+
+    city: Optional[str]
+    """Free text input for the city of the user, e.g. `San Francisco`."""
+
+    country: Optional[str]
+    """
+    The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of
+    the user, e.g. `US`.
+    """
+
+    region: Optional[str]
+    """Free text input for the region of the user, e.g. `California`."""
+
+    timezone: Optional[str]
+    """
+    The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the
+    user, e.g. `America/Los_Angeles`.
+    """
+
+
+class WebSearchPreviewToolParam(TypedDict, total=False):
+    type: Required[Literal["web_search_preview", "web_search_preview_2025_03_11"]]
+    """The type of the web search tool.
+
+    One of `web_search_preview` or `web_search_preview_2025_03_11`.
+    """
+
+    search_context_size: Literal["low", "medium", "high"]
+    """High level guidance for the amount of context window space to use for the
+    search.
+
+    One of `low`, `medium`, or `high`. `medium` is the default.
+    """
+
+    user_location: Optional[UserLocation]
+    """The user's location."""
diff --git a/src/openai/types/responses/web_search_tool.py b/src/openai/types/responses/web_search_tool.py
index bee270bf85..bde9600c87 100644
--- a/src/openai/types/responses/web_search_tool.py
+++ b/src/openai/types/responses/web_search_tool.py
@@ -1,17 +1,25 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Optional
+from typing import List, Optional
 from typing_extensions import Literal
 
 from ..._models import BaseModel
 
-__all__ = ["WebSearchTool", "UserLocation"]
+__all__ = ["WebSearchTool", "Filters", "UserLocation"]
 
 
-class UserLocation(BaseModel):
-    type: Literal["approximate"]
-    """The type of location approximation. Always `approximate`."""
+class Filters(BaseModel):
+    allowed_domains: Optional[List[str]] = None
+    """Allowed domains for the search.
+
+    If not provided, all domains are allowed. Subdomains of the provided domains are
+    allowed as well.
+
+    Example: `["pubmed.ncbi.nlm.nih.gov"]`
+    """
+
 
+class UserLocation(BaseModel):
     city: Optional[str] = None
     """Free text input for the city of the user, e.g. `San Francisco`."""
 
@@ -30,19 +38,26 @@ class UserLocation(BaseModel):
     user, e.g. `America/Los_Angeles`.
     """
 
+    type: Optional[Literal["approximate"]] = None
+    """The type of location approximation. Always `approximate`."""
+
 
 class WebSearchTool(BaseModel):
-    type: Literal["web_search_preview", "web_search_preview_2025_03_11"]
-    """The type of the web search tool. One of:
+    type: Literal["web_search", "web_search_2025_08_26"]
+    """The type of the web search tool.
 
-    - `web_search_preview`
-    - `web_search_preview_2025_03_11`
+    One of `web_search` or `web_search_2025_08_26`.
     """
 
+    filters: Optional[Filters] = None
+    """Filters for the search."""
+
     search_context_size: Optional[Literal["low", "medium", "high"]] = None
-    """
-    High level guidance for the amount of context window space to use for the
-    search. One of `low`, `medium`, or `high`. `medium` is the default.
+    """High level guidance for the amount of context window space to use for the
+    search.
+
+    One of `low`, `medium`, or `high`. `medium` is the default.
     """
 
     user_location: Optional[UserLocation] = None
+    """The approximate location of the user."""
diff --git a/src/openai/types/responses/web_search_tool_param.py b/src/openai/types/responses/web_search_tool_param.py
index 8ee36ffb47..7fa19e9c23 100644
--- a/src/openai/types/responses/web_search_tool_param.py
+++ b/src/openai/types/responses/web_search_tool_param.py
@@ -5,44 +5,61 @@
 from typing import Optional
 from typing_extensions import Literal, Required, TypedDict
 
-__all__ = ["WebSearchToolParam", "UserLocation"]
+from ..._types import SequenceNotStr
 
+__all__ = ["WebSearchToolParam", "Filters", "UserLocation"]
+
+
+class Filters(TypedDict, total=False):
+    allowed_domains: Optional[SequenceNotStr[str]]
+    """Allowed domains for the search.
+
+    If not provided, all domains are allowed. Subdomains of the provided domains are
+    allowed as well.
+
+    Example: `["pubmed.ncbi.nlm.nih.gov"]`
+    """
 
-class UserLocation(TypedDict, total=False):
-    type: Required[Literal["approximate"]]
-    """The type of location approximation. Always `approximate`."""
 
-    city: str
+class UserLocation(TypedDict, total=False):
+    city: Optional[str]
     """Free text input for the city of the user, e.g. `San Francisco`."""
 
-    country: str
+    country: Optional[str]
     """
     The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of
     the user, e.g. `US`.
     """
 
-    region: str
+    region: Optional[str]
     """Free text input for the region of the user, e.g. `California`."""
 
-    timezone: str
+    timezone: Optional[str]
     """
     The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the
     user, e.g. `America/Los_Angeles`.
     """
 
+    type: Literal["approximate"]
+    """The type of location approximation. Always `approximate`."""
+
 
 class WebSearchToolParam(TypedDict, total=False):
-    type: Required[Literal["web_search_preview", "web_search_preview_2025_03_11"]]
-    """The type of the web search tool. One of:
+    type: Required[Literal["web_search", "web_search_2025_08_26"]]
+    """The type of the web search tool.
 
-    - `web_search_preview`
-    - `web_search_preview_2025_03_11`
+    One of `web_search` or `web_search_2025_08_26`.
     """
 
+    filters: Optional[Filters]
+    """Filters for the search."""
+
     search_context_size: Literal["low", "medium", "high"]
-    """
-    High level guidance for the amount of context window space to use for the
-    search. One of `low`, `medium`, or `high`. `medium` is the default.
+    """High level guidance for the amount of context window space to use for the
+    search.
+
+    One of `low`, `medium`, or `high`. `medium` is the default.
     """
 
     user_location: Optional[UserLocation]
+    """The approximate location of the user."""
diff --git a/src/openai/types/shared/__init__.py b/src/openai/types/shared/__init__.py
index 6ccc2313cc..2930b9ae3b 100644
--- a/src/openai/types/shared/__init__.py
+++ b/src/openai/types/shared/__init__.py
@@ -2,13 +2,18 @@
 
 from .metadata import Metadata as Metadata
 from .reasoning import Reasoning as Reasoning
+from .all_models import AllModels as AllModels
 from .chat_model import ChatModel as ChatModel
 from .error_object import ErrorObject as ErrorObject
 from .compound_filter import CompoundFilter as CompoundFilter
+from .responses_model import ResponsesModel as ResponsesModel
 from .reasoning_effort import ReasoningEffort as ReasoningEffort
 from .comparison_filter import ComparisonFilter as ComparisonFilter
 from .function_definition import FunctionDefinition as FunctionDefinition
 from .function_parameters import FunctionParameters as FunctionParameters
 from .response_format_text import ResponseFormatText as ResponseFormatText
+from .custom_tool_input_format import CustomToolInputFormat as CustomToolInputFormat
 from .response_format_json_object import ResponseFormatJSONObject as ResponseFormatJSONObject
 from .response_format_json_schema import ResponseFormatJSONSchema as ResponseFormatJSONSchema
+from .response_format_text_python import ResponseFormatTextPython as ResponseFormatTextPython
+from .response_format_text_grammar import ResponseFormatTextGrammar as ResponseFormatTextGrammar
diff --git a/src/openai/types/shared/all_models.py b/src/openai/types/shared/all_models.py
new file mode 100644
index 0000000000..3e0b09e2d1
--- /dev/null
+++ b/src/openai/types/shared/all_models.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from .chat_model import ChatModel
+
+__all__ = ["AllModels"]
+
+AllModels: TypeAlias = Union[
+    str,
+    ChatModel,
+    Literal[
+        "o1-pro",
+        "o1-pro-2025-03-19",
+        "o3-pro",
+        "o3-pro-2025-06-10",
+        "o3-deep-research",
+        "o3-deep-research-2025-06-26",
+        "o4-mini-deep-research",
+        "o4-mini-deep-research-2025-06-26",
+        "computer-use-preview",
+        "computer-use-preview-2025-03-11",
+        "gpt-5-codex",
+        "gpt-5-pro",
+        "gpt-5-pro-2025-10-06",
+    ],
+]
diff --git a/src/openai/types/shared/chat_model.py b/src/openai/types/shared/chat_model.py
index 31d7104e6e..b3ae7c3a95 100644
--- a/src/openai/types/shared/chat_model.py
+++ b/src/openai/types/shared/chat_model.py
@@ -5,6 +5,28 @@
 __all__ = ["ChatModel"]
 
 ChatModel: TypeAlias = Literal[
+    "gpt-5.1",
+    "gpt-5.1-2025-11-13",
+    "gpt-5.1-codex",
+    "gpt-5.1-mini",
+    "gpt-5.1-chat-latest",
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-5-2025-08-07",
+    "gpt-5-mini-2025-08-07",
+    "gpt-5-nano-2025-08-07",
+    "gpt-5-chat-latest",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4.1-2025-04-14",
+    "gpt-4.1-mini-2025-04-14",
+    "gpt-4.1-nano-2025-04-14",
+    "o4-mini",
+    "o4-mini-2025-04-16",
+    "o3",
+    "o3-2025-04-16",
     "o3-mini",
     "o3-mini-2025-01-31",
     "o1",
@@ -13,11 +35,6 @@
     "o1-preview-2024-09-12",
     "o1-mini",
     "o1-mini-2024-09-12",
-    "computer-use-preview",
-    "computer-use-preview-2025-02-04",
-    "computer-use-preview-2025-03-11",
-    "gpt-4.5-preview",
-    "gpt-4.5-preview-2025-02-27",
     "gpt-4o",
     "gpt-4o-2024-11-20",
     "gpt-4o-2024-08-06",
@@ -25,9 +42,15 @@
     "gpt-4o-audio-preview",
     "gpt-4o-audio-preview-2024-10-01",
     "gpt-4o-audio-preview-2024-12-17",
+    "gpt-4o-audio-preview-2025-06-03",
     "gpt-4o-mini-audio-preview",
     "gpt-4o-mini-audio-preview-2024-12-17",
+    "gpt-4o-search-preview",
+    "gpt-4o-mini-search-preview",
+    "gpt-4o-search-preview-2025-03-11",
+    "gpt-4o-mini-search-preview-2025-03-11",
     "chatgpt-4o-latest",
+    "codex-mini-latest",
     "gpt-4o-mini",
     "gpt-4o-mini-2024-07-18",
     "gpt-4-turbo",
diff --git a/src/openai/types/shared/comparison_filter.py b/src/openai/types/shared/comparison_filter.py
index 2ec2651ff2..33415ca4f9 100644
--- a/src/openai/types/shared/comparison_filter.py
+++ b/src/openai/types/shared/comparison_filter.py
@@ -1,6 +1,6 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import Union
+from typing import List, Union
 from typing_extensions import Literal
 
 from ..._models import BaseModel
@@ -13,7 +13,9 @@ class ComparisonFilter(BaseModel):
     """The key to compare against the value."""
 
     type: Literal["eq", "ne", "gt", "gte", "lt", "lte"]
-    """Specifies the comparison operator: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`.
+    """
+    Specifies the comparison operator: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`,
+    `nin`.
 
     - `eq`: equals
     - `ne`: not equal
@@ -21,9 +23,11 @@ class ComparisonFilter(BaseModel):
     - `gte`: greater than or equal
     - `lt`: less than
     - `lte`: less than or equal
+    - `in`: in
+    - `nin`: not in
     """
 
-    value: Union[str, float, bool]
+    value: Union[str, float, bool, List[Union[str, float]]]
     """
     The value to compare against the attribute key; supports string, number, or
     boolean types.
diff --git a/src/openai/types/shared/custom_tool_input_format.py b/src/openai/types/shared/custom_tool_input_format.py
new file mode 100644
index 0000000000..53c8323ed2
--- /dev/null
+++ b/src/openai/types/shared/custom_tool_input_format.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = ["CustomToolInputFormat", "Text", "Grammar"]
+
+
+class Text(BaseModel):
+    type: Literal["text"]
+    """Unconstrained text format. Always `text`."""
+
+
+class Grammar(BaseModel):
+    definition: str
+    """The grammar definition."""
+
+    syntax: Literal["lark", "regex"]
+    """The syntax of the grammar definition. One of `lark` or `regex`."""
+
+    type: Literal["grammar"]
+    """Grammar format. Always `grammar`."""
+
+
+CustomToolInputFormat: TypeAlias = Annotated[Union[Text, Grammar], PropertyInfo(discriminator="type")]
diff --git a/src/openai/types/shared/function_definition.py b/src/openai/types/shared/function_definition.py
index 06baa23170..33ebb9ad3e 100644
--- a/src/openai/types/shared/function_definition.py
+++ b/src/openai/types/shared/function_definition.py
@@ -39,5 +39,5 @@ class FunctionDefinition(BaseModel):
     If set to true, the model will follow the exact schema defined in the
     `parameters` field. Only a subset of JSON Schema is supported when `strict` is
     `true`. Learn more about Structured Outputs in the
-    [function calling guide](docs/guides/function-calling).
+    [function calling guide](https://platform.openai.com/docs/guides/function-calling).
     """
diff --git a/src/openai/types/shared/reasoning.py b/src/openai/types/shared/reasoning.py
index 50821a1727..cf470ca057 100644
--- a/src/openai/types/shared/reasoning.py
+++ b/src/openai/types/shared/reasoning.py
@@ -11,18 +11,34 @@
 
 class Reasoning(BaseModel):
     effort: Optional[ReasoningEffort] = None
-    """**o-series models only**
-
+    """
     Constrains effort on reasoning for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-    result in faster responses and fewer tokens used on reasoning in a response.
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     """
 
-    generate_summary: Optional[Literal["concise", "detailed"]] = None
-    """**o-series models only**
+    generate_summary: Optional[Literal["auto", "concise", "detailed"]] = None
+    """**Deprecated:** use `summary` instead.
 
     A summary of the reasoning performed by the model. This can be useful for
-    debugging and understanding the model's reasoning process. One of `concise` or
-    `detailed`.
+    debugging and understanding the model's reasoning process. One of `auto`,
+    `concise`, or `detailed`.
+    """
+
+    summary: Optional[Literal["auto", "concise", "detailed"]] = None
+    """A summary of the reasoning performed by the model.
+
+    This can be useful for debugging and understanding the model's reasoning
+    process. One of `auto`, `concise`, or `detailed`.
+
+    `concise` is only supported for `computer-use-preview` models.
     """
diff --git a/src/openai/types/shared/reasoning_effort.py b/src/openai/types/shared/reasoning_effort.py
index ace21b67e4..c890a133cc 100644
--- a/src/openai/types/shared/reasoning_effort.py
+++ b/src/openai/types/shared/reasoning_effort.py
@@ -5,4 +5,4 @@
 
 __all__ = ["ReasoningEffort"]
 
-ReasoningEffort: TypeAlias = Optional[Literal["low", "medium", "high"]]
+ReasoningEffort: TypeAlias = Optional[Literal["none", "minimal", "low", "medium", "high"]]
diff --git a/src/openai/types/shared/response_format_text_grammar.py b/src/openai/types/shared/response_format_text_grammar.py
new file mode 100644
index 0000000000..b02f99c1b8
--- /dev/null
+++ b/src/openai/types/shared/response_format_text_grammar.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseFormatTextGrammar"]
+
+
+class ResponseFormatTextGrammar(BaseModel):
+    grammar: str
+    """The custom grammar for the model to follow."""
+
+    type: Literal["grammar"]
+    """The type of response format being defined. Always `grammar`."""
diff --git a/src/openai/types/shared/response_format_text_python.py b/src/openai/types/shared/response_format_text_python.py
new file mode 100644
index 0000000000..4cd18d46fa
--- /dev/null
+++ b/src/openai/types/shared/response_format_text_python.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseFormatTextPython"]
+
+
+class ResponseFormatTextPython(BaseModel):
+    type: Literal["python"]
+    """The type of response format being defined. Always `python`."""
diff --git a/src/openai/types/shared/responses_model.py b/src/openai/types/shared/responses_model.py
new file mode 100644
index 0000000000..432cb82afd
--- /dev/null
+++ b/src/openai/types/shared/responses_model.py
@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from .chat_model import ChatModel
+
+__all__ = ["ResponsesModel"]
+
+ResponsesModel: TypeAlias = Union[
+    str,
+    ChatModel,
+    Literal[
+        "o1-pro",
+        "o1-pro-2025-03-19",
+        "o3-pro",
+        "o3-pro-2025-06-10",
+        "o3-deep-research",
+        "o3-deep-research-2025-06-26",
+        "o4-mini-deep-research",
+        "o4-mini-deep-research-2025-06-26",
+        "computer-use-preview",
+        "computer-use-preview-2025-03-11",
+        "gpt-5-codex",
+        "gpt-5-pro",
+        "gpt-5-pro-2025-10-06",
+    ],
+]
diff --git a/src/openai/types/shared_params/__init__.py b/src/openai/types/shared_params/__init__.py
index 4a4a8cdf1e..b6c0912b0f 100644
--- a/src/openai/types/shared_params/__init__.py
+++ b/src/openai/types/shared_params/__init__.py
@@ -4,10 +4,12 @@
 from .reasoning import Reasoning as Reasoning
 from .chat_model import ChatModel as ChatModel
 from .compound_filter import CompoundFilter as CompoundFilter
+from .responses_model import ResponsesModel as ResponsesModel
 from .reasoning_effort import ReasoningEffort as ReasoningEffort
 from .comparison_filter import ComparisonFilter as ComparisonFilter
 from .function_definition import FunctionDefinition as FunctionDefinition
 from .function_parameters import FunctionParameters as FunctionParameters
 from .response_format_text import ResponseFormatText as ResponseFormatText
+from .custom_tool_input_format import CustomToolInputFormat as CustomToolInputFormat
 from .response_format_json_object import ResponseFormatJSONObject as ResponseFormatJSONObject
 from .response_format_json_schema import ResponseFormatJSONSchema as ResponseFormatJSONSchema
diff --git a/src/openai/types/shared_params/chat_model.py b/src/openai/types/shared_params/chat_model.py
index 55649876eb..7505d51d67 100644
--- a/src/openai/types/shared_params/chat_model.py
+++ b/src/openai/types/shared_params/chat_model.py
@@ -7,6 +7,28 @@
 __all__ = ["ChatModel"]
 
 ChatModel: TypeAlias = Literal[
+    "gpt-5.1",
+    "gpt-5.1-2025-11-13",
+    "gpt-5.1-codex",
+    "gpt-5.1-mini",
+    "gpt-5.1-chat-latest",
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-5-2025-08-07",
+    "gpt-5-mini-2025-08-07",
+    "gpt-5-nano-2025-08-07",
+    "gpt-5-chat-latest",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4.1-2025-04-14",
+    "gpt-4.1-mini-2025-04-14",
+    "gpt-4.1-nano-2025-04-14",
+    "o4-mini",
+    "o4-mini-2025-04-16",
+    "o3",
+    "o3-2025-04-16",
     "o3-mini",
     "o3-mini-2025-01-31",
     "o1",
@@ -15,11 +37,6 @@
     "o1-preview-2024-09-12",
     "o1-mini",
     "o1-mini-2024-09-12",
-    "computer-use-preview",
-    "computer-use-preview-2025-02-04",
-    "computer-use-preview-2025-03-11",
-    "gpt-4.5-preview",
-    "gpt-4.5-preview-2025-02-27",
     "gpt-4o",
     "gpt-4o-2024-11-20",
     "gpt-4o-2024-08-06",
@@ -27,9 +44,15 @@
     "gpt-4o-audio-preview",
     "gpt-4o-audio-preview-2024-10-01",
     "gpt-4o-audio-preview-2024-12-17",
+    "gpt-4o-audio-preview-2025-06-03",
     "gpt-4o-mini-audio-preview",
     "gpt-4o-mini-audio-preview-2024-12-17",
+    "gpt-4o-search-preview",
+    "gpt-4o-mini-search-preview",
+    "gpt-4o-search-preview-2025-03-11",
+    "gpt-4o-mini-search-preview-2025-03-11",
     "chatgpt-4o-latest",
+    "codex-mini-latest",
     "gpt-4o-mini",
     "gpt-4o-mini-2024-07-18",
     "gpt-4-turbo",
diff --git a/src/openai/types/shared_params/comparison_filter.py b/src/openai/types/shared_params/comparison_filter.py
index 38edd315ed..1c40729c19 100644
--- a/src/openai/types/shared_params/comparison_filter.py
+++ b/src/openai/types/shared_params/comparison_filter.py
@@ -5,6 +5,8 @@
 from typing import Union
 from typing_extensions import Literal, Required, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["ComparisonFilter"]
 
 
@@ -13,7 +15,9 @@ class ComparisonFilter(TypedDict, total=False):
     """The key to compare against the value."""
 
     type: Required[Literal["eq", "ne", "gt", "gte", "lt", "lte"]]
-    """Specifies the comparison operator: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`.
+    """
+    Specifies the comparison operator: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`,
+    `nin`.
 
     - `eq`: equals
     - `ne`: not equal
@@ -21,9 +25,11 @@ class ComparisonFilter(TypedDict, total=False):
     - `gte`: greater than or equal
     - `lt`: less than
     - `lte`: less than or equal
+    - `in`: in
+    - `nin`: not in
     """
 
-    value: Required[Union[str, float, bool]]
+    value: Required[Union[str, float, bool, SequenceNotStr[Union[str, float]]]]
     """
     The value to compare against the attribute key; supports string, number, or
     boolean types.
diff --git a/src/openai/types/shared_params/custom_tool_input_format.py b/src/openai/types/shared_params/custom_tool_input_format.py
new file mode 100644
index 0000000000..37df393e39
--- /dev/null
+++ b/src/openai/types/shared_params/custom_tool_input_format.py
@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["CustomToolInputFormat", "Text", "Grammar"]
+
+
+class Text(TypedDict, total=False):
+    type: Required[Literal["text"]]
+    """Unconstrained text format. Always `text`."""
+
+
+class Grammar(TypedDict, total=False):
+    definition: Required[str]
+    """The grammar definition."""
+
+    syntax: Required[Literal["lark", "regex"]]
+    """The syntax of the grammar definition. One of `lark` or `regex`."""
+
+    type: Required[Literal["grammar"]]
+    """Grammar format. Always `grammar`."""
+
+
+CustomToolInputFormat: TypeAlias = Union[Text, Grammar]
diff --git a/src/openai/types/shared_params/function_definition.py b/src/openai/types/shared_params/function_definition.py
index d45ec13f1e..b3fdaf86ff 100644
--- a/src/openai/types/shared_params/function_definition.py
+++ b/src/openai/types/shared_params/function_definition.py
@@ -41,5 +41,5 @@ class FunctionDefinition(TypedDict, total=False):
     If set to true, the model will follow the exact schema defined in the
     `parameters` field. Only a subset of JSON Schema is supported when `strict` is
     `true`. Learn more about Structured Outputs in the
-    [function calling guide](docs/guides/function-calling).
+    [function calling guide](https://platform.openai.com/docs/guides/function-calling).
     """
diff --git a/src/openai/types/shared_params/reasoning.py b/src/openai/types/shared_params/reasoning.py
index f2b5c5963a..ad58f70b71 100644
--- a/src/openai/types/shared_params/reasoning.py
+++ b/src/openai/types/shared_params/reasoning.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from typing import Optional
-from typing_extensions import Literal, Required, TypedDict
+from typing_extensions import Literal, TypedDict
 
 from ..shared.reasoning_effort import ReasoningEffort
 
@@ -11,19 +11,35 @@
 
 
 class Reasoning(TypedDict, total=False):
-    effort: Required[Optional[ReasoningEffort]]
-    """**o-series models only**
-
+    effort: Optional[ReasoningEffort]
+    """
     Constrains effort on reasoning for
     [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-    result in faster responses and fewer tokens used on reasoning in a response.
+    supported values are `none`, `minimal`, `low`, `medium`, and `high`. Reducing
+    reasoning effort can result in faster responses and fewer tokens used on
+    reasoning in a response.
+
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
+      reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
+      calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
+      support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
     """
 
-    generate_summary: Optional[Literal["concise", "detailed"]]
-    """**o-series models only**
+    generate_summary: Optional[Literal["auto", "concise", "detailed"]]
+    """**Deprecated:** use `summary` instead.
 
     A summary of the reasoning performed by the model. This can be useful for
-    debugging and understanding the model's reasoning process. One of `concise` or
-    `detailed`.
+    debugging and understanding the model's reasoning process. One of `auto`,
+    `concise`, or `detailed`.
+    """
+
+    summary: Optional[Literal["auto", "concise", "detailed"]]
+    """A summary of the reasoning performed by the model.
+
+    This can be useful for debugging and understanding the model's reasoning
+    process. One of `auto`, `concise`, or `detailed`.
+
+    `concise` is only supported for `computer-use-preview` models.
     """
diff --git a/src/openai/types/shared_params/reasoning_effort.py b/src/openai/types/shared_params/reasoning_effort.py
index 6052c5ae15..e388eebff1 100644
--- a/src/openai/types/shared_params/reasoning_effort.py
+++ b/src/openai/types/shared_params/reasoning_effort.py
@@ -7,4 +7,4 @@
 
 __all__ = ["ReasoningEffort"]
 
-ReasoningEffort: TypeAlias = Optional[Literal["low", "medium", "high"]]
+ReasoningEffort: TypeAlias = Optional[Literal["none", "minimal", "low", "medium", "high"]]
diff --git a/src/openai/types/shared_params/responses_model.py b/src/openai/types/shared_params/responses_model.py
new file mode 100644
index 0000000000..fe34eb0f62
--- /dev/null
+++ b/src/openai/types/shared_params/responses_model.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias
+
+from ..shared.chat_model import ChatModel
+
+__all__ = ["ResponsesModel"]
+
+ResponsesModel: TypeAlias = Union[
+    str,
+    ChatModel,
+    Literal[
+        "o1-pro",
+        "o1-pro-2025-03-19",
+        "o3-pro",
+        "o3-pro-2025-06-10",
+        "o3-deep-research",
+        "o3-deep-research-2025-06-26",
+        "o4-mini-deep-research",
+        "o4-mini-deep-research-2025-06-26",
+        "computer-use-preview",
+        "computer-use-preview-2025-03-11",
+        "gpt-5-codex",
+        "gpt-5-pro",
+        "gpt-5-pro-2025-10-06",
+    ],
+]
diff --git a/src/openai/types/static_file_chunking_strategy.py b/src/openai/types/static_file_chunking_strategy.py
index 2813bc6630..cb842442c1 100644
--- a/src/openai/types/static_file_chunking_strategy.py
+++ b/src/openai/types/static_file_chunking_strategy.py
@@ -1,6 +1,5 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-
 from .._models import BaseModel
 
 __all__ = ["StaticFileChunkingStrategy"]
diff --git a/src/openai/types/upload_complete_params.py b/src/openai/types/upload_complete_params.py
index cce568d5c6..846a241dc7 100644
--- a/src/openai/types/upload_complete_params.py
+++ b/src/openai/types/upload_complete_params.py
@@ -2,14 +2,15 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["UploadCompleteParams"]
 
 
 class UploadCompleteParams(TypedDict, total=False):
-    part_ids: Required[List[str]]
+    part_ids: Required[SequenceNotStr[str]]
     """The ordered list of Part IDs."""
 
     md5: str
diff --git a/src/openai/types/upload_create_params.py b/src/openai/types/upload_create_params.py
index 2ebabe6c66..ab4cded81d 100644
--- a/src/openai/types/upload_create_params.py
+++ b/src/openai/types/upload_create_params.py
@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-from typing_extensions import Required, TypedDict
+from typing_extensions import Literal, Required, TypedDict
 
 from .file_purpose import FilePurpose
 
-__all__ = ["UploadCreateParams"]
+__all__ = ["UploadCreateParams", "ExpiresAfter"]
 
 
 class UploadCreateParams(TypedDict, total=False):
@@ -29,3 +29,24 @@ class UploadCreateParams(TypedDict, total=False):
     See the
     [documentation on File purposes](https://platform.openai.com/docs/api-reference/files/create#files-create-purpose).
     """
+
+    expires_after: ExpiresAfter
+    """The expiration policy for a file.
+
+    By default, files with `purpose=batch` expire after 30 days and all other files
+    are persisted until they are manually deleted.
+    """
+
+
+class ExpiresAfter(TypedDict, total=False):
+    anchor: Required[Literal["created_at"]]
+    """Anchor timestamp after which the expiration policy applies.
+
+    Supported anchors: `created_at`.
+    """
+
+    seconds: Required[int]
+    """The number of seconds after the anchor time that the file will expire.
+
+    Must be between 3600 (1 hour) and 2592000 (30 days).
+    """
diff --git a/src/openai/types/vector_store_create_params.py b/src/openai/types/vector_store_create_params.py
index 365d0936b1..f373a6ed28 100644
--- a/src/openai/types/vector_store_create_params.py
+++ b/src/openai/types/vector_store_create_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 from typing_extensions import Literal, Required, TypedDict
 
+from .._types import SequenceNotStr
 from .shared_params.metadata import Metadata
 from .file_chunking_strategy_param import FileChunkingStrategyParam
 
@@ -19,10 +20,16 @@ class VectorStoreCreateParams(TypedDict, total=False):
     non-empty.
     """
 
+    description: str
+    """A description for the vector store.
+
+    Can be used to describe the vector store's purpose.
+    """
+
     expires_after: ExpiresAfter
     """The expiration policy for a vector store."""
 
-    file_ids: List[str]
+    file_ids: SequenceNotStr[str]
     """
     A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
     the vector store should use. Useful for tools like `file_search` that can access
diff --git a/src/openai/types/vector_store_search_params.py b/src/openai/types/vector_store_search_params.py
index 17573d0f61..8b7b13c4a1 100644
--- a/src/openai/types/vector_store_search_params.py
+++ b/src/openai/types/vector_store_search_params.py
@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Union
+from typing import Union
 from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
+from .._types import SequenceNotStr
 from .shared_params.compound_filter import CompoundFilter
 from .shared_params.comparison_filter import ComparisonFilter
 
@@ -12,7 +13,7 @@
 
 
 class VectorStoreSearchParams(TypedDict, total=False):
-    query: Required[Union[str, List[str]]]
+    query: Required[Union[str, SequenceNotStr[str]]]
     """A query string for a search"""
 
     filters: Filters
@@ -35,6 +36,7 @@ class VectorStoreSearchParams(TypedDict, total=False):
 
 
 class RankingOptions(TypedDict, total=False):
-    ranker: Literal["auto", "default-2024-11-15"]
+    ranker: Literal["none", "auto", "default-2024-11-15"]
+    """Enable re-ranking; set to `none` to disable, which can help reduce latency."""
 
     score_threshold: float
diff --git a/src/openai/types/vector_stores/file_batch_create_params.py b/src/openai/types/vector_stores/file_batch_create_params.py
index 1a470f757a..2ab98a83ab 100644
--- a/src/openai/types/vector_stores/file_batch_create_params.py
+++ b/src/openai/types/vector_stores/file_batch_create_params.py
@@ -2,19 +2,54 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Optional
+from typing import Dict, Union, Iterable, Optional
 from typing_extensions import Required, TypedDict
 
+from ..._types import SequenceNotStr
 from ..file_chunking_strategy_param import FileChunkingStrategyParam
 
-__all__ = ["FileBatchCreateParams"]
+__all__ = ["FileBatchCreateParams", "File"]
 
 
 class FileBatchCreateParams(TypedDict, total=False):
-    file_ids: Required[List[str]]
+    attributes: Optional[Dict[str, Union[str, float, bool]]]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard. Keys are
+    strings with a maximum length of 64 characters. Values are strings with a
+    maximum length of 512 characters, booleans, or numbers.
+    """
+
+    chunking_strategy: FileChunkingStrategyParam
+    """The chunking strategy used to chunk the file(s).
+
+    If not set, will use the `auto` strategy. Only applicable if `file_ids` is
+    non-empty.
+    """
+
+    file_ids: SequenceNotStr[str]
     """
     A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
     the vector store should use. Useful for tools like `file_search` that can access
+    files. If `attributes` or `chunking_strategy` are provided, they will be applied
+    to all files in the batch. Mutually exclusive with `files`.
+    """
+
+    files: Iterable[File]
+    """
+    A list of objects that each include a `file_id` plus optional `attributes` or
+    `chunking_strategy`. Use this when you need to override metadata for specific
+    files. The global `attributes` or `chunking_strategy` will be ignored and must
+    be specified for each file. Mutually exclusive with `file_ids`.
+    """
+
+
+class File(TypedDict, total=False):
+    file_id: Required[str]
+    """
+    A [File](https://platform.openai.com/docs/api-reference/files) ID that the
+    vector store should use. Useful for tools like `file_search` that can access
     files.
     """
 
diff --git a/src/openai/types/vector_stores/vector_store_file.py b/src/openai/types/vector_stores/vector_store_file.py
index b59a61dfb0..001584dfd7 100644
--- a/src/openai/types/vector_stores/vector_store_file.py
+++ b/src/openai/types/vector_stores/vector_store_file.py
@@ -11,7 +11,7 @@
 
 class LastError(BaseModel):
     code: Literal["server_error", "unsupported_file", "invalid_file"]
-    """One of `server_error` or `rate_limit_exceeded`."""
+    """One of `server_error`, `unsupported_file`, or `invalid_file`."""
 
     message: str
     """A human-readable description of the error."""
diff --git a/src/openai/types/video.py b/src/openai/types/video.py
new file mode 100644
index 0000000000..22ee3a11f7
--- /dev/null
+++ b/src/openai/types/video.py
@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .video_size import VideoSize
+from .video_model import VideoModel
+from .video_seconds import VideoSeconds
+from .video_create_error import VideoCreateError
+
+__all__ = ["Video"]
+
+
+class Video(BaseModel):
+    id: str
+    """Unique identifier for the video job."""
+
+    completed_at: Optional[int] = None
+    """Unix timestamp (seconds) for when the job completed, if finished."""
+
+    created_at: int
+    """Unix timestamp (seconds) for when the job was created."""
+
+    error: Optional[VideoCreateError] = None
+    """Error payload that explains why generation failed, if applicable."""
+
+    expires_at: Optional[int] = None
+    """Unix timestamp (seconds) for when the downloadable assets expire, if set."""
+
+    model: VideoModel
+    """The video generation model that produced the job."""
+
+    object: Literal["video"]
+    """The object type, which is always `video`."""
+
+    progress: int
+    """Approximate completion percentage for the generation task."""
+
+    prompt: Optional[str] = None
+    """The prompt that was used to generate the video."""
+
+    remixed_from_video_id: Optional[str] = None
+    """Identifier of the source video if this video is a remix."""
+
+    seconds: VideoSeconds
+    """Duration of the generated clip in seconds."""
+
+    size: VideoSize
+    """The resolution of the generated video."""
+
+    status: Literal["queued", "in_progress", "completed", "failed"]
+    """Current lifecycle status of the video job."""
diff --git a/src/openai/types/video_create_error.py b/src/openai/types/video_create_error.py
new file mode 100644
index 0000000000..ae328b78ea
--- /dev/null
+++ b/src/openai/types/video_create_error.py
@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["VideoCreateError"]
+
+
+class VideoCreateError(BaseModel):
+    code: str
+
+    message: str
diff --git a/src/openai/types/video_create_params.py b/src/openai/types/video_create_params.py
new file mode 100644
index 0000000000..527d62d193
--- /dev/null
+++ b/src/openai/types/video_create_params.py
@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from .._types import FileTypes
+from .video_size import VideoSize
+from .video_model import VideoModel
+from .video_seconds import VideoSeconds
+
+__all__ = ["VideoCreateParams"]
+
+
+class VideoCreateParams(TypedDict, total=False):
+    prompt: Required[str]
+    """Text prompt that describes the video to generate."""
+
+    input_reference: FileTypes
+    """Optional image reference that guides generation."""
+
+    model: VideoModel
+    """The video generation model to use. Defaults to `sora-2`."""
+
+    seconds: VideoSeconds
+    """Clip duration in seconds. Defaults to 4 seconds."""
+
+    size: VideoSize
+    """Output resolution formatted as width x height. Defaults to 720x1280."""
diff --git a/src/openai/types/video_delete_response.py b/src/openai/types/video_delete_response.py
new file mode 100644
index 0000000000..e2673ffe2b
--- /dev/null
+++ b/src/openai/types/video_delete_response.py
@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["VideoDeleteResponse"]
+
+
+class VideoDeleteResponse(BaseModel):
+    id: str
+    """Identifier of the deleted video."""
+
+    deleted: bool
+    """Indicates that the video resource was deleted."""
+
+    object: Literal["video.deleted"]
+    """The object type that signals the deletion response."""
diff --git a/src/openai/types/video_download_content_params.py b/src/openai/types/video_download_content_params.py
new file mode 100644
index 0000000000..8c113d6715
--- /dev/null
+++ b/src/openai/types/video_download_content_params.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["VideoDownloadContentParams"]
+
+
+class VideoDownloadContentParams(TypedDict, total=False):
+    variant: Literal["video", "thumbnail", "spritesheet"]
+    """Which downloadable asset to return. Defaults to the MP4 video."""
diff --git a/src/openai/types/video_list_params.py b/src/openai/types/video_list_params.py
new file mode 100644
index 0000000000..bf55ba7fa2
--- /dev/null
+++ b/src/openai/types/video_list_params.py
@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["VideoListParams"]
+
+
+class VideoListParams(TypedDict, total=False):
+    after: str
+    """Identifier for the last item from the previous pagination request"""
+
+    limit: int
+    """Number of items to retrieve"""
+
+    order: Literal["asc", "desc"]
+    """Sort order of results by timestamp.
+
+    Use `asc` for ascending order or `desc` for descending order.
+    """
diff --git a/src/openai/types/video_model.py b/src/openai/types/video_model.py
new file mode 100644
index 0000000000..0b0835fca4
--- /dev/null
+++ b/src/openai/types/video_model.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["VideoModel"]
+
+VideoModel: TypeAlias = Literal["sora-2", "sora-2-pro"]
diff --git a/src/openai/types/video_remix_params.py b/src/openai/types/video_remix_params.py
new file mode 100644
index 0000000000..15388d6172
--- /dev/null
+++ b/src/openai/types/video_remix_params.py
@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["VideoRemixParams"]
+
+
+class VideoRemixParams(TypedDict, total=False):
+    prompt: Required[str]
+    """Updated text prompt that directs the remix generation."""
diff --git a/src/openai/types/video_seconds.py b/src/openai/types/video_seconds.py
new file mode 100644
index 0000000000..e50d37dc51
--- /dev/null
+++ b/src/openai/types/video_seconds.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["VideoSeconds"]
+
+VideoSeconds: TypeAlias = Literal["4", "8", "12"]
diff --git a/src/openai/types/video_size.py b/src/openai/types/video_size.py
new file mode 100644
index 0000000000..215ac8815a
--- /dev/null
+++ b/src/openai/types/video_size.py
@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["VideoSize"]
+
+VideoSize: TypeAlias = Literal["720x1280", "1280x720", "1024x1792", "1792x1024"]
diff --git a/src/openai/types/webhooks/__init__.py b/src/openai/types/webhooks/__init__.py
new file mode 100644
index 0000000000..8b9e55653b
--- /dev/null
+++ b/src/openai/types/webhooks/__init__.py
@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .unwrap_webhook_event import UnwrapWebhookEvent as UnwrapWebhookEvent
+from .batch_failed_webhook_event import BatchFailedWebhookEvent as BatchFailedWebhookEvent
+from .batch_expired_webhook_event import BatchExpiredWebhookEvent as BatchExpiredWebhookEvent
+from .batch_cancelled_webhook_event import BatchCancelledWebhookEvent as BatchCancelledWebhookEvent
+from .batch_completed_webhook_event import BatchCompletedWebhookEvent as BatchCompletedWebhookEvent
+from .eval_run_failed_webhook_event import EvalRunFailedWebhookEvent as EvalRunFailedWebhookEvent
+from .response_failed_webhook_event import ResponseFailedWebhookEvent as ResponseFailedWebhookEvent
+from .eval_run_canceled_webhook_event import EvalRunCanceledWebhookEvent as EvalRunCanceledWebhookEvent
+from .eval_run_succeeded_webhook_event import EvalRunSucceededWebhookEvent as EvalRunSucceededWebhookEvent
+from .response_cancelled_webhook_event import ResponseCancelledWebhookEvent as ResponseCancelledWebhookEvent
+from .response_completed_webhook_event import ResponseCompletedWebhookEvent as ResponseCompletedWebhookEvent
+from .response_incomplete_webhook_event import ResponseIncompleteWebhookEvent as ResponseIncompleteWebhookEvent
+from .fine_tuning_job_failed_webhook_event import FineTuningJobFailedWebhookEvent as FineTuningJobFailedWebhookEvent
+from .realtime_call_incoming_webhook_event import RealtimeCallIncomingWebhookEvent as RealtimeCallIncomingWebhookEvent
+from .fine_tuning_job_cancelled_webhook_event import (
+    FineTuningJobCancelledWebhookEvent as FineTuningJobCancelledWebhookEvent,
+)
+from .fine_tuning_job_succeeded_webhook_event import (
+    FineTuningJobSucceededWebhookEvent as FineTuningJobSucceededWebhookEvent,
+)
diff --git a/src/openai/types/webhooks/batch_cancelled_webhook_event.py b/src/openai/types/webhooks/batch_cancelled_webhook_event.py
new file mode 100644
index 0000000000..4bbd7307a5
--- /dev/null
+++ b/src/openai/types/webhooks/batch_cancelled_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BatchCancelledWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the batch API request."""
+
+
+class BatchCancelledWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the batch API request was cancelled."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["batch.cancelled"]
+    """The type of the event. Always `batch.cancelled`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/batch_completed_webhook_event.py b/src/openai/types/webhooks/batch_completed_webhook_event.py
new file mode 100644
index 0000000000..a47ca156fa
--- /dev/null
+++ b/src/openai/types/webhooks/batch_completed_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BatchCompletedWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the batch API request."""
+
+
+class BatchCompletedWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the batch API request was completed."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["batch.completed"]
+    """The type of the event. Always `batch.completed`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/batch_expired_webhook_event.py b/src/openai/types/webhooks/batch_expired_webhook_event.py
new file mode 100644
index 0000000000..e91001e8d8
--- /dev/null
+++ b/src/openai/types/webhooks/batch_expired_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BatchExpiredWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the batch API request."""
+
+
+class BatchExpiredWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the batch API request expired."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["batch.expired"]
+    """The type of the event. Always `batch.expired`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/batch_failed_webhook_event.py b/src/openai/types/webhooks/batch_failed_webhook_event.py
new file mode 100644
index 0000000000..ef80863edb
--- /dev/null
+++ b/src/openai/types/webhooks/batch_failed_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BatchFailedWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the batch API request."""
+
+
+class BatchFailedWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the batch API request failed."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["batch.failed"]
+    """The type of the event. Always `batch.failed`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/eval_run_canceled_webhook_event.py b/src/openai/types/webhooks/eval_run_canceled_webhook_event.py
new file mode 100644
index 0000000000..855359f743
--- /dev/null
+++ b/src/openai/types/webhooks/eval_run_canceled_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["EvalRunCanceledWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the eval run."""
+
+
+class EvalRunCanceledWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the eval run was canceled."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["eval.run.canceled"]
+    """The type of the event. Always `eval.run.canceled`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/eval_run_failed_webhook_event.py b/src/openai/types/webhooks/eval_run_failed_webhook_event.py
new file mode 100644
index 0000000000..7671680720
--- /dev/null
+++ b/src/openai/types/webhooks/eval_run_failed_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["EvalRunFailedWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the eval run."""
+
+
+class EvalRunFailedWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the eval run failed."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["eval.run.failed"]
+    """The type of the event. Always `eval.run.failed`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/eval_run_succeeded_webhook_event.py b/src/openai/types/webhooks/eval_run_succeeded_webhook_event.py
new file mode 100644
index 0000000000..d0d1fc2b04
--- /dev/null
+++ b/src/openai/types/webhooks/eval_run_succeeded_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["EvalRunSucceededWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the eval run."""
+
+
+class EvalRunSucceededWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the eval run succeeded."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["eval.run.succeeded"]
+    """The type of the event. Always `eval.run.succeeded`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/fine_tuning_job_cancelled_webhook_event.py b/src/openai/types/webhooks/fine_tuning_job_cancelled_webhook_event.py
new file mode 100644
index 0000000000..1fe3c06096
--- /dev/null
+++ b/src/openai/types/webhooks/fine_tuning_job_cancelled_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["FineTuningJobCancelledWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the fine-tuning job."""
+
+
+class FineTuningJobCancelledWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the fine-tuning job was cancelled."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["fine_tuning.job.cancelled"]
+    """The type of the event. Always `fine_tuning.job.cancelled`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/fine_tuning_job_failed_webhook_event.py b/src/openai/types/webhooks/fine_tuning_job_failed_webhook_event.py
new file mode 100644
index 0000000000..71d899c8ef
--- /dev/null
+++ b/src/openai/types/webhooks/fine_tuning_job_failed_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["FineTuningJobFailedWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the fine-tuning job."""
+
+
+class FineTuningJobFailedWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the fine-tuning job failed."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["fine_tuning.job.failed"]
+    """The type of the event. Always `fine_tuning.job.failed`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/fine_tuning_job_succeeded_webhook_event.py b/src/openai/types/webhooks/fine_tuning_job_succeeded_webhook_event.py
new file mode 100644
index 0000000000..470f1fcfaa
--- /dev/null
+++ b/src/openai/types/webhooks/fine_tuning_job_succeeded_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["FineTuningJobSucceededWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the fine-tuning job."""
+
+
+class FineTuningJobSucceededWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the fine-tuning job succeeded."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["fine_tuning.job.succeeded"]
+    """The type of the event. Always `fine_tuning.job.succeeded`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/realtime_call_incoming_webhook_event.py b/src/openai/types/webhooks/realtime_call_incoming_webhook_event.py
new file mode 100644
index 0000000000..a166a3471b
--- /dev/null
+++ b/src/openai/types/webhooks/realtime_call_incoming_webhook_event.py
@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["RealtimeCallIncomingWebhookEvent", "Data", "DataSipHeader"]
+
+
+class DataSipHeader(BaseModel):
+    name: str
+    """Name of the SIP Header."""
+
+    value: str
+    """Value of the SIP Header."""
+
+
+class Data(BaseModel):
+    call_id: str
+    """The unique ID of this call."""
+
+    sip_headers: List[DataSipHeader]
+    """Headers from the SIP Invite."""
+
+
+class RealtimeCallIncomingWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the model response was completed."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["realtime.call.incoming"]
+    """The type of the event. Always `realtime.call.incoming`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/response_cancelled_webhook_event.py b/src/openai/types/webhooks/response_cancelled_webhook_event.py
new file mode 100644
index 0000000000..443e360e90
--- /dev/null
+++ b/src/openai/types/webhooks/response_cancelled_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseCancelledWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the model response."""
+
+
+class ResponseCancelledWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the model response was cancelled."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["response.cancelled"]
+    """The type of the event. Always `response.cancelled`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/response_completed_webhook_event.py b/src/openai/types/webhooks/response_completed_webhook_event.py
new file mode 100644
index 0000000000..ac1feff32b
--- /dev/null
+++ b/src/openai/types/webhooks/response_completed_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseCompletedWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the model response."""
+
+
+class ResponseCompletedWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the model response was completed."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["response.completed"]
+    """The type of the event. Always `response.completed`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/response_failed_webhook_event.py b/src/openai/types/webhooks/response_failed_webhook_event.py
new file mode 100644
index 0000000000..5b4ba65e18
--- /dev/null
+++ b/src/openai/types/webhooks/response_failed_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseFailedWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the model response."""
+
+
+class ResponseFailedWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the model response failed."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["response.failed"]
+    """The type of the event. Always `response.failed`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/response_incomplete_webhook_event.py b/src/openai/types/webhooks/response_incomplete_webhook_event.py
new file mode 100644
index 0000000000..01609314e0
--- /dev/null
+++ b/src/openai/types/webhooks/response_incomplete_webhook_event.py
@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ResponseIncompleteWebhookEvent", "Data"]
+
+
+class Data(BaseModel):
+    id: str
+    """The unique ID of the model response."""
+
+
+class ResponseIncompleteWebhookEvent(BaseModel):
+    id: str
+    """The unique ID of the event."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) of when the model response was interrupted."""
+
+    data: Data
+    """Event data payload."""
+
+    type: Literal["response.incomplete"]
+    """The type of the event. Always `response.incomplete`."""
+
+    object: Optional[Literal["event"]] = None
+    """The object of the event. Always `event`."""
diff --git a/src/openai/types/webhooks/unwrap_webhook_event.py b/src/openai/types/webhooks/unwrap_webhook_event.py
new file mode 100644
index 0000000000..952383c049
--- /dev/null
+++ b/src/openai/types/webhooks/unwrap_webhook_event.py
@@ -0,0 +1,44 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .batch_failed_webhook_event import BatchFailedWebhookEvent
+from .batch_expired_webhook_event import BatchExpiredWebhookEvent
+from .batch_cancelled_webhook_event import BatchCancelledWebhookEvent
+from .batch_completed_webhook_event import BatchCompletedWebhookEvent
+from .eval_run_failed_webhook_event import EvalRunFailedWebhookEvent
+from .response_failed_webhook_event import ResponseFailedWebhookEvent
+from .eval_run_canceled_webhook_event import EvalRunCanceledWebhookEvent
+from .eval_run_succeeded_webhook_event import EvalRunSucceededWebhookEvent
+from .response_cancelled_webhook_event import ResponseCancelledWebhookEvent
+from .response_completed_webhook_event import ResponseCompletedWebhookEvent
+from .response_incomplete_webhook_event import ResponseIncompleteWebhookEvent
+from .fine_tuning_job_failed_webhook_event import FineTuningJobFailedWebhookEvent
+from .realtime_call_incoming_webhook_event import RealtimeCallIncomingWebhookEvent
+from .fine_tuning_job_cancelled_webhook_event import FineTuningJobCancelledWebhookEvent
+from .fine_tuning_job_succeeded_webhook_event import FineTuningJobSucceededWebhookEvent
+
+__all__ = ["UnwrapWebhookEvent"]
+
+UnwrapWebhookEvent: TypeAlias = Annotated[
+    Union[
+        BatchCancelledWebhookEvent,
+        BatchCompletedWebhookEvent,
+        BatchExpiredWebhookEvent,
+        BatchFailedWebhookEvent,
+        EvalRunCanceledWebhookEvent,
+        EvalRunFailedWebhookEvent,
+        EvalRunSucceededWebhookEvent,
+        FineTuningJobCancelledWebhookEvent,
+        FineTuningJobFailedWebhookEvent,
+        FineTuningJobSucceededWebhookEvent,
+        RealtimeCallIncomingWebhookEvent,
+        ResponseCancelledWebhookEvent,
+        ResponseCompletedWebhookEvent,
+        ResponseFailedWebhookEvent,
+        ResponseIncompleteWebhookEvent,
+    ],
+    PropertyInfo(discriminator="type"),
+]
diff --git a/tests/api_resources/audio/test_speech.py b/tests/api_resources/audio/test_speech.py
index 781ebeceb9..2c77f38949 100644
--- a/tests/api_resources/audio/test_speech.py
+++ b/tests/api_resources/audio/test_speech.py
@@ -28,7 +28,7 @@ def test_method_create(self, client: OpenAI, respx_mock: MockRouter) -> None:
         speech = client.audio.speech.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
         )
         assert isinstance(speech, _legacy_response.HttpxBinaryResponseContent)
         assert speech.json() == {"foo": "bar"}
@@ -40,9 +40,11 @@ def test_method_create_with_all_params(self, client: OpenAI, respx_mock: MockRou
         speech = client.audio.speech.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
+            instructions="instructions",
             response_format="mp3",
             speed=0.25,
+            stream_format="sse",
         )
         assert isinstance(speech, _legacy_response.HttpxBinaryResponseContent)
         assert speech.json() == {"foo": "bar"}
@@ -55,7 +57,7 @@ def test_raw_response_create(self, client: OpenAI, respx_mock: MockRouter) -> No
         response = client.audio.speech.with_raw_response.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
         )
 
         assert response.is_closed is True
@@ -70,7 +72,7 @@ def test_streaming_response_create(self, client: OpenAI, respx_mock: MockRouter)
         with client.audio.speech.with_streaming_response.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -82,7 +84,9 @@ def test_streaming_response_create(self, client: OpenAI, respx_mock: MockRouter)
 
 
 class TestAsyncSpeech:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     @pytest.mark.respx(base_url=base_url)
@@ -91,7 +95,7 @@ async def test_method_create(self, async_client: AsyncOpenAI, respx_mock: MockRo
         speech = await async_client.audio.speech.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
         )
         assert isinstance(speech, _legacy_response.HttpxBinaryResponseContent)
         assert speech.json() == {"foo": "bar"}
@@ -103,9 +107,11 @@ async def test_method_create_with_all_params(self, async_client: AsyncOpenAI, re
         speech = await async_client.audio.speech.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
+            instructions="instructions",
             response_format="mp3",
             speed=0.25,
+            stream_format="sse",
         )
         assert isinstance(speech, _legacy_response.HttpxBinaryResponseContent)
         assert speech.json() == {"foo": "bar"}
@@ -118,7 +124,7 @@ async def test_raw_response_create(self, async_client: AsyncOpenAI, respx_mock:
         response = await async_client.audio.speech.with_raw_response.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
         )
 
         assert response.is_closed is True
@@ -133,7 +139,7 @@ async def test_streaming_response_create(self, async_client: AsyncOpenAI, respx_
         async with async_client.audio.speech.with_streaming_response.create(
             input="string",
             model="string",
-            voice="alloy",
+            voice="ash",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
diff --git a/tests/api_resources/audio/test_transcriptions.py b/tests/api_resources/audio/test_transcriptions.py
index bdb7e0dfb6..b5eaa4be1f 100644
--- a/tests/api_resources/audio/test_transcriptions.py
+++ b/tests/api_resources/audio/test_transcriptions.py
@@ -18,31 +18,36 @@ class TestTranscriptions:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
     @parametrize
-    def test_method_create(self, client: OpenAI) -> None:
+    def test_method_create_overload_1(self, client: OpenAI) -> None:
         transcription = client.audio.transcriptions.create(
             file=b"raw file contents",
-            model="whisper-1",
+            model="gpt-4o-transcribe",
         )
         assert_matches_type(TranscriptionCreateResponse, transcription, path=["response"])
 
     @parametrize
-    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+    def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
         transcription = client.audio.transcriptions.create(
             file=b"raw file contents",
-            model="whisper-1",
-            language="string",
-            prompt="string",
+            model="gpt-4o-transcribe",
+            chunking_strategy="auto",
+            include=["logprobs"],
+            known_speaker_names=["string"],
+            known_speaker_references=["string"],
+            language="language",
+            prompt="prompt",
             response_format="json",
+            stream=False,
             temperature=0,
             timestamp_granularities=["word"],
         )
         assert_matches_type(TranscriptionCreateResponse, transcription, path=["response"])
 
     @parametrize
-    def test_raw_response_create(self, client: OpenAI) -> None:
+    def test_raw_response_create_overload_1(self, client: OpenAI) -> None:
         response = client.audio.transcriptions.with_raw_response.create(
             file=b"raw file contents",
-            model="whisper-1",
+            model="gpt-4o-transcribe",
         )
 
         assert response.is_closed is True
@@ -51,10 +56,10 @@ def test_raw_response_create(self, client: OpenAI) -> None:
         assert_matches_type(TranscriptionCreateResponse, transcription, path=["response"])
 
     @parametrize
-    def test_streaming_response_create(self, client: OpenAI) -> None:
+    def test_streaming_response_create_overload_1(self, client: OpenAI) -> None:
         with client.audio.transcriptions.with_streaming_response.create(
             file=b"raw file contents",
-            model="whisper-1",
+            model="gpt-4o-transcribe",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -64,36 +69,97 @@ def test_streaming_response_create(self, client: OpenAI) -> None:
 
         assert cast(Any, response.is_closed) is True
 
+    @parametrize
+    def test_method_create_overload_2(self, client: OpenAI) -> None:
+        transcription_stream = client.audio.transcriptions.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+        )
+        transcription_stream.response.close()
+
+    @parametrize
+    def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
+        transcription_stream = client.audio.transcriptions.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+            chunking_strategy="auto",
+            include=["logprobs"],
+            known_speaker_names=["string"],
+            known_speaker_references=["string"],
+            language="language",
+            prompt="prompt",
+            response_format="json",
+            temperature=0,
+            timestamp_granularities=["word"],
+        )
+        transcription_stream.response.close()
+
+    @parametrize
+    def test_raw_response_create_overload_2(self, client: OpenAI) -> None:
+        response = client.audio.transcriptions.with_raw_response.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @parametrize
+    def test_streaming_response_create_overload_2(self, client: OpenAI) -> None:
+        with client.audio.transcriptions.with_streaming_response.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
 
 class TestAsyncTranscriptions:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
-    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_create_overload_1(self, async_client: AsyncOpenAI) -> None:
         transcription = await async_client.audio.transcriptions.create(
             file=b"raw file contents",
-            model="whisper-1",
+            model="gpt-4o-transcribe",
         )
         assert_matches_type(TranscriptionCreateResponse, transcription, path=["response"])
 
     @parametrize
-    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_create_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
         transcription = await async_client.audio.transcriptions.create(
             file=b"raw file contents",
-            model="whisper-1",
-            language="string",
-            prompt="string",
+            model="gpt-4o-transcribe",
+            chunking_strategy="auto",
+            include=["logprobs"],
+            known_speaker_names=["string"],
+            known_speaker_references=["string"],
+            language="language",
+            prompt="prompt",
             response_format="json",
+            stream=False,
             temperature=0,
             timestamp_granularities=["word"],
         )
         assert_matches_type(TranscriptionCreateResponse, transcription, path=["response"])
 
     @parametrize
-    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+    async def test_raw_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.audio.transcriptions.with_raw_response.create(
             file=b"raw file contents",
-            model="whisper-1",
+            model="gpt-4o-transcribe",
         )
 
         assert response.is_closed is True
@@ -102,10 +168,10 @@ async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(TranscriptionCreateResponse, transcription, path=["response"])
 
     @parametrize
-    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+    async def test_streaming_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
         async with async_client.audio.transcriptions.with_streaming_response.create(
             file=b"raw file contents",
-            model="whisper-1",
+            model="gpt-4o-transcribe",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -114,3 +180,57 @@ async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> Non
             assert_matches_type(TranscriptionCreateResponse, transcription, path=["response"])
 
         assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_create_overload_2(self, async_client: AsyncOpenAI) -> None:
+        transcription_stream = await async_client.audio.transcriptions.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+        )
+        await transcription_stream.response.aclose()
+
+    @parametrize
+    async def test_method_create_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
+        transcription_stream = await async_client.audio.transcriptions.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+            chunking_strategy="auto",
+            include=["logprobs"],
+            known_speaker_names=["string"],
+            known_speaker_references=["string"],
+            language="language",
+            prompt="prompt",
+            response_format="json",
+            temperature=0,
+            timestamp_granularities=["word"],
+        )
+        await transcription_stream.response.aclose()
+
+    @parametrize
+    async def test_raw_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.audio.transcriptions.with_raw_response.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        await stream.close()
+
+    @parametrize
+    async def test_streaming_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.audio.transcriptions.with_streaming_response.create(
+            file=b"raw file contents",
+            model="gpt-4o-transcribe",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/audio/test_translations.py b/tests/api_resources/audio/test_translations.py
index e12ab7e6c0..ead69e9369 100644
--- a/tests/api_resources/audio/test_translations.py
+++ b/tests/api_resources/audio/test_translations.py
@@ -64,7 +64,9 @@ def test_streaming_response_create(self, client: OpenAI) -> None:
 
 
 class TestAsyncTranslations:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
diff --git a/tests/api_resources/beta/realtime/__init__.py b/tests/api_resources/beta/chatkit/__init__.py
similarity index 100%
rename from tests/api_resources/beta/realtime/__init__.py
rename to tests/api_resources/beta/chatkit/__init__.py
diff --git a/tests/api_resources/beta/chatkit/test_sessions.py b/tests/api_resources/beta/chatkit/test_sessions.py
new file mode 100644
index 0000000000..c94e4c92ae
--- /dev/null
+++ b/tests/api_resources/beta/chatkit/test_sessions.py
@@ -0,0 +1,230 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types.beta.chatkit import (
+    ChatSession,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestSessions:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        session = client.beta.chatkit.sessions.create(
+            user="x",
+            workflow={"id": "id"},
+        )
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        session = client.beta.chatkit.sessions.create(
+            user="x",
+            workflow={
+                "id": "id",
+                "state_variables": {"foo": "string"},
+                "tracing": {"enabled": True},
+                "version": "version",
+            },
+            chatkit_configuration={
+                "automatic_thread_titling": {"enabled": True},
+                "file_upload": {
+                    "enabled": True,
+                    "max_file_size": 1,
+                    "max_files": 1,
+                },
+                "history": {
+                    "enabled": True,
+                    "recent_threads": 1,
+                },
+            },
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 1,
+            },
+            rate_limits={"max_requests_per_1_minute": 1},
+        )
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.beta.chatkit.sessions.with_raw_response.create(
+            user="x",
+            workflow={"id": "id"},
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = response.parse()
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.beta.chatkit.sessions.with_streaming_response.create(
+            user="x",
+            workflow={"id": "id"},
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = response.parse()
+            assert_matches_type(ChatSession, session, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_cancel(self, client: OpenAI) -> None:
+        session = client.beta.chatkit.sessions.cancel(
+            "cksess_123",
+        )
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    def test_raw_response_cancel(self, client: OpenAI) -> None:
+        response = client.beta.chatkit.sessions.with_raw_response.cancel(
+            "cksess_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = response.parse()
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    def test_streaming_response_cancel(self, client: OpenAI) -> None:
+        with client.beta.chatkit.sessions.with_streaming_response.cancel(
+            "cksess_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = response.parse()
+            assert_matches_type(ChatSession, session, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_cancel(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `session_id` but received ''"):
+            client.beta.chatkit.sessions.with_raw_response.cancel(
+                "",
+            )
+
+
+class TestAsyncSessions:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        session = await async_client.beta.chatkit.sessions.create(
+            user="x",
+            workflow={"id": "id"},
+        )
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        session = await async_client.beta.chatkit.sessions.create(
+            user="x",
+            workflow={
+                "id": "id",
+                "state_variables": {"foo": "string"},
+                "tracing": {"enabled": True},
+                "version": "version",
+            },
+            chatkit_configuration={
+                "automatic_thread_titling": {"enabled": True},
+                "file_upload": {
+                    "enabled": True,
+                    "max_file_size": 1,
+                    "max_files": 1,
+                },
+                "history": {
+                    "enabled": True,
+                    "recent_threads": 1,
+                },
+            },
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 1,
+            },
+            rate_limits={"max_requests_per_1_minute": 1},
+        )
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.beta.chatkit.sessions.with_raw_response.create(
+            user="x",
+            workflow={"id": "id"},
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = response.parse()
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.beta.chatkit.sessions.with_streaming_response.create(
+            user="x",
+            workflow={"id": "id"},
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = await response.parse()
+            assert_matches_type(ChatSession, session, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_cancel(self, async_client: AsyncOpenAI) -> None:
+        session = await async_client.beta.chatkit.sessions.cancel(
+            "cksess_123",
+        )
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    async def test_raw_response_cancel(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.beta.chatkit.sessions.with_raw_response.cancel(
+            "cksess_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        session = response.parse()
+        assert_matches_type(ChatSession, session, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_cancel(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.beta.chatkit.sessions.with_streaming_response.cancel(
+            "cksess_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            session = await response.parse()
+            assert_matches_type(ChatSession, session, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_cancel(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `session_id` but received ''"):
+            await async_client.beta.chatkit.sessions.with_raw_response.cancel(
+                "",
+            )
diff --git a/tests/api_resources/beta/chatkit/test_threads.py b/tests/api_resources/beta/chatkit/test_threads.py
new file mode 100644
index 0000000000..6395b72b2f
--- /dev/null
+++ b/tests/api_resources/beta/chatkit/test_threads.py
@@ -0,0 +1,348 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.pagination import SyncConversationCursorPage, AsyncConversationCursorPage
+from openai.types.beta.chatkit import ChatKitThread, ThreadDeleteResponse
+from openai.types.beta.chatkit.chatkit_thread_item_list import Data
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestThreads:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        thread = client.beta.chatkit.threads.retrieve(
+            "cthr_123",
+        )
+        assert_matches_type(ChatKitThread, thread, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.beta.chatkit.threads.with_raw_response.retrieve(
+            "cthr_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(ChatKitThread, thread, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.beta.chatkit.threads.with_streaming_response.retrieve(
+            "cthr_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = response.parse()
+            assert_matches_type(ChatKitThread, thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+            client.beta.chatkit.threads.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        thread = client.beta.chatkit.threads.list()
+        assert_matches_type(SyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        thread = client.beta.chatkit.threads.list(
+            after="after",
+            before="before",
+            limit=0,
+            order="asc",
+            user="x",
+        )
+        assert_matches_type(SyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.beta.chatkit.threads.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(SyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.beta.chatkit.threads.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = response.parse()
+            assert_matches_type(SyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        thread = client.beta.chatkit.threads.delete(
+            "cthr_123",
+        )
+        assert_matches_type(ThreadDeleteResponse, thread, path=["response"])
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.beta.chatkit.threads.with_raw_response.delete(
+            "cthr_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(ThreadDeleteResponse, thread, path=["response"])
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.beta.chatkit.threads.with_streaming_response.delete(
+            "cthr_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = response.parse()
+            assert_matches_type(ThreadDeleteResponse, thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+            client.beta.chatkit.threads.with_raw_response.delete(
+                "",
+            )
+
+    @parametrize
+    def test_method_list_items(self, client: OpenAI) -> None:
+        thread = client.beta.chatkit.threads.list_items(
+            thread_id="cthr_123",
+        )
+        assert_matches_type(SyncConversationCursorPage[Data], thread, path=["response"])
+
+    @parametrize
+    def test_method_list_items_with_all_params(self, client: OpenAI) -> None:
+        thread = client.beta.chatkit.threads.list_items(
+            thread_id="cthr_123",
+            after="after",
+            before="before",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(SyncConversationCursorPage[Data], thread, path=["response"])
+
+    @parametrize
+    def test_raw_response_list_items(self, client: OpenAI) -> None:
+        response = client.beta.chatkit.threads.with_raw_response.list_items(
+            thread_id="cthr_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(SyncConversationCursorPage[Data], thread, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list_items(self, client: OpenAI) -> None:
+        with client.beta.chatkit.threads.with_streaming_response.list_items(
+            thread_id="cthr_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = response.parse()
+            assert_matches_type(SyncConversationCursorPage[Data], thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_list_items(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+            client.beta.chatkit.threads.with_raw_response.list_items(
+                thread_id="",
+            )
+
+
+class TestAsyncThreads:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        thread = await async_client.beta.chatkit.threads.retrieve(
+            "cthr_123",
+        )
+        assert_matches_type(ChatKitThread, thread, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.beta.chatkit.threads.with_raw_response.retrieve(
+            "cthr_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(ChatKitThread, thread, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.beta.chatkit.threads.with_streaming_response.retrieve(
+            "cthr_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = await response.parse()
+            assert_matches_type(ChatKitThread, thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+            await async_client.beta.chatkit.threads.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        thread = await async_client.beta.chatkit.threads.list()
+        assert_matches_type(AsyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        thread = await async_client.beta.chatkit.threads.list(
+            after="after",
+            before="before",
+            limit=0,
+            order="asc",
+            user="x",
+        )
+        assert_matches_type(AsyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.beta.chatkit.threads.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(AsyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.beta.chatkit.threads.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = await response.parse()
+            assert_matches_type(AsyncConversationCursorPage[ChatKitThread], thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        thread = await async_client.beta.chatkit.threads.delete(
+            "cthr_123",
+        )
+        assert_matches_type(ThreadDeleteResponse, thread, path=["response"])
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.beta.chatkit.threads.with_raw_response.delete(
+            "cthr_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(ThreadDeleteResponse, thread, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.beta.chatkit.threads.with_streaming_response.delete(
+            "cthr_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = await response.parse()
+            assert_matches_type(ThreadDeleteResponse, thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+            await async_client.beta.chatkit.threads.with_raw_response.delete(
+                "",
+            )
+
+    @parametrize
+    async def test_method_list_items(self, async_client: AsyncOpenAI) -> None:
+        thread = await async_client.beta.chatkit.threads.list_items(
+            thread_id="cthr_123",
+        )
+        assert_matches_type(AsyncConversationCursorPage[Data], thread, path=["response"])
+
+    @parametrize
+    async def test_method_list_items_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        thread = await async_client.beta.chatkit.threads.list_items(
+            thread_id="cthr_123",
+            after="after",
+            before="before",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(AsyncConversationCursorPage[Data], thread, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list_items(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.beta.chatkit.threads.with_raw_response.list_items(
+            thread_id="cthr_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        thread = response.parse()
+        assert_matches_type(AsyncConversationCursorPage[Data], thread, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list_items(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.beta.chatkit.threads.with_streaming_response.list_items(
+            thread_id="cthr_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            thread = await response.parse()
+            assert_matches_type(AsyncConversationCursorPage[Data], thread, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_list_items(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+            await async_client.beta.chatkit.threads.with_raw_response.list_items(
+                thread_id="",
+            )
diff --git a/tests/api_resources/beta/realtime/test_sessions.py b/tests/api_resources/beta/realtime/test_sessions.py
deleted file mode 100644
index 5ea308ca0d..0000000000
--- a/tests/api_resources/beta/realtime/test_sessions.py
+++ /dev/null
@@ -1,144 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import os
-from typing import Any, cast
-
-import pytest
-
-from openai import OpenAI, AsyncOpenAI
-from tests.utils import assert_matches_type
-from openai.types.beta.realtime import SessionCreateResponse
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestSessions:
-    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    def test_method_create(self, client: OpenAI) -> None:
-        session = client.beta.realtime.sessions.create()
-        assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-    @parametrize
-    def test_method_create_with_all_params(self, client: OpenAI) -> None:
-        session = client.beta.realtime.sessions.create(
-            input_audio_format="pcm16",
-            input_audio_transcription={
-                "language": "language",
-                "model": "model",
-                "prompt": "prompt",
-            },
-            instructions="instructions",
-            max_response_output_tokens=0,
-            modalities=["text"],
-            model="gpt-4o-realtime-preview",
-            output_audio_format="pcm16",
-            temperature=0,
-            tool_choice="tool_choice",
-            tools=[
-                {
-                    "description": "description",
-                    "name": "name",
-                    "parameters": {},
-                    "type": "function",
-                }
-            ],
-            turn_detection={
-                "create_response": True,
-                "interrupt_response": True,
-                "prefix_padding_ms": 0,
-                "silence_duration_ms": 0,
-                "threshold": 0,
-                "type": "type",
-            },
-            voice="alloy",
-        )
-        assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-    @parametrize
-    def test_raw_response_create(self, client: OpenAI) -> None:
-        response = client.beta.realtime.sessions.with_raw_response.create()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        session = response.parse()
-        assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-    @parametrize
-    def test_streaming_response_create(self, client: OpenAI) -> None:
-        with client.beta.realtime.sessions.with_streaming_response.create() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            session = response.parse()
-            assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
-
-
-class TestAsyncSessions:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    @parametrize
-    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
-        session = await async_client.beta.realtime.sessions.create()
-        assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-    @parametrize
-    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        session = await async_client.beta.realtime.sessions.create(
-            input_audio_format="pcm16",
-            input_audio_transcription={
-                "language": "language",
-                "model": "model",
-                "prompt": "prompt",
-            },
-            instructions="instructions",
-            max_response_output_tokens=0,
-            modalities=["text"],
-            model="gpt-4o-realtime-preview",
-            output_audio_format="pcm16",
-            temperature=0,
-            tool_choice="tool_choice",
-            tools=[
-                {
-                    "description": "description",
-                    "name": "name",
-                    "parameters": {},
-                    "type": "function",
-                }
-            ],
-            turn_detection={
-                "create_response": True,
-                "interrupt_response": True,
-                "prefix_padding_ms": 0,
-                "silence_duration_ms": 0,
-                "threshold": 0,
-                "type": "type",
-            },
-            voice="alloy",
-        )
-        assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-    @parametrize
-    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.realtime.sessions.with_raw_response.create()
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        session = response.parse()
-        assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-    @parametrize
-    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.realtime.sessions.with_streaming_response.create() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            session = await response.parse()
-            assert_matches_type(SessionCreateResponse, session, path=["response"])
-
-        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/beta/test_assistants.py b/tests/api_resources/beta/test_assistants.py
index 82aaf87b1c..2557735426 100644
--- a/tests/api_resources/beta/test_assistants.py
+++ b/tests/api_resources/beta/test_assistants.py
@@ -36,7 +36,7 @@ def test_method_create_with_all_params(self, client: OpenAI) -> None:
             instructions="instructions",
             metadata={"foo": "string"},
             name="name",
-            reasoning_effort="low",
+            reasoning_effort="none",
             response_format="auto",
             temperature=1,
             tool_resources={
@@ -135,7 +135,7 @@ def test_method_update_with_all_params(self, client: OpenAI) -> None:
             metadata={"foo": "string"},
             model="string",
             name="name",
-            reasoning_effort="low",
+            reasoning_effort="none",
             response_format="auto",
             temperature=1,
             tool_resources={
@@ -253,7 +253,9 @@ def test_path_params_delete(self, client: OpenAI) -> None:
 
 
 class TestAsyncAssistants:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
@@ -270,7 +272,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) ->
             instructions="instructions",
             metadata={"foo": "string"},
             name="name",
-            reasoning_effort="low",
+            reasoning_effort="none",
             response_format="auto",
             temperature=1,
             tool_resources={
@@ -369,7 +371,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncOpenAI) ->
             metadata={"foo": "string"},
             model="string",
             name="name",
-            reasoning_effort="low",
+            reasoning_effort="none",
             response_format="auto",
             temperature=1,
             tool_resources={
diff --git a/tests/api_resources/beta/test_realtime.py b/tests/api_resources/beta/test_realtime.py
index 537017ffd3..8f752a0fd3 100644
--- a/tests/api_resources/beta/test_realtime.py
+++ b/tests/api_resources/beta/test_realtime.py
@@ -6,6 +6,8 @@
 
 import pytest
 
+# pyright: reportDeprecated=false
+
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
 
@@ -14,4 +16,6 @@ class TestRealtime:
 
 
 class TestAsyncRealtime:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
diff --git a/tests/api_resources/beta/test_threads.py b/tests/api_resources/beta/test_threads.py
index ecf5b11102..f392c86729 100644
--- a/tests/api_resources/beta/test_threads.py
+++ b/tests/api_resources/beta/test_threads.py
@@ -15,6 +15,8 @@
 )
 from openai.types.beta.threads import Run
 
+# pyright: reportDeprecated=false
+
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
 
@@ -23,45 +25,50 @@ class TestThreads:
 
     @parametrize
     def test_method_create(self, client: OpenAI) -> None:
-        thread = client.beta.threads.create()
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.create()
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     def test_method_create_with_all_params(self, client: OpenAI) -> None:
-        thread = client.beta.threads.create(
-            messages=[
-                {
-                    "content": "string",
-                    "role": "user",
-                    "attachments": [
-                        {
-                            "file_id": "file_id",
-                            "tools": [{"type": "code_interpreter"}],
-                        }
-                    ],
-                    "metadata": {"foo": "string"},
-                }
-            ],
-            metadata={"foo": "string"},
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {
-                    "vector_store_ids": ["string"],
-                    "vector_stores": [
-                        {
-                            "chunking_strategy": {"type": "auto"},
-                            "file_ids": ["string"],
-                            "metadata": {"foo": "string"},
-                        }
-                    ],
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.create(
+                messages=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "attachments": [
+                            {
+                                "file_id": "file_id",
+                                "tools": [{"type": "code_interpreter"}],
+                            }
+                        ],
+                        "metadata": {"foo": "string"},
+                    }
+                ],
+                metadata={"foo": "string"},
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {
+                        "vector_store_ids": ["string"],
+                        "vector_stores": [
+                            {
+                                "chunking_strategy": {"type": "auto"},
+                                "file_ids": ["string"],
+                                "metadata": {"foo": "string"},
+                            }
+                        ],
+                    },
                 },
-            },
-        )
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     def test_raw_response_create(self, client: OpenAI) -> None:
-        response = client.beta.threads.with_raw_response.create()
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.with_raw_response.create()
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -70,27 +77,31 @@ def test_raw_response_create(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_create(self, client: OpenAI) -> None:
-        with client.beta.threads.with_streaming_response.create() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.with_streaming_response.create() as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = response.parse()
-            assert_matches_type(Thread, thread, path=["response"])
+                thread = response.parse()
+                assert_matches_type(Thread, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_method_retrieve(self, client: OpenAI) -> None:
-        thread = client.beta.threads.retrieve(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.retrieve(
+                "thread_id",
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     def test_raw_response_retrieve(self, client: OpenAI) -> None:
-        response = client.beta.threads.with_raw_response.retrieve(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.with_raw_response.retrieve(
+                "thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -99,48 +110,55 @@ def test_raw_response_retrieve(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_retrieve(self, client: OpenAI) -> None:
-        with client.beta.threads.with_streaming_response.retrieve(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.with_streaming_response.retrieve(
+                "thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = response.parse()
-            assert_matches_type(Thread, thread, path=["response"])
+                thread = response.parse()
+                assert_matches_type(Thread, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_retrieve(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.with_raw_response.retrieve(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.with_raw_response.retrieve(
+                    "",
+                )
 
     @parametrize
     def test_method_update(self, client: OpenAI) -> None:
-        thread = client.beta.threads.update(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.update(
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     def test_method_update_with_all_params(self, client: OpenAI) -> None:
-        thread = client.beta.threads.update(
-            thread_id="thread_id",
-            metadata={"foo": "string"},
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {"vector_store_ids": ["string"]},
-            },
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.update(
+                thread_id="thread_id",
+                metadata={"foo": "string"},
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {"vector_store_ids": ["string"]},
+                },
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     def test_raw_response_update(self, client: OpenAI) -> None:
-        response = client.beta.threads.with_raw_response.update(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.with_raw_response.update(
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -149,36 +167,41 @@ def test_raw_response_update(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_update(self, client: OpenAI) -> None:
-        with client.beta.threads.with_streaming_response.update(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.with_streaming_response.update(
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = response.parse()
-            assert_matches_type(Thread, thread, path=["response"])
+                thread = response.parse()
+                assert_matches_type(Thread, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_update(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.with_raw_response.update(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.with_raw_response.update(
+                    thread_id="",
+                )
 
     @parametrize
     def test_method_delete(self, client: OpenAI) -> None:
-        thread = client.beta.threads.delete(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.delete(
+                "thread_id",
+            )
+
         assert_matches_type(ThreadDeleted, thread, path=["response"])
 
     @parametrize
     def test_raw_response_delete(self, client: OpenAI) -> None:
-        response = client.beta.threads.with_raw_response.delete(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.with_raw_response.delete(
+                "thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -187,92 +210,99 @@ def test_raw_response_delete(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_delete(self, client: OpenAI) -> None:
-        with client.beta.threads.with_streaming_response.delete(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.with_streaming_response.delete(
+                "thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = response.parse()
-            assert_matches_type(ThreadDeleted, thread, path=["response"])
+                thread = response.parse()
+                assert_matches_type(ThreadDeleted, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_delete(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.with_raw_response.delete(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.with_raw_response.delete(
+                    "",
+                )
 
     @parametrize
     def test_method_create_and_run_overload_1(self, client: OpenAI) -> None:
-        thread = client.beta.threads.create_and_run(
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+            )
+
         assert_matches_type(Run, thread, path=["response"])
 
     @parametrize
     def test_method_create_and_run_with_all_params_overload_1(self, client: OpenAI) -> None:
-        thread = client.beta.threads.create_and_run(
-            assistant_id="string",
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            response_format="auto",
-            stream=False,
-            temperature=1,
-            thread={
-                "messages": [
-                    {
-                        "content": "string",
-                        "role": "user",
-                        "attachments": [
-                            {
-                                "file_id": "file_id",
-                                "tools": [{"type": "code_interpreter"}],
-                            }
-                        ],
-                        "metadata": {"foo": "string"},
-                    }
-                ],
-                "metadata": {"foo": "string"},
-                "tool_resources": {
-                    "code_interpreter": {"file_ids": ["string"]},
-                    "file_search": {
-                        "vector_store_ids": ["string"],
-                        "vector_stores": [
-                            {
-                                "chunking_strategy": {"type": "auto"},
-                                "file_ids": ["string"],
-                                "metadata": {"foo": "string"},
-                            }
-                        ],
+        with pytest.warns(DeprecationWarning):
+            thread = client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                response_format="auto",
+                stream=False,
+                temperature=1,
+                thread={
+                    "messages": [
+                        {
+                            "content": "string",
+                            "role": "user",
+                            "attachments": [
+                                {
+                                    "file_id": "file_id",
+                                    "tools": [{"type": "code_interpreter"}],
+                                }
+                            ],
+                            "metadata": {"foo": "string"},
+                        }
+                    ],
+                    "metadata": {"foo": "string"},
+                    "tool_resources": {
+                        "code_interpreter": {"file_ids": ["string"]},
+                        "file_search": {
+                            "vector_store_ids": ["string"],
+                            "vector_stores": [
+                                {
+                                    "chunking_strategy": {"type": "auto"},
+                                    "file_ids": ["string"],
+                                    "metadata": {"foo": "string"},
+                                }
+                            ],
+                        },
                     },
                 },
-            },
-            tool_choice="none",
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {"vector_store_ids": ["string"]},
-            },
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+                tool_choice="none",
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {"vector_store_ids": ["string"]},
+                },
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         assert_matches_type(Run, thread, path=["response"])
 
     @parametrize
     def test_raw_response_create_and_run_overload_1(self, client: OpenAI) -> None:
-        response = client.beta.threads.with_raw_response.create_and_run(
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.with_raw_response.create_and_run(
+                assistant_id="assistant_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -281,87 +311,93 @@ def test_raw_response_create_and_run_overload_1(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_create_and_run_overload_1(self, client: OpenAI) -> None:
-        with client.beta.threads.with_streaming_response.create_and_run(
-            assistant_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.with_streaming_response.create_and_run(
+                assistant_id="assistant_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = response.parse()
-            assert_matches_type(Run, thread, path=["response"])
+                thread = response.parse()
+                assert_matches_type(Run, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_method_create_and_run_overload_2(self, client: OpenAI) -> None:
-        thread_stream = client.beta.threads.create_and_run(
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            thread_stream = client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+            )
+
         thread_stream.response.close()
 
     @parametrize
     def test_method_create_and_run_with_all_params_overload_2(self, client: OpenAI) -> None:
-        thread_stream = client.beta.threads.create_and_run(
-            assistant_id="string",
-            stream=True,
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            response_format="auto",
-            temperature=1,
-            thread={
-                "messages": [
-                    {
-                        "content": "string",
-                        "role": "user",
-                        "attachments": [
-                            {
-                                "file_id": "file_id",
-                                "tools": [{"type": "code_interpreter"}],
-                            }
-                        ],
-                        "metadata": {"foo": "string"},
-                    }
-                ],
-                "metadata": {"foo": "string"},
-                "tool_resources": {
-                    "code_interpreter": {"file_ids": ["string"]},
-                    "file_search": {
-                        "vector_store_ids": ["string"],
-                        "vector_stores": [
-                            {
-                                "chunking_strategy": {"type": "auto"},
-                                "file_ids": ["string"],
-                                "metadata": {"foo": "string"},
-                            }
-                        ],
+        with pytest.warns(DeprecationWarning):
+            thread_stream = client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                response_format="auto",
+                temperature=1,
+                thread={
+                    "messages": [
+                        {
+                            "content": "string",
+                            "role": "user",
+                            "attachments": [
+                                {
+                                    "file_id": "file_id",
+                                    "tools": [{"type": "code_interpreter"}],
+                                }
+                            ],
+                            "metadata": {"foo": "string"},
+                        }
+                    ],
+                    "metadata": {"foo": "string"},
+                    "tool_resources": {
+                        "code_interpreter": {"file_ids": ["string"]},
+                        "file_search": {
+                            "vector_store_ids": ["string"],
+                            "vector_stores": [
+                                {
+                                    "chunking_strategy": {"type": "auto"},
+                                    "file_ids": ["string"],
+                                    "metadata": {"foo": "string"},
+                                }
+                            ],
+                        },
                     },
                 },
-            },
-            tool_choice="none",
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {"vector_store_ids": ["string"]},
-            },
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+                tool_choice="none",
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {"vector_store_ids": ["string"]},
+                },
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         thread_stream.response.close()
 
     @parametrize
     def test_raw_response_create_and_run_overload_2(self, client: OpenAI) -> None:
-        response = client.beta.threads.with_raw_response.create_and_run(
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.with_raw_response.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+            )
 
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         stream = response.parse()
@@ -369,63 +405,71 @@ def test_raw_response_create_and_run_overload_2(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_create_and_run_overload_2(self, client: OpenAI) -> None:
-        with client.beta.threads.with_streaming_response.create_and_run(
-            assistant_id="string",
-            stream=True,
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.with_streaming_response.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            stream = response.parse()
-            stream.close()
+                stream = response.parse()
+                stream.close()
 
         assert cast(Any, response.is_closed) is True
 
 
 class TestAsyncThreads:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.create()
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.create()
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.create(
-            messages=[
-                {
-                    "content": "string",
-                    "role": "user",
-                    "attachments": [
-                        {
-                            "file_id": "file_id",
-                            "tools": [{"type": "code_interpreter"}],
-                        }
-                    ],
-                    "metadata": {"foo": "string"},
-                }
-            ],
-            metadata={"foo": "string"},
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {
-                    "vector_store_ids": ["string"],
-                    "vector_stores": [
-                        {
-                            "chunking_strategy": {"type": "auto"},
-                            "file_ids": ["string"],
-                            "metadata": {"foo": "string"},
-                        }
-                    ],
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.create(
+                messages=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "attachments": [
+                            {
+                                "file_id": "file_id",
+                                "tools": [{"type": "code_interpreter"}],
+                            }
+                        ],
+                        "metadata": {"foo": "string"},
+                    }
+                ],
+                metadata={"foo": "string"},
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {
+                        "vector_store_ids": ["string"],
+                        "vector_stores": [
+                            {
+                                "chunking_strategy": {"type": "auto"},
+                                "file_ids": ["string"],
+                                "metadata": {"foo": "string"},
+                            }
+                        ],
+                    },
                 },
-            },
-        )
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.with_raw_response.create()
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.with_raw_response.create()
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -434,27 +478,31 @@ async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.with_streaming_response.create() as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.with_streaming_response.create() as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = await response.parse()
-            assert_matches_type(Thread, thread, path=["response"])
+                thread = await response.parse()
+                assert_matches_type(Thread, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.retrieve(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.retrieve(
+                "thread_id",
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.with_raw_response.retrieve(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.with_raw_response.retrieve(
+                "thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -463,48 +511,55 @@ async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.with_streaming_response.retrieve(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.with_streaming_response.retrieve(
+                "thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = await response.parse()
-            assert_matches_type(Thread, thread, path=["response"])
+                thread = await response.parse()
+                assert_matches_type(Thread, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.with_raw_response.retrieve(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.with_raw_response.retrieve(
+                    "",
+                )
 
     @parametrize
     async def test_method_update(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.update(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.update(
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.update(
-            thread_id="thread_id",
-            metadata={"foo": "string"},
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {"vector_store_ids": ["string"]},
-            },
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.update(
+                thread_id="thread_id",
+                metadata={"foo": "string"},
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {"vector_store_ids": ["string"]},
+                },
+            )
+
         assert_matches_type(Thread, thread, path=["response"])
 
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.with_raw_response.update(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.with_raw_response.update(
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -513,36 +568,41 @@ async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.with_streaming_response.update(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.with_streaming_response.update(
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = await response.parse()
-            assert_matches_type(Thread, thread, path=["response"])
+                thread = await response.parse()
+                assert_matches_type(Thread, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_update(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.with_raw_response.update(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.with_raw_response.update(
+                    thread_id="",
+                )
 
     @parametrize
     async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.delete(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.delete(
+                "thread_id",
+            )
+
         assert_matches_type(ThreadDeleted, thread, path=["response"])
 
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.with_raw_response.delete(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.with_raw_response.delete(
+                "thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -551,92 +611,99 @@ async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.with_streaming_response.delete(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.with_streaming_response.delete(
+                "thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = await response.parse()
-            assert_matches_type(ThreadDeleted, thread, path=["response"])
+                thread = await response.parse()
+                assert_matches_type(ThreadDeleted, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.with_raw_response.delete(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.with_raw_response.delete(
+                    "",
+                )
 
     @parametrize
     async def test_method_create_and_run_overload_1(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.create_and_run(
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+            )
+
         assert_matches_type(Run, thread, path=["response"])
 
     @parametrize
     async def test_method_create_and_run_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
-        thread = await async_client.beta.threads.create_and_run(
-            assistant_id="string",
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            response_format="auto",
-            stream=False,
-            temperature=1,
-            thread={
-                "messages": [
-                    {
-                        "content": "string",
-                        "role": "user",
-                        "attachments": [
-                            {
-                                "file_id": "file_id",
-                                "tools": [{"type": "code_interpreter"}],
-                            }
-                        ],
-                        "metadata": {"foo": "string"},
-                    }
-                ],
-                "metadata": {"foo": "string"},
-                "tool_resources": {
-                    "code_interpreter": {"file_ids": ["string"]},
-                    "file_search": {
-                        "vector_store_ids": ["string"],
-                        "vector_stores": [
-                            {
-                                "chunking_strategy": {"type": "auto"},
-                                "file_ids": ["string"],
-                                "metadata": {"foo": "string"},
-                            }
-                        ],
+        with pytest.warns(DeprecationWarning):
+            thread = await async_client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                response_format="auto",
+                stream=False,
+                temperature=1,
+                thread={
+                    "messages": [
+                        {
+                            "content": "string",
+                            "role": "user",
+                            "attachments": [
+                                {
+                                    "file_id": "file_id",
+                                    "tools": [{"type": "code_interpreter"}],
+                                }
+                            ],
+                            "metadata": {"foo": "string"},
+                        }
+                    ],
+                    "metadata": {"foo": "string"},
+                    "tool_resources": {
+                        "code_interpreter": {"file_ids": ["string"]},
+                        "file_search": {
+                            "vector_store_ids": ["string"],
+                            "vector_stores": [
+                                {
+                                    "chunking_strategy": {"type": "auto"},
+                                    "file_ids": ["string"],
+                                    "metadata": {"foo": "string"},
+                                }
+                            ],
+                        },
                     },
                 },
-            },
-            tool_choice="none",
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {"vector_store_ids": ["string"]},
-            },
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+                tool_choice="none",
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {"vector_store_ids": ["string"]},
+                },
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         assert_matches_type(Run, thread, path=["response"])
 
     @parametrize
     async def test_raw_response_create_and_run_overload_1(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.with_raw_response.create_and_run(
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.with_raw_response.create_and_run(
+                assistant_id="assistant_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -645,87 +712,93 @@ async def test_raw_response_create_and_run_overload_1(self, async_client: AsyncO
 
     @parametrize
     async def test_streaming_response_create_and_run_overload_1(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.with_streaming_response.create_and_run(
-            assistant_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.with_streaming_response.create_and_run(
+                assistant_id="assistant_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            thread = await response.parse()
-            assert_matches_type(Run, thread, path=["response"])
+                thread = await response.parse()
+                assert_matches_type(Run, thread, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_method_create_and_run_overload_2(self, async_client: AsyncOpenAI) -> None:
-        thread_stream = await async_client.beta.threads.create_and_run(
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            thread_stream = await async_client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+            )
+
         await thread_stream.response.aclose()
 
     @parametrize
     async def test_method_create_and_run_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
-        thread_stream = await async_client.beta.threads.create_and_run(
-            assistant_id="string",
-            stream=True,
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            response_format="auto",
-            temperature=1,
-            thread={
-                "messages": [
-                    {
-                        "content": "string",
-                        "role": "user",
-                        "attachments": [
-                            {
-                                "file_id": "file_id",
-                                "tools": [{"type": "code_interpreter"}],
-                            }
-                        ],
-                        "metadata": {"foo": "string"},
-                    }
-                ],
-                "metadata": {"foo": "string"},
-                "tool_resources": {
-                    "code_interpreter": {"file_ids": ["string"]},
-                    "file_search": {
-                        "vector_store_ids": ["string"],
-                        "vector_stores": [
-                            {
-                                "chunking_strategy": {"type": "auto"},
-                                "file_ids": ["string"],
-                                "metadata": {"foo": "string"},
-                            }
-                        ],
+        with pytest.warns(DeprecationWarning):
+            thread_stream = await async_client.beta.threads.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                response_format="auto",
+                temperature=1,
+                thread={
+                    "messages": [
+                        {
+                            "content": "string",
+                            "role": "user",
+                            "attachments": [
+                                {
+                                    "file_id": "file_id",
+                                    "tools": [{"type": "code_interpreter"}],
+                                }
+                            ],
+                            "metadata": {"foo": "string"},
+                        }
+                    ],
+                    "metadata": {"foo": "string"},
+                    "tool_resources": {
+                        "code_interpreter": {"file_ids": ["string"]},
+                        "file_search": {
+                            "vector_store_ids": ["string"],
+                            "vector_stores": [
+                                {
+                                    "chunking_strategy": {"type": "auto"},
+                                    "file_ids": ["string"],
+                                    "metadata": {"foo": "string"},
+                                }
+                            ],
+                        },
                     },
                 },
-            },
-            tool_choice="none",
-            tool_resources={
-                "code_interpreter": {"file_ids": ["string"]},
-                "file_search": {"vector_store_ids": ["string"]},
-            },
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+                tool_choice="none",
+                tool_resources={
+                    "code_interpreter": {"file_ids": ["string"]},
+                    "file_search": {"vector_store_ids": ["string"]},
+                },
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         await thread_stream.response.aclose()
 
     @parametrize
     async def test_raw_response_create_and_run_overload_2(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.with_raw_response.create_and_run(
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.with_raw_response.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+            )
 
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         stream = response.parse()
@@ -733,14 +806,15 @@ async def test_raw_response_create_and_run_overload_2(self, async_client: AsyncO
 
     @parametrize
     async def test_streaming_response_create_and_run_overload_2(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.with_streaming_response.create_and_run(
-            assistant_id="string",
-            stream=True,
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            stream = await response.parse()
-            await stream.close()
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.with_streaming_response.create_and_run(
+                assistant_id="assistant_id",
+                stream=True,
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+                stream = await response.parse()
+                await stream.close()
 
         assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/beta/threads/runs/test_steps.py b/tests/api_resources/beta/threads/runs/test_steps.py
index f5dc17e0b5..ba44eec63d 100644
--- a/tests/api_resources/beta/threads/runs/test_steps.py
+++ b/tests/api_resources/beta/threads/runs/test_steps.py
@@ -12,6 +12,8 @@
 from openai.pagination import SyncCursorPage, AsyncCursorPage
 from openai.types.beta.threads.runs import RunStep
 
+# pyright: reportDeprecated=false
+
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
 
@@ -20,30 +22,35 @@ class TestSteps:
 
     @parametrize
     def test_method_retrieve(self, client: OpenAI) -> None:
-        step = client.beta.threads.runs.steps.retrieve(
-            "string",
-            thread_id="string",
-            run_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            step = client.beta.threads.runs.steps.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+            )
+
         assert_matches_type(RunStep, step, path=["response"])
 
     @parametrize
     def test_method_retrieve_with_all_params(self, client: OpenAI) -> None:
-        step = client.beta.threads.runs.steps.retrieve(
-            step_id="step_id",
-            thread_id="thread_id",
-            run_id="run_id",
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-        )
+        with pytest.warns(DeprecationWarning):
+            step = client.beta.threads.runs.steps.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+            )
+
         assert_matches_type(RunStep, step, path=["response"])
 
     @parametrize
     def test_raw_response_retrieve(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.steps.with_raw_response.retrieve(
-            "string",
-            thread_id="string",
-            run_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.steps.with_raw_response.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -52,69 +59,76 @@ def test_raw_response_retrieve(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_retrieve(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.steps.with_streaming_response.retrieve(
-            "string",
-            thread_id="string",
-            run_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            step = response.parse()
-            assert_matches_type(RunStep, step, path=["response"])
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.steps.with_streaming_response.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+                step = response.parse()
+                assert_matches_type(RunStep, step, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_retrieve(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.steps.with_raw_response.retrieve(
-                "string",
-                thread_id="",
-                run_id="string",
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            client.beta.threads.runs.steps.with_raw_response.retrieve(
-                "string",
-                thread_id="string",
-                run_id="",
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `step_id` but received ''"):
-            client.beta.threads.runs.steps.with_raw_response.retrieve(
-                "",
-                thread_id="string",
-                run_id="string",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.steps.with_raw_response.retrieve(
+                    step_id="step_id",
+                    thread_id="",
+                    run_id="run_id",
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                client.beta.threads.runs.steps.with_raw_response.retrieve(
+                    step_id="step_id",
+                    thread_id="thread_id",
+                    run_id="",
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `step_id` but received ''"):
+                client.beta.threads.runs.steps.with_raw_response.retrieve(
+                    step_id="",
+                    thread_id="thread_id",
+                    run_id="run_id",
+                )
 
     @parametrize
     def test_method_list(self, client: OpenAI) -> None:
-        step = client.beta.threads.runs.steps.list(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            step = client.beta.threads.runs.steps.list(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(SyncCursorPage[RunStep], step, path=["response"])
 
     @parametrize
     def test_method_list_with_all_params(self, client: OpenAI) -> None:
-        step = client.beta.threads.runs.steps.list(
-            run_id="run_id",
-            thread_id="thread_id",
-            after="after",
-            before="before",
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-            limit=0,
-            order="asc",
-        )
+        with pytest.warns(DeprecationWarning):
+            step = client.beta.threads.runs.steps.list(
+                run_id="run_id",
+                thread_id="thread_id",
+                after="after",
+                before="before",
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+                limit=0,
+                order="asc",
+            )
+
         assert_matches_type(SyncCursorPage[RunStep], step, path=["response"])
 
     @parametrize
     def test_raw_response_list(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.steps.with_raw_response.list(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.steps.with_raw_response.list(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -123,62 +137,71 @@ def test_raw_response_list(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_list(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.steps.with_streaming_response.list(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.steps.with_streaming_response.list(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            step = response.parse()
-            assert_matches_type(SyncCursorPage[RunStep], step, path=["response"])
+                step = response.parse()
+                assert_matches_type(SyncCursorPage[RunStep], step, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_list(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.steps.with_raw_response.list(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.steps.with_raw_response.list(
+                    run_id="run_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            client.beta.threads.runs.steps.with_raw_response.list(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                client.beta.threads.runs.steps.with_raw_response.list(
+                    run_id="",
+                    thread_id="thread_id",
+                )
 
 
 class TestAsyncSteps:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
-        step = await async_client.beta.threads.runs.steps.retrieve(
-            "string",
-            thread_id="string",
-            run_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            step = await async_client.beta.threads.runs.steps.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+            )
+
         assert_matches_type(RunStep, step, path=["response"])
 
     @parametrize
     async def test_method_retrieve_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        step = await async_client.beta.threads.runs.steps.retrieve(
-            step_id="step_id",
-            thread_id="thread_id",
-            run_id="run_id",
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-        )
+        with pytest.warns(DeprecationWarning):
+            step = await async_client.beta.threads.runs.steps.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+            )
+
         assert_matches_type(RunStep, step, path=["response"])
 
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
-            "string",
-            thread_id="string",
-            run_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -187,69 +210,76 @@ async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.steps.with_streaming_response.retrieve(
-            "string",
-            thread_id="string",
-            run_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            step = await response.parse()
-            assert_matches_type(RunStep, step, path=["response"])
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.steps.with_streaming_response.retrieve(
+                step_id="step_id",
+                thread_id="thread_id",
+                run_id="run_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+                step = await response.parse()
+                assert_matches_type(RunStep, step, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
-                "string",
-                thread_id="",
-                run_id="string",
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
-                "string",
-                thread_id="string",
-                run_id="",
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `step_id` but received ''"):
-            await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
-                "",
-                thread_id="string",
-                run_id="string",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
+                    step_id="step_id",
+                    thread_id="",
+                    run_id="run_id",
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
+                    step_id="step_id",
+                    thread_id="thread_id",
+                    run_id="",
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `step_id` but received ''"):
+                await async_client.beta.threads.runs.steps.with_raw_response.retrieve(
+                    step_id="",
+                    thread_id="thread_id",
+                    run_id="run_id",
+                )
 
     @parametrize
     async def test_method_list(self, async_client: AsyncOpenAI) -> None:
-        step = await async_client.beta.threads.runs.steps.list(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            step = await async_client.beta.threads.runs.steps.list(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(AsyncCursorPage[RunStep], step, path=["response"])
 
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        step = await async_client.beta.threads.runs.steps.list(
-            run_id="run_id",
-            thread_id="thread_id",
-            after="after",
-            before="before",
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-            limit=0,
-            order="asc",
-        )
+        with pytest.warns(DeprecationWarning):
+            step = await async_client.beta.threads.runs.steps.list(
+                run_id="run_id",
+                thread_id="thread_id",
+                after="after",
+                before="before",
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+                limit=0,
+                order="asc",
+            )
+
         assert_matches_type(AsyncCursorPage[RunStep], step, path=["response"])
 
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.steps.with_raw_response.list(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.steps.with_raw_response.list(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -258,28 +288,30 @@ async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.steps.with_streaming_response.list(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.steps.with_streaming_response.list(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            step = await response.parse()
-            assert_matches_type(AsyncCursorPage[RunStep], step, path=["response"])
+                step = await response.parse()
+                assert_matches_type(AsyncCursorPage[RunStep], step, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.steps.with_raw_response.list(
-                "string",
-                thread_id="",
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            await async_client.beta.threads.runs.steps.with_raw_response.list(
-                "",
-                thread_id="string",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.steps.with_raw_response.list(
+                    run_id="run_id",
+                    thread_id="",
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                await async_client.beta.threads.runs.steps.with_raw_response.list(
+                    run_id="",
+                    thread_id="thread_id",
+                )
diff --git a/tests/api_resources/beta/threads/test_messages.py b/tests/api_resources/beta/threads/test_messages.py
index 9189a2f29e..7f57002f27 100644
--- a/tests/api_resources/beta/threads/test_messages.py
+++ b/tests/api_resources/beta/threads/test_messages.py
@@ -15,6 +15,8 @@
     MessageDeleted,
 )
 
+# pyright: reportDeprecated=false
+
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
 
@@ -23,36 +25,41 @@ class TestMessages:
 
     @parametrize
     def test_method_create(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.create(
-            "string",
-            content="string",
-            role="user",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     def test_method_create_with_all_params(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.create(
-            "string",
-            content="string",
-            role="user",
-            attachments=[
-                {
-                    "file_id": "file_id",
-                    "tools": [{"type": "code_interpreter"}],
-                }
-            ],
-            metadata={"foo": "string"},
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+                attachments=[
+                    {
+                        "file_id": "file_id",
+                        "tools": [{"type": "code_interpreter"}],
+                    }
+                ],
+                metadata={"foo": "string"},
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     def test_raw_response_create(self, client: OpenAI) -> None:
-        response = client.beta.threads.messages.with_raw_response.create(
-            "string",
-            content="string",
-            role="user",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.messages.with_raw_response.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -61,42 +68,47 @@ def test_raw_response_create(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_create(self, client: OpenAI) -> None:
-        with client.beta.threads.messages.with_streaming_response.create(
-            "string",
-            content="string",
-            role="user",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.messages.with_streaming_response.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = response.parse()
-            assert_matches_type(Message, message, path=["response"])
+                message = response.parse()
+                assert_matches_type(Message, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_create(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.create(
-                "",
-                content="string",
-                role="user",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.create(
+                    thread_id="",
+                    content="string",
+                    role="user",
+                )
 
     @parametrize
     def test_method_retrieve(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.retrieve(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     def test_raw_response_retrieve(self, client: OpenAI) -> None:
-        response = client.beta.threads.messages.with_raw_response.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.messages.with_raw_response.retrieve(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -105,55 +117,62 @@ def test_raw_response_retrieve(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_retrieve(self, client: OpenAI) -> None:
-        with client.beta.threads.messages.with_streaming_response.retrieve(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.messages.with_streaming_response.retrieve(
+                message_id="message_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = response.parse()
-            assert_matches_type(Message, message, path=["response"])
+                message = response.parse()
+                assert_matches_type(Message, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_retrieve(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.retrieve(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.retrieve(
+                    message_id="message_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.retrieve(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.retrieve(
+                    message_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     def test_method_update(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.update(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     def test_method_update_with_all_params(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.update(
-            message_id="message_id",
-            thread_id="thread_id",
-            metadata={"foo": "string"},
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.update(
+                message_id="message_id",
+                thread_id="thread_id",
+                metadata={"foo": "string"},
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     def test_raw_response_update(self, client: OpenAI) -> None:
-        response = client.beta.threads.messages.with_raw_response.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.messages.with_raw_response.update(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -162,56 +181,63 @@ def test_raw_response_update(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_update(self, client: OpenAI) -> None:
-        with client.beta.threads.messages.with_streaming_response.update(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.messages.with_streaming_response.update(
+                message_id="message_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = response.parse()
-            assert_matches_type(Message, message, path=["response"])
+                message = response.parse()
+                assert_matches_type(Message, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_update(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.update(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.update(
+                    message_id="message_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.update(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.update(
+                    message_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     def test_method_list(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.list(
+                thread_id="thread_id",
+            )
+
         assert_matches_type(SyncCursorPage[Message], message, path=["response"])
 
     @parametrize
     def test_method_list_with_all_params(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.list(
-            "string",
-            after="string",
-            before="string",
-            limit=0,
-            order="asc",
-            run_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.list(
+                thread_id="thread_id",
+                after="after",
+                before="before",
+                limit=0,
+                order="asc",
+                run_id="run_id",
+            )
+
         assert_matches_type(SyncCursorPage[Message], message, path=["response"])
 
     @parametrize
     def test_raw_response_list(self, client: OpenAI) -> None:
-        response = client.beta.threads.messages.with_raw_response.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.messages.with_raw_response.list(
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -220,38 +246,43 @@ def test_raw_response_list(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_list(self, client: OpenAI) -> None:
-        with client.beta.threads.messages.with_streaming_response.list(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.messages.with_streaming_response.list(
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = response.parse()
-            assert_matches_type(SyncCursorPage[Message], message, path=["response"])
+                message = response.parse()
+                assert_matches_type(SyncCursorPage[Message], message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_list(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.list(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.list(
+                    thread_id="",
+                )
 
     @parametrize
     def test_method_delete(self, client: OpenAI) -> None:
-        message = client.beta.threads.messages.delete(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = client.beta.threads.messages.delete(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(MessageDeleted, message, path=["response"])
 
     @parametrize
     def test_raw_response_delete(self, client: OpenAI) -> None:
-        response = client.beta.threads.messages.with_raw_response.delete(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.messages.with_raw_response.delete(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -260,68 +291,77 @@ def test_raw_response_delete(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_delete(self, client: OpenAI) -> None:
-        with client.beta.threads.messages.with_streaming_response.delete(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.messages.with_streaming_response.delete(
+                message_id="message_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = response.parse()
-            assert_matches_type(MessageDeleted, message, path=["response"])
+                message = response.parse()
+                assert_matches_type(MessageDeleted, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_delete(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.delete(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.delete(
+                    message_id="message_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
-            client.beta.threads.messages.with_raw_response.delete(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
+                client.beta.threads.messages.with_raw_response.delete(
+                    message_id="",
+                    thread_id="thread_id",
+                )
 
 
 class TestAsyncMessages:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.create(
-            "string",
-            content="string",
-            role="user",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.create(
-            "string",
-            content="string",
-            role="user",
-            attachments=[
-                {
-                    "file_id": "file_id",
-                    "tools": [{"type": "code_interpreter"}],
-                }
-            ],
-            metadata={"foo": "string"},
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+                attachments=[
+                    {
+                        "file_id": "file_id",
+                        "tools": [{"type": "code_interpreter"}],
+                    }
+                ],
+                metadata={"foo": "string"},
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.messages.with_raw_response.create(
-            "string",
-            content="string",
-            role="user",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.messages.with_raw_response.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -330,42 +370,47 @@ async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.messages.with_streaming_response.create(
-            "string",
-            content="string",
-            role="user",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.messages.with_streaming_response.create(
+                thread_id="thread_id",
+                content="string",
+                role="user",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = await response.parse()
-            assert_matches_type(Message, message, path=["response"])
+                message = await response.parse()
+                assert_matches_type(Message, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_create(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.create(
-                "",
-                content="string",
-                role="user",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.create(
+                    thread_id="",
+                    content="string",
+                    role="user",
+                )
 
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.retrieve(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.messages.with_raw_response.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.messages.with_raw_response.retrieve(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -374,55 +419,62 @@ async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.messages.with_streaming_response.retrieve(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.messages.with_streaming_response.retrieve(
+                message_id="message_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = await response.parse()
-            assert_matches_type(Message, message, path=["response"])
+                message = await response.parse()
+                assert_matches_type(Message, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.retrieve(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.retrieve(
+                    message_id="message_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.retrieve(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.retrieve(
+                    message_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     async def test_method_update(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.update(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.update(
-            message_id="message_id",
-            thread_id="thread_id",
-            metadata={"foo": "string"},
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.update(
+                message_id="message_id",
+                thread_id="thread_id",
+                metadata={"foo": "string"},
+            )
+
         assert_matches_type(Message, message, path=["response"])
 
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.messages.with_raw_response.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.messages.with_raw_response.update(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -431,56 +483,63 @@ async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.messages.with_streaming_response.update(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.messages.with_streaming_response.update(
+                message_id="message_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = await response.parse()
-            assert_matches_type(Message, message, path=["response"])
+                message = await response.parse()
+                assert_matches_type(Message, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_update(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.update(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.update(
+                    message_id="message_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.update(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.update(
+                    message_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     async def test_method_list(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.list(
+                thread_id="thread_id",
+            )
+
         assert_matches_type(AsyncCursorPage[Message], message, path=["response"])
 
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.list(
-            "string",
-            after="string",
-            before="string",
-            limit=0,
-            order="asc",
-            run_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.list(
+                thread_id="thread_id",
+                after="after",
+                before="before",
+                limit=0,
+                order="asc",
+                run_id="run_id",
+            )
+
         assert_matches_type(AsyncCursorPage[Message], message, path=["response"])
 
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.messages.with_raw_response.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.messages.with_raw_response.list(
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -489,38 +548,43 @@ async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.messages.with_streaming_response.list(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.messages.with_streaming_response.list(
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = await response.parse()
-            assert_matches_type(AsyncCursorPage[Message], message, path=["response"])
+                message = await response.parse()
+                assert_matches_type(AsyncCursorPage[Message], message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.list(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.list(
+                    thread_id="",
+                )
 
     @parametrize
     async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
-        message = await async_client.beta.threads.messages.delete(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            message = await async_client.beta.threads.messages.delete(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(MessageDeleted, message, path=["response"])
 
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.messages.with_raw_response.delete(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.messages.with_raw_response.delete(
+                message_id="message_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -529,28 +593,30 @@ async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.messages.with_streaming_response.delete(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.messages.with_streaming_response.delete(
+                message_id="message_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            message = await response.parse()
-            assert_matches_type(MessageDeleted, message, path=["response"])
+                message = await response.parse()
+                assert_matches_type(MessageDeleted, message, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.delete(
-                "string",
-                thread_id="",
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
-            await async_client.beta.threads.messages.with_raw_response.delete(
-                "",
-                thread_id="string",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.delete(
+                    message_id="message_id",
+                    thread_id="",
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
+                await async_client.beta.threads.messages.with_raw_response.delete(
+                    message_id="",
+                    thread_id="thread_id",
+                )
diff --git a/tests/api_resources/beta/threads/test_runs.py b/tests/api_resources/beta/threads/test_runs.py
index d05ee96144..3a6b36864d 100644
--- a/tests/api_resources/beta/threads/test_runs.py
+++ b/tests/api_resources/beta/threads/test_runs.py
@@ -24,58 +24,63 @@ class TestRuns:
 
     @parametrize
     def test_method_create_overload_1(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.create(
-            "string",
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.create(
-            thread_id="thread_id",
-            assistant_id="assistant_id",
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-            additional_instructions="additional_instructions",
-            additional_messages=[
-                {
-                    "content": "string",
-                    "role": "user",
-                    "attachments": [
-                        {
-                            "file_id": "file_id",
-                            "tools": [{"type": "code_interpreter"}],
-                        }
-                    ],
-                    "metadata": {"foo": "string"},
-                }
-            ],
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            reasoning_effort="low",
-            response_format="auto",
-            stream=False,
-            temperature=1,
-            tool_choice="none",
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+                additional_instructions="additional_instructions",
+                additional_messages=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "attachments": [
+                            {
+                                "file_id": "file_id",
+                                "tools": [{"type": "code_interpreter"}],
+                            }
+                        ],
+                        "metadata": {"foo": "string"},
+                    }
+                ],
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                reasoning_effort="none",
+                response_format="auto",
+                stream=False,
+                temperature=1,
+                tool_choice="none",
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_raw_response_create_overload_1(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.create(
-            "string",
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -84,82 +89,89 @@ def test_raw_response_create_overload_1(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_create_overload_1(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.create(
-            "string",
-            assistant_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_create_overload_1(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.create(
-                "",
-                assistant_id="string",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.create(
+                    thread_id="",
+                    assistant_id="assistant_id",
+                )
 
     @parametrize
     def test_method_create_overload_2(self, client: OpenAI) -> None:
-        run_stream = client.beta.threads.runs.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            run_stream = client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+            )
+
         run_stream.response.close()
 
     @parametrize
     def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
-        run_stream = client.beta.threads.runs.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-            additional_instructions="additional_instructions",
-            additional_messages=[
-                {
-                    "content": "string",
-                    "role": "user",
-                    "attachments": [
-                        {
-                            "file_id": "file_id",
-                            "tools": [{"type": "code_interpreter"}],
-                        }
-                    ],
-                    "metadata": {"foo": "string"},
-                }
-            ],
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            reasoning_effort="low",
-            response_format="auto",
-            temperature=1,
-            tool_choice="none",
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+        with pytest.warns(DeprecationWarning):
+            run_stream = client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+                additional_instructions="additional_instructions",
+                additional_messages=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "attachments": [
+                            {
+                                "file_id": "file_id",
+                                "tools": [{"type": "code_interpreter"}],
+                            }
+                        ],
+                        "metadata": {"foo": "string"},
+                    }
+                ],
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                reasoning_effort="none",
+                response_format="auto",
+                temperature=1,
+                tool_choice="none",
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         run_stream.response.close()
 
     @parametrize
     def test_raw_response_create_overload_2(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+            )
 
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         stream = response.parse()
@@ -167,42 +179,47 @@ def test_raw_response_create_overload_2(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_create_overload_2(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            stream = response.parse()
-            stream.close()
+                stream = response.parse()
+                stream.close()
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_create_overload_2(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.create(
-                "",
-                assistant_id="string",
-                stream=True,
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.create(
+                    thread_id="",
+                    assistant_id="assistant_id",
+                    stream=True,
+                )
 
     @parametrize
     def test_method_retrieve(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.retrieve(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_raw_response_retrieve(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.retrieve(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -211,55 +228,62 @@ def test_raw_response_retrieve(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_retrieve(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.retrieve(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.retrieve(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_retrieve(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.retrieve(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.retrieve(
+                    run_id="run_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.retrieve(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.retrieve(
+                    run_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     def test_method_update(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.update(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_method_update_with_all_params(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.update(
-            run_id="run_id",
-            thread_id="thread_id",
-            metadata={"foo": "string"},
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.update(
+                run_id="run_id",
+                thread_id="thread_id",
+                metadata={"foo": "string"},
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_raw_response_update(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.update(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -268,55 +292,62 @@ def test_raw_response_update(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_update(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.update(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.update(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_update(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.update(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.update(
+                    run_id="run_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.update(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.update(
+                    run_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     def test_method_list(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.list(
+                thread_id="thread_id",
+            )
+
         assert_matches_type(SyncCursorPage[Run], run, path=["response"])
 
     @parametrize
     def test_method_list_with_all_params(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.list(
-            "string",
-            after="string",
-            before="string",
-            limit=0,
-            order="asc",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.list(
+                thread_id="thread_id",
+                after="after",
+                before="before",
+                limit=0,
+                order="asc",
+            )
+
         assert_matches_type(SyncCursorPage[Run], run, path=["response"])
 
     @parametrize
     def test_raw_response_list(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.list(
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -325,38 +356,43 @@ def test_raw_response_list(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_list(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.list(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.list(
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = response.parse()
-            assert_matches_type(SyncCursorPage[Run], run, path=["response"])
+                run = response.parse()
+                assert_matches_type(SyncCursorPage[Run], run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_list(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.list(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.list(
+                    thread_id="",
+                )
 
     @parametrize
     def test_method_cancel(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.cancel(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.cancel(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_raw_response_cancel(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.cancel(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.cancel(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -365,63 +401,70 @@ def test_raw_response_cancel(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_cancel(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.cancel(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.cancel(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_cancel(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.cancel(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.cancel(
+                    run_id="run_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.cancel(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.cancel(
+                    run_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     def test_method_submit_tool_outputs_overload_1(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.submit_tool_outputs(
-            run_id="run_id",
-            thread_id="thread_id",
-            tool_outputs=[{}],
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[{}],
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_method_submit_tool_outputs_with_all_params_overload_1(self, client: OpenAI) -> None:
-        run = client.beta.threads.runs.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            tool_outputs=[
-                {
-                    "output": "output",
-                    "tool_call_id": "tool_call_id",
-                }
-            ],
-            stream=False,
-        )
+        with pytest.warns(DeprecationWarning):
+            run = client.beta.threads.runs.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[
+                    {
+                        "output": "output",
+                        "tool_call_id": "tool_call_id",
+                    }
+                ],
+                stream=False,
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     def test_raw_response_submit_tool_outputs_overload_1(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-            run_id="run_id",
-            thread_id="thread_id",
-            tool_outputs=[{}],
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[{}],
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -430,53 +473,58 @@ def test_raw_response_submit_tool_outputs_overload_1(self, client: OpenAI) -> No
 
     @parametrize
     def test_streaming_response_submit_tool_outputs_overload_1(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
-            run_id="run_id",
-            thread_id="thread_id",
-            tool_outputs=[{}],
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[{}],
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_submit_tool_outputs_overload_1(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                "string",
-                thread_id="",
-                tool_outputs=[{}],
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="run_id",
+                    thread_id="",
+                    tool_outputs=[{}],
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="",
+                    thread_id="thread_id",
+                    tool_outputs=[{}],
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                run_id="",
+    @parametrize
+    def test_method_submit_tool_outputs_overload_2(self, client: OpenAI) -> None:
+        with pytest.warns(DeprecationWarning):
+            run_stream = client.beta.threads.runs.submit_tool_outputs(
+                run_id="run_id",
                 thread_id="thread_id",
+                stream=True,
                 tool_outputs=[{}],
             )
 
-    @parametrize
-    def test_method_submit_tool_outputs_overload_2(self, client: OpenAI) -> None:
-        run_stream = client.beta.threads.runs.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            stream=True,
-            tool_outputs=[{}],
-        )
         run_stream.response.close()
 
     @parametrize
     def test_raw_response_submit_tool_outputs_overload_2(self, client: OpenAI) -> None:
-        response = client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            stream=True,
-            tool_outputs=[{}],
-        )
+        with pytest.warns(DeprecationWarning):
+            response = client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                stream=True,
+                tool_outputs=[{}],
+            )
 
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         stream = response.parse()
@@ -484,96 +532,105 @@ def test_raw_response_submit_tool_outputs_overload_2(self, client: OpenAI) -> No
 
     @parametrize
     def test_streaming_response_submit_tool_outputs_overload_2(self, client: OpenAI) -> None:
-        with client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            stream=True,
-            tool_outputs=[{}],
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            stream = response.parse()
-            stream.close()
+        with pytest.warns(DeprecationWarning):
+            with client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                stream=True,
+                tool_outputs=[{}],
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+                stream = response.parse()
+                stream.close()
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     def test_path_params_submit_tool_outputs_overload_2(self, client: OpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                "string",
-                thread_id="",
-                stream=True,
-                tool_outputs=[{}],
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                "",
-                thread_id="string",
-                stream=True,
-                tool_outputs=[{}],
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="run_id",
+                    thread_id="",
+                    stream=True,
+                    tool_outputs=[{}],
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="",
+                    thread_id="thread_id",
+                    stream=True,
+                    tool_outputs=[{}],
+                )
 
 
 class TestAsyncRuns:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create_overload_1(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.create(
-            "string",
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_method_create_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.create(
-            thread_id="thread_id",
-            assistant_id="assistant_id",
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-            additional_instructions="additional_instructions",
-            additional_messages=[
-                {
-                    "content": "string",
-                    "role": "user",
-                    "attachments": [
-                        {
-                            "file_id": "file_id",
-                            "tools": [{"type": "code_interpreter"}],
-                        }
-                    ],
-                    "metadata": {"foo": "string"},
-                }
-            ],
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            reasoning_effort="low",
-            response_format="auto",
-            stream=False,
-            temperature=1,
-            tool_choice="none",
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+                additional_instructions="additional_instructions",
+                additional_messages=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "attachments": [
+                            {
+                                "file_id": "file_id",
+                                "tools": [{"type": "code_interpreter"}],
+                            }
+                        ],
+                        "metadata": {"foo": "string"},
+                    }
+                ],
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                reasoning_effort="none",
+                response_format="auto",
+                stream=False,
+                temperature=1,
+                tool_choice="none",
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_raw_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.create(
-            "string",
-            assistant_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -582,82 +639,89 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncOpenAI) -
 
     @parametrize
     async def test_streaming_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.create(
-            "string",
-            assistant_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = await response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = await response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_create_overload_1(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.create(
-                "",
-                assistant_id="string",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.create(
+                    thread_id="",
+                    assistant_id="assistant_id",
+                )
 
     @parametrize
     async def test_method_create_overload_2(self, async_client: AsyncOpenAI) -> None:
-        run_stream = await async_client.beta.threads.runs.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            run_stream = await async_client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+            )
+
         await run_stream.response.aclose()
 
     @parametrize
     async def test_method_create_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
-        run_stream = await async_client.beta.threads.runs.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-            include=["step_details.tool_calls[*].file_search.results[*].content"],
-            additional_instructions="additional_instructions",
-            additional_messages=[
-                {
-                    "content": "string",
-                    "role": "user",
-                    "attachments": [
-                        {
-                            "file_id": "file_id",
-                            "tools": [{"type": "code_interpreter"}],
-                        }
-                    ],
-                    "metadata": {"foo": "string"},
-                }
-            ],
-            instructions="string",
-            max_completion_tokens=256,
-            max_prompt_tokens=256,
-            metadata={"foo": "string"},
-            model="gpt-4o",
-            parallel_tool_calls=True,
-            reasoning_effort="low",
-            response_format="auto",
-            temperature=1,
-            tool_choice="none",
-            tools=[{"type": "code_interpreter"}],
-            top_p=1,
-            truncation_strategy={
-                "type": "auto",
-                "last_messages": 1,
-            },
-        )
+        with pytest.warns(DeprecationWarning):
+            run_stream = await async_client.beta.threads.runs.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+                include=["step_details.tool_calls[*].file_search.results[*].content"],
+                additional_instructions="additional_instructions",
+                additional_messages=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "attachments": [
+                            {
+                                "file_id": "file_id",
+                                "tools": [{"type": "code_interpreter"}],
+                            }
+                        ],
+                        "metadata": {"foo": "string"},
+                    }
+                ],
+                instructions="instructions",
+                max_completion_tokens=256,
+                max_prompt_tokens=256,
+                metadata={"foo": "string"},
+                model="string",
+                parallel_tool_calls=True,
+                reasoning_effort="none",
+                response_format="auto",
+                temperature=1,
+                tool_choice="none",
+                tools=[{"type": "code_interpreter"}],
+                top_p=1,
+                truncation_strategy={
+                    "type": "auto",
+                    "last_messages": 1,
+                },
+            )
+
         await run_stream.response.aclose()
 
     @parametrize
     async def test_raw_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+            )
 
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         stream = response.parse()
@@ -665,42 +729,47 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncOpenAI) -
 
     @parametrize
     async def test_streaming_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.create(
-            "string",
-            assistant_id="string",
-            stream=True,
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.create(
+                thread_id="thread_id",
+                assistant_id="assistant_id",
+                stream=True,
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            stream = await response.parse()
-            await stream.close()
+                stream = await response.parse()
+                await stream.close()
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_create_overload_2(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.create(
-                "",
-                assistant_id="string",
-                stream=True,
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.create(
+                    thread_id="",
+                    assistant_id="assistant_id",
+                    stream=True,
+                )
 
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.retrieve(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.retrieve(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.retrieve(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -709,55 +778,62 @@ async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.retrieve(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.retrieve(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = await response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = await response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.retrieve(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.retrieve(
+                    run_id="run_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.retrieve(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.retrieve(
+                    run_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     async def test_method_update(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.update(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.update(
-            run_id="run_id",
-            thread_id="thread_id",
-            metadata={"foo": "string"},
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.update(
+                run_id="run_id",
+                thread_id="thread_id",
+                metadata={"foo": "string"},
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.update(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.update(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -766,55 +842,62 @@ async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.update(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.update(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = await response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = await response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_update(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.update(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.update(
+                    run_id="run_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.update(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.update(
+                    run_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     async def test_method_list(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.list(
+                thread_id="thread_id",
+            )
+
         assert_matches_type(AsyncCursorPage[Run], run, path=["response"])
 
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.list(
-            "string",
-            after="string",
-            before="string",
-            limit=0,
-            order="asc",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.list(
+                thread_id="thread_id",
+                after="after",
+                before="before",
+                limit=0,
+                order="asc",
+            )
+
         assert_matches_type(AsyncCursorPage[Run], run, path=["response"])
 
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.list(
-            "string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.list(
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -823,38 +906,43 @@ async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.list(
-            "string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.list(
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = await response.parse()
-            assert_matches_type(AsyncCursorPage[Run], run, path=["response"])
+                run = await response.parse()
+                assert_matches_type(AsyncCursorPage[Run], run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.list(
-                "",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.list(
+                    thread_id="",
+                )
 
     @parametrize
     async def test_method_cancel(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.cancel(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.cancel(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_raw_response_cancel(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.cancel(
-            "string",
-            thread_id="string",
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.cancel(
+                run_id="run_id",
+                thread_id="thread_id",
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -863,63 +951,70 @@ async def test_raw_response_cancel(self, async_client: AsyncOpenAI) -> None:
 
     @parametrize
     async def test_streaming_response_cancel(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.cancel(
-            "string",
-            thread_id="string",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.cancel(
+                run_id="run_id",
+                thread_id="thread_id",
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = await response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = await response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_cancel(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.cancel(
-                "string",
-                thread_id="",
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.cancel(
+                    run_id="run_id",
+                    thread_id="",
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.cancel(
-                "",
-                thread_id="string",
-            )
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.cancel(
+                    run_id="",
+                    thread_id="thread_id",
+                )
 
     @parametrize
     async def test_method_submit_tool_outputs_overload_1(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.submit_tool_outputs(
-            run_id="run_id",
-            thread_id="thread_id",
-            tool_outputs=[{}],
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[{}],
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_method_submit_tool_outputs_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
-        run = await async_client.beta.threads.runs.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            tool_outputs=[
-                {
-                    "output": "output",
-                    "tool_call_id": "tool_call_id",
-                }
-            ],
-            stream=False,
-        )
+        with pytest.warns(DeprecationWarning):
+            run = await async_client.beta.threads.runs.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[
+                    {
+                        "output": "output",
+                        "tool_call_id": "tool_call_id",
+                    }
+                ],
+                stream=False,
+            )
+
         assert_matches_type(Run, run, path=["response"])
 
     @parametrize
     async def test_raw_response_submit_tool_outputs_overload_1(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-            run_id="run_id",
-            thread_id="thread_id",
-            tool_outputs=[{}],
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[{}],
+            )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -928,53 +1023,58 @@ async def test_raw_response_submit_tool_outputs_overload_1(self, async_client: A
 
     @parametrize
     async def test_streaming_response_submit_tool_outputs_overload_1(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
-            run_id="run_id",
-            thread_id="thread_id",
-            tool_outputs=[{}],
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                tool_outputs=[{}],
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            run = await response.parse()
-            assert_matches_type(Run, run, path=["response"])
+                run = await response.parse()
+                assert_matches_type(Run, run, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_submit_tool_outputs_overload_1(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                "string",
-                thread_id="",
-                tool_outputs=[{}],
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="run_id",
+                    thread_id="",
+                    tool_outputs=[{}],
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="",
+                    thread_id="thread_id",
+                    tool_outputs=[{}],
+                )
 
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                run_id="",
+    @parametrize
+    async def test_method_submit_tool_outputs_overload_2(self, async_client: AsyncOpenAI) -> None:
+        with pytest.warns(DeprecationWarning):
+            run_stream = await async_client.beta.threads.runs.submit_tool_outputs(
+                run_id="run_id",
                 thread_id="thread_id",
+                stream=True,
                 tool_outputs=[{}],
             )
 
-    @parametrize
-    async def test_method_submit_tool_outputs_overload_2(self, async_client: AsyncOpenAI) -> None:
-        run_stream = await async_client.beta.threads.runs.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            stream=True,
-            tool_outputs=[{}],
-        )
         await run_stream.response.aclose()
 
     @parametrize
     async def test_raw_response_submit_tool_outputs_overload_2(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            stream=True,
-            tool_outputs=[{}],
-        )
+        with pytest.warns(DeprecationWarning):
+            response = await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                stream=True,
+                tool_outputs=[{}],
+            )
 
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         stream = response.parse()
@@ -982,34 +1082,36 @@ async def test_raw_response_submit_tool_outputs_overload_2(self, async_client: A
 
     @parametrize
     async def test_streaming_response_submit_tool_outputs_overload_2(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
-            "string",
-            thread_id="string",
-            stream=True,
-            tool_outputs=[{}],
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            stream = await response.parse()
-            await stream.close()
+        with pytest.warns(DeprecationWarning):
+            async with async_client.beta.threads.runs.with_streaming_response.submit_tool_outputs(
+                run_id="run_id",
+                thread_id="thread_id",
+                stream=True,
+                tool_outputs=[{}],
+            ) as response:
+                assert not response.is_closed
+                assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+                stream = await response.parse()
+                await stream.close()
 
         assert cast(Any, response.is_closed) is True
 
     @parametrize
     async def test_path_params_submit_tool_outputs_overload_2(self, async_client: AsyncOpenAI) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                "string",
-                thread_id="",
-                stream=True,
-                tool_outputs=[{}],
-            )
-
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
-            await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
-                "",
-                thread_id="string",
-                stream=True,
-                tool_outputs=[{}],
-            )
+        with pytest.warns(DeprecationWarning):
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `thread_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="run_id",
+                    thread_id="",
+                    stream=True,
+                    tool_outputs=[{}],
+                )
+
+            with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+                await async_client.beta.threads.runs.with_raw_response.submit_tool_outputs(
+                    run_id="",
+                    thread_id="thread_id",
+                    stream=True,
+                    tool_outputs=[{}],
+                )
diff --git a/tests/api_resources/chat/completions/test_messages.py b/tests/api_resources/chat/completions/test_messages.py
index 5caac9ec6c..4a4267e539 100644
--- a/tests/api_resources/chat/completions/test_messages.py
+++ b/tests/api_resources/chat/completions/test_messages.py
@@ -68,7 +68,9 @@ def test_path_params_list(self, client: OpenAI) -> None:
 
 
 class TestAsyncMessages:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_list(self, async_client: AsyncOpenAI) -> None:
diff --git a/tests/api_resources/chat/test_completions.py b/tests/api_resources/chat/test_completions.py
index d4ccc494dd..2b58ff8191 100644
--- a/tests/api_resources/chat/test_completions.py
+++ b/tests/api_resources/chat/test_completions.py
@@ -48,7 +48,7 @@ def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
             model="gpt-4o",
             audio={
                 "format": "wav",
-                "voice": "alloy",
+                "voice": "ash",
             },
             frequency_penalty=-2,
             function_call="none",
@@ -72,14 +72,20 @@ def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
                 "type": "content",
             },
             presence_penalty=-2,
-            reasoning_effort="low",
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
+            reasoning_effort="none",
             response_format={"type": "text"},
+            safety_identifier="safety-identifier-1234",
             seed=-9007199254740991,
             service_tier="auto",
             stop="\n",
             store=True,
             stream=False,
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             temperature=1,
             tool_choice="none",
             tools=[
@@ -96,6 +102,7 @@ def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
             top_logprobs=0,
             top_p=1,
             user="user-1234",
+            verbosity="low",
             web_search_options={
                 "search_context_size": "low",
                 "user_location": {
@@ -175,7 +182,7 @@ def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
             stream=True,
             audio={
                 "format": "wav",
-                "voice": "alloy",
+                "voice": "ash",
             },
             frequency_penalty=-2,
             function_call="none",
@@ -199,13 +206,19 @@ def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
                 "type": "content",
             },
             presence_penalty=-2,
-            reasoning_effort="low",
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
+            reasoning_effort="none",
             response_format={"type": "text"},
+            safety_identifier="safety-identifier-1234",
             seed=-9007199254740991,
             service_tier="auto",
             stop="\n",
             store=True,
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             temperature=1,
             tool_choice="none",
             tools=[
@@ -222,6 +235,7 @@ def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
             top_logprobs=0,
             top_p=1,
             user="user-1234",
+            verbosity="low",
             web_search_options={
                 "search_context_size": "low",
                 "user_location": {
@@ -447,7 +461,9 @@ class MyModel(pydantic.BaseModel):
 
 
 class TestAsyncCompletions:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create_overload_1(self, async_client: AsyncOpenAI) -> None:
@@ -475,7 +491,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
             model="gpt-4o",
             audio={
                 "format": "wav",
-                "voice": "alloy",
+                "voice": "ash",
             },
             frequency_penalty=-2,
             function_call="none",
@@ -499,14 +515,20 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
                 "type": "content",
             },
             presence_penalty=-2,
-            reasoning_effort="low",
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
+            reasoning_effort="none",
             response_format={"type": "text"},
+            safety_identifier="safety-identifier-1234",
             seed=-9007199254740991,
             service_tier="auto",
             stop="\n",
             store=True,
             stream=False,
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             temperature=1,
             tool_choice="none",
             tools=[
@@ -523,6 +545,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
             top_logprobs=0,
             top_p=1,
             user="user-1234",
+            verbosity="low",
             web_search_options={
                 "search_context_size": "low",
                 "user_location": {
@@ -602,7 +625,7 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
             stream=True,
             audio={
                 "format": "wav",
-                "voice": "alloy",
+                "voice": "ash",
             },
             frequency_penalty=-2,
             function_call="none",
@@ -626,13 +649,19 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
                 "type": "content",
             },
             presence_penalty=-2,
-            reasoning_effort="low",
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
+            reasoning_effort="none",
             response_format={"type": "text"},
+            safety_identifier="safety-identifier-1234",
             seed=-9007199254740991,
             service_tier="auto",
             stop="\n",
             store=True,
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             temperature=1,
             tool_choice="none",
             tools=[
@@ -649,6 +678,7 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
             top_logprobs=0,
             top_p=1,
             user="user-1234",
+            verbosity="low",
             web_search_options={
                 "search_context_size": "low",
                 "user_location": {
diff --git a/tests/api_resources/containers/__init__.py b/tests/api_resources/containers/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/containers/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/containers/files/__init__.py b/tests/api_resources/containers/files/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/containers/files/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/containers/files/test_content.py b/tests/api_resources/containers/files/test_content.py
new file mode 100644
index 0000000000..67fcdca36c
--- /dev/null
+++ b/tests/api_resources/containers/files/test_content.py
@@ -0,0 +1,154 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import httpx
+import pytest
+from respx import MockRouter
+
+import openai._legacy_response as _legacy_response
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+
+# pyright: reportDeprecated=false
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestContent:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_method_retrieve(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/containers/container_id/files/file_id/content").mock(
+            return_value=httpx.Response(200, json={"foo": "bar"})
+        )
+        content = client.containers.files.content.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+        assert isinstance(content, _legacy_response.HttpxBinaryResponseContent)
+        assert content.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_raw_response_retrieve(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/containers/container_id/files/file_id/content").mock(
+            return_value=httpx.Response(200, json={"foo": "bar"})
+        )
+
+        response = client.containers.files.content.with_raw_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        content = response.parse()
+        assert_matches_type(_legacy_response.HttpxBinaryResponseContent, content, path=["response"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_streaming_response_retrieve(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/containers/container_id/files/file_id/content").mock(
+            return_value=httpx.Response(200, json={"foo": "bar"})
+        )
+        with client.containers.files.content.with_streaming_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            content = response.parse()
+            assert_matches_type(bytes, content, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            client.containers.files.content.with_raw_response.retrieve(
+                file_id="file_id",
+                container_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `file_id` but received ''"):
+            client.containers.files.content.with_raw_response.retrieve(
+                file_id="",
+                container_id="container_id",
+            )
+
+
+class TestAsyncContent:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_method_retrieve(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/containers/container_id/files/file_id/content").mock(
+            return_value=httpx.Response(200, json={"foo": "bar"})
+        )
+        content = await async_client.containers.files.content.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+        assert isinstance(content, _legacy_response.HttpxBinaryResponseContent)
+        assert content.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/containers/container_id/files/file_id/content").mock(
+            return_value=httpx.Response(200, json={"foo": "bar"})
+        )
+
+        response = await async_client.containers.files.content.with_raw_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        content = response.parse()
+        assert_matches_type(_legacy_response.HttpxBinaryResponseContent, content, path=["response"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/containers/container_id/files/file_id/content").mock(
+            return_value=httpx.Response(200, json={"foo": "bar"})
+        )
+        async with async_client.containers.files.content.with_streaming_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            content = await response.parse()
+            assert_matches_type(bytes, content, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            await async_client.containers.files.content.with_raw_response.retrieve(
+                file_id="file_id",
+                container_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `file_id` but received ''"):
+            await async_client.containers.files.content.with_raw_response.retrieve(
+                file_id="",
+                container_id="container_id",
+            )
diff --git a/tests/api_resources/containers/test_files.py b/tests/api_resources/containers/test_files.py
new file mode 100644
index 0000000000..f9d82d005c
--- /dev/null
+++ b/tests/api_resources/containers/test_files.py
@@ -0,0 +1,411 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.pagination import SyncCursorPage, AsyncCursorPage
+from openai.types.containers import (
+    FileListResponse,
+    FileCreateResponse,
+    FileRetrieveResponse,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestFiles:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        file = client.containers.files.create(
+            container_id="container_id",
+        )
+        assert_matches_type(FileCreateResponse, file, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        file = client.containers.files.create(
+            container_id="container_id",
+            file=b"raw file contents",
+            file_id="file_id",
+        )
+        assert_matches_type(FileCreateResponse, file, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.containers.files.with_raw_response.create(
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert_matches_type(FileCreateResponse, file, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.containers.files.with_streaming_response.create(
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = response.parse()
+            assert_matches_type(FileCreateResponse, file, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_create(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            client.containers.files.with_raw_response.create(
+                container_id="",
+            )
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        file = client.containers.files.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+        assert_matches_type(FileRetrieveResponse, file, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.containers.files.with_raw_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert_matches_type(FileRetrieveResponse, file, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.containers.files.with_streaming_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = response.parse()
+            assert_matches_type(FileRetrieveResponse, file, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            client.containers.files.with_raw_response.retrieve(
+                file_id="file_id",
+                container_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `file_id` but received ''"):
+            client.containers.files.with_raw_response.retrieve(
+                file_id="",
+                container_id="container_id",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        file = client.containers.files.list(
+            container_id="container_id",
+        )
+        assert_matches_type(SyncCursorPage[FileListResponse], file, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        file = client.containers.files.list(
+            container_id="container_id",
+            after="after",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(SyncCursorPage[FileListResponse], file, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.containers.files.with_raw_response.list(
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert_matches_type(SyncCursorPage[FileListResponse], file, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.containers.files.with_streaming_response.list(
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = response.parse()
+            assert_matches_type(SyncCursorPage[FileListResponse], file, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_list(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            client.containers.files.with_raw_response.list(
+                container_id="",
+            )
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        file = client.containers.files.delete(
+            file_id="file_id",
+            container_id="container_id",
+        )
+        assert file is None
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.containers.files.with_raw_response.delete(
+            file_id="file_id",
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert file is None
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.containers.files.with_streaming_response.delete(
+            file_id="file_id",
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = response.parse()
+            assert file is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            client.containers.files.with_raw_response.delete(
+                file_id="file_id",
+                container_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `file_id` but received ''"):
+            client.containers.files.with_raw_response.delete(
+                file_id="",
+                container_id="container_id",
+            )
+
+
+class TestAsyncFiles:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        file = await async_client.containers.files.create(
+            container_id="container_id",
+        )
+        assert_matches_type(FileCreateResponse, file, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        file = await async_client.containers.files.create(
+            container_id="container_id",
+            file=b"raw file contents",
+            file_id="file_id",
+        )
+        assert_matches_type(FileCreateResponse, file, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.files.with_raw_response.create(
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert_matches_type(FileCreateResponse, file, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.files.with_streaming_response.create(
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = await response.parse()
+            assert_matches_type(FileCreateResponse, file, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_create(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            await async_client.containers.files.with_raw_response.create(
+                container_id="",
+            )
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        file = await async_client.containers.files.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+        assert_matches_type(FileRetrieveResponse, file, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.files.with_raw_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert_matches_type(FileRetrieveResponse, file, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.files.with_streaming_response.retrieve(
+            file_id="file_id",
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = await response.parse()
+            assert_matches_type(FileRetrieveResponse, file, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            await async_client.containers.files.with_raw_response.retrieve(
+                file_id="file_id",
+                container_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `file_id` but received ''"):
+            await async_client.containers.files.with_raw_response.retrieve(
+                file_id="",
+                container_id="container_id",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        file = await async_client.containers.files.list(
+            container_id="container_id",
+        )
+        assert_matches_type(AsyncCursorPage[FileListResponse], file, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        file = await async_client.containers.files.list(
+            container_id="container_id",
+            after="after",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(AsyncCursorPage[FileListResponse], file, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.files.with_raw_response.list(
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert_matches_type(AsyncCursorPage[FileListResponse], file, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.files.with_streaming_response.list(
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = await response.parse()
+            assert_matches_type(AsyncCursorPage[FileListResponse], file, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            await async_client.containers.files.with_raw_response.list(
+                container_id="",
+            )
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        file = await async_client.containers.files.delete(
+            file_id="file_id",
+            container_id="container_id",
+        )
+        assert file is None
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.files.with_raw_response.delete(
+            file_id="file_id",
+            container_id="container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        file = response.parse()
+        assert file is None
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.files.with_streaming_response.delete(
+            file_id="file_id",
+            container_id="container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            file = await response.parse()
+            assert file is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            await async_client.containers.files.with_raw_response.delete(
+                file_id="file_id",
+                container_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `file_id` but received ''"):
+            await async_client.containers.files.with_raw_response.delete(
+                file_id="",
+                container_id="container_id",
+            )
diff --git a/tests/api_resources/conversations/__init__.py b/tests/api_resources/conversations/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/conversations/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/conversations/test_items.py b/tests/api_resources/conversations/test_items.py
new file mode 100644
index 0000000000..0503301f16
--- /dev/null
+++ b/tests/api_resources/conversations/test_items.py
@@ -0,0 +1,499 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.pagination import SyncConversationCursorPage, AsyncConversationCursorPage
+from openai.types.conversations import (
+    Conversation,
+    ConversationItem,
+    ConversationItemList,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestItems:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        item = client.conversations.items.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+        )
+        assert_matches_type(ConversationItemList, item, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        item = client.conversations.items.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+            include=["file_search_call.results"],
+        )
+        assert_matches_type(ConversationItemList, item, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.conversations.items.with_raw_response.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(ConversationItemList, item, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.conversations.items.with_streaming_response.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = response.parse()
+            assert_matches_type(ConversationItemList, item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_create(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            client.conversations.items.with_raw_response.create(
+                conversation_id="",
+                items=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "type": "message",
+                    }
+                ],
+            )
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        item = client.conversations.items.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+        assert_matches_type(ConversationItem, item, path=["response"])
+
+    @parametrize
+    def test_method_retrieve_with_all_params(self, client: OpenAI) -> None:
+        item = client.conversations.items.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+            include=["file_search_call.results"],
+        )
+        assert_matches_type(ConversationItem, item, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.conversations.items.with_raw_response.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(ConversationItem, item, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.conversations.items.with_streaming_response.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = response.parse()
+            assert_matches_type(ConversationItem, item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            client.conversations.items.with_raw_response.retrieve(
+                item_id="msg_abc",
+                conversation_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `item_id` but received ''"):
+            client.conversations.items.with_raw_response.retrieve(
+                item_id="",
+                conversation_id="conv_123",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        item = client.conversations.items.list(
+            conversation_id="conv_123",
+        )
+        assert_matches_type(SyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        item = client.conversations.items.list(
+            conversation_id="conv_123",
+            after="after",
+            include=["file_search_call.results"],
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(SyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.conversations.items.with_raw_response.list(
+            conversation_id="conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(SyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.conversations.items.with_streaming_response.list(
+            conversation_id="conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = response.parse()
+            assert_matches_type(SyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_list(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            client.conversations.items.with_raw_response.list(
+                conversation_id="",
+            )
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        item = client.conversations.items.delete(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+        assert_matches_type(Conversation, item, path=["response"])
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.conversations.items.with_raw_response.delete(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(Conversation, item, path=["response"])
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.conversations.items.with_streaming_response.delete(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = response.parse()
+            assert_matches_type(Conversation, item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            client.conversations.items.with_raw_response.delete(
+                item_id="msg_abc",
+                conversation_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `item_id` but received ''"):
+            client.conversations.items.with_raw_response.delete(
+                item_id="",
+                conversation_id="conv_123",
+            )
+
+
+class TestAsyncItems:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        item = await async_client.conversations.items.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+        )
+        assert_matches_type(ConversationItemList, item, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        item = await async_client.conversations.items.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+            include=["file_search_call.results"],
+        )
+        assert_matches_type(ConversationItemList, item, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.items.with_raw_response.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(ConversationItemList, item, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.items.with_streaming_response.create(
+            conversation_id="conv_123",
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = await response.parse()
+            assert_matches_type(ConversationItemList, item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_create(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            await async_client.conversations.items.with_raw_response.create(
+                conversation_id="",
+                items=[
+                    {
+                        "content": "string",
+                        "role": "user",
+                        "type": "message",
+                    }
+                ],
+            )
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        item = await async_client.conversations.items.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+        assert_matches_type(ConversationItem, item, path=["response"])
+
+    @parametrize
+    async def test_method_retrieve_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        item = await async_client.conversations.items.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+            include=["file_search_call.results"],
+        )
+        assert_matches_type(ConversationItem, item, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.items.with_raw_response.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(ConversationItem, item, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.items.with_streaming_response.retrieve(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = await response.parse()
+            assert_matches_type(ConversationItem, item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            await async_client.conversations.items.with_raw_response.retrieve(
+                item_id="msg_abc",
+                conversation_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `item_id` but received ''"):
+            await async_client.conversations.items.with_raw_response.retrieve(
+                item_id="",
+                conversation_id="conv_123",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        item = await async_client.conversations.items.list(
+            conversation_id="conv_123",
+        )
+        assert_matches_type(AsyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        item = await async_client.conversations.items.list(
+            conversation_id="conv_123",
+            after="after",
+            include=["file_search_call.results"],
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(AsyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.items.with_raw_response.list(
+            conversation_id="conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(AsyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.items.with_streaming_response.list(
+            conversation_id="conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = await response.parse()
+            assert_matches_type(AsyncConversationCursorPage[ConversationItem], item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            await async_client.conversations.items.with_raw_response.list(
+                conversation_id="",
+            )
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        item = await async_client.conversations.items.delete(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+        assert_matches_type(Conversation, item, path=["response"])
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.items.with_raw_response.delete(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        item = response.parse()
+        assert_matches_type(Conversation, item, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.items.with_streaming_response.delete(
+            item_id="msg_abc",
+            conversation_id="conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            item = await response.parse()
+            assert_matches_type(Conversation, item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            await async_client.conversations.items.with_raw_response.delete(
+                item_id="msg_abc",
+                conversation_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `item_id` but received ''"):
+            await async_client.conversations.items.with_raw_response.delete(
+                item_id="",
+                conversation_id="conv_123",
+            )
diff --git a/tests/api_resources/evals/__init__.py b/tests/api_resources/evals/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/evals/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/evals/runs/__init__.py b/tests/api_resources/evals/runs/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/evals/runs/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/evals/runs/test_output_items.py b/tests/api_resources/evals/runs/test_output_items.py
new file mode 100644
index 0000000000..673867ac42
--- /dev/null
+++ b/tests/api_resources/evals/runs/test_output_items.py
@@ -0,0 +1,265 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.pagination import SyncCursorPage, AsyncCursorPage
+from openai.types.evals.runs import OutputItemListResponse, OutputItemRetrieveResponse
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestOutputItems:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        output_item = client.evals.runs.output_items.retrieve(
+            output_item_id="output_item_id",
+            eval_id="eval_id",
+            run_id="run_id",
+        )
+        assert_matches_type(OutputItemRetrieveResponse, output_item, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.evals.runs.output_items.with_raw_response.retrieve(
+            output_item_id="output_item_id",
+            eval_id="eval_id",
+            run_id="run_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        output_item = response.parse()
+        assert_matches_type(OutputItemRetrieveResponse, output_item, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.evals.runs.output_items.with_streaming_response.retrieve(
+            output_item_id="output_item_id",
+            eval_id="eval_id",
+            run_id="run_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            output_item = response.parse()
+            assert_matches_type(OutputItemRetrieveResponse, output_item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.runs.output_items.with_raw_response.retrieve(
+                output_item_id="output_item_id",
+                eval_id="",
+                run_id="run_id",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            client.evals.runs.output_items.with_raw_response.retrieve(
+                output_item_id="output_item_id",
+                eval_id="eval_id",
+                run_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `output_item_id` but received ''"):
+            client.evals.runs.output_items.with_raw_response.retrieve(
+                output_item_id="",
+                eval_id="eval_id",
+                run_id="run_id",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        output_item = client.evals.runs.output_items.list(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(SyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        output_item = client.evals.runs.output_items.list(
+            run_id="run_id",
+            eval_id="eval_id",
+            after="after",
+            limit=0,
+            order="asc",
+            status="fail",
+        )
+        assert_matches_type(SyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.evals.runs.output_items.with_raw_response.list(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        output_item = response.parse()
+        assert_matches_type(SyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.evals.runs.output_items.with_streaming_response.list(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            output_item = response.parse()
+            assert_matches_type(SyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_list(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.runs.output_items.with_raw_response.list(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            client.evals.runs.output_items.with_raw_response.list(
+                run_id="",
+                eval_id="eval_id",
+            )
+
+
+class TestAsyncOutputItems:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        output_item = await async_client.evals.runs.output_items.retrieve(
+            output_item_id="output_item_id",
+            eval_id="eval_id",
+            run_id="run_id",
+        )
+        assert_matches_type(OutputItemRetrieveResponse, output_item, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.runs.output_items.with_raw_response.retrieve(
+            output_item_id="output_item_id",
+            eval_id="eval_id",
+            run_id="run_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        output_item = response.parse()
+        assert_matches_type(OutputItemRetrieveResponse, output_item, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.runs.output_items.with_streaming_response.retrieve(
+            output_item_id="output_item_id",
+            eval_id="eval_id",
+            run_id="run_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            output_item = await response.parse()
+            assert_matches_type(OutputItemRetrieveResponse, output_item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.runs.output_items.with_raw_response.retrieve(
+                output_item_id="output_item_id",
+                eval_id="",
+                run_id="run_id",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            await async_client.evals.runs.output_items.with_raw_response.retrieve(
+                output_item_id="output_item_id",
+                eval_id="eval_id",
+                run_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `output_item_id` but received ''"):
+            await async_client.evals.runs.output_items.with_raw_response.retrieve(
+                output_item_id="",
+                eval_id="eval_id",
+                run_id="run_id",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        output_item = await async_client.evals.runs.output_items.list(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(AsyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        output_item = await async_client.evals.runs.output_items.list(
+            run_id="run_id",
+            eval_id="eval_id",
+            after="after",
+            limit=0,
+            order="asc",
+            status="fail",
+        )
+        assert_matches_type(AsyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.runs.output_items.with_raw_response.list(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        output_item = response.parse()
+        assert_matches_type(AsyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.runs.output_items.with_streaming_response.list(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            output_item = await response.parse()
+            assert_matches_type(AsyncCursorPage[OutputItemListResponse], output_item, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.runs.output_items.with_raw_response.list(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            await async_client.evals.runs.output_items.with_raw_response.list(
+                run_id="",
+                eval_id="eval_id",
+            )
diff --git a/tests/api_resources/evals/test_runs.py b/tests/api_resources/evals/test_runs.py
new file mode 100644
index 0000000000..1367cb4bab
--- /dev/null
+++ b/tests/api_resources/evals/test_runs.py
@@ -0,0 +1,591 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.pagination import SyncCursorPage, AsyncCursorPage
+from openai.types.evals import (
+    RunListResponse,
+    RunCancelResponse,
+    RunCreateResponse,
+    RunDeleteResponse,
+    RunRetrieveResponse,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestRuns:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        run = client.evals.runs.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [{"item": {"foo": "bar"}}],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+        )
+        assert_matches_type(RunCreateResponse, run, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        run = client.evals.runs.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [
+                        {
+                            "item": {"foo": "bar"},
+                            "sample": {"foo": "bar"},
+                        }
+                    ],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+            metadata={"foo": "string"},
+            name="name",
+        )
+        assert_matches_type(RunCreateResponse, run, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.evals.runs.with_raw_response.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [{"item": {"foo": "bar"}}],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunCreateResponse, run, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.evals.runs.with_streaming_response.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [{"item": {"foo": "bar"}}],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = response.parse()
+            assert_matches_type(RunCreateResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_create(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.runs.with_raw_response.create(
+                eval_id="",
+                data_source={
+                    "source": {
+                        "content": [{"item": {"foo": "bar"}}],
+                        "type": "file_content",
+                    },
+                    "type": "jsonl",
+                },
+            )
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        run = client.evals.runs.retrieve(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(RunRetrieveResponse, run, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.evals.runs.with_raw_response.retrieve(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunRetrieveResponse, run, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.evals.runs.with_streaming_response.retrieve(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = response.parse()
+            assert_matches_type(RunRetrieveResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.runs.with_raw_response.retrieve(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            client.evals.runs.with_raw_response.retrieve(
+                run_id="",
+                eval_id="eval_id",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        run = client.evals.runs.list(
+            eval_id="eval_id",
+        )
+        assert_matches_type(SyncCursorPage[RunListResponse], run, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        run = client.evals.runs.list(
+            eval_id="eval_id",
+            after="after",
+            limit=0,
+            order="asc",
+            status="queued",
+        )
+        assert_matches_type(SyncCursorPage[RunListResponse], run, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.evals.runs.with_raw_response.list(
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(SyncCursorPage[RunListResponse], run, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.evals.runs.with_streaming_response.list(
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = response.parse()
+            assert_matches_type(SyncCursorPage[RunListResponse], run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_list(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.runs.with_raw_response.list(
+                eval_id="",
+            )
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        run = client.evals.runs.delete(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(RunDeleteResponse, run, path=["response"])
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.evals.runs.with_raw_response.delete(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunDeleteResponse, run, path=["response"])
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.evals.runs.with_streaming_response.delete(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = response.parse()
+            assert_matches_type(RunDeleteResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.runs.with_raw_response.delete(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            client.evals.runs.with_raw_response.delete(
+                run_id="",
+                eval_id="eval_id",
+            )
+
+    @parametrize
+    def test_method_cancel(self, client: OpenAI) -> None:
+        run = client.evals.runs.cancel(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(RunCancelResponse, run, path=["response"])
+
+    @parametrize
+    def test_raw_response_cancel(self, client: OpenAI) -> None:
+        response = client.evals.runs.with_raw_response.cancel(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunCancelResponse, run, path=["response"])
+
+    @parametrize
+    def test_streaming_response_cancel(self, client: OpenAI) -> None:
+        with client.evals.runs.with_streaming_response.cancel(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = response.parse()
+            assert_matches_type(RunCancelResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_cancel(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.runs.with_raw_response.cancel(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            client.evals.runs.with_raw_response.cancel(
+                run_id="",
+                eval_id="eval_id",
+            )
+
+
+class TestAsyncRuns:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        run = await async_client.evals.runs.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [{"item": {"foo": "bar"}}],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+        )
+        assert_matches_type(RunCreateResponse, run, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        run = await async_client.evals.runs.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [
+                        {
+                            "item": {"foo": "bar"},
+                            "sample": {"foo": "bar"},
+                        }
+                    ],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+            metadata={"foo": "string"},
+            name="name",
+        )
+        assert_matches_type(RunCreateResponse, run, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.runs.with_raw_response.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [{"item": {"foo": "bar"}}],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunCreateResponse, run, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.runs.with_streaming_response.create(
+            eval_id="eval_id",
+            data_source={
+                "source": {
+                    "content": [{"item": {"foo": "bar"}}],
+                    "type": "file_content",
+                },
+                "type": "jsonl",
+            },
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = await response.parse()
+            assert_matches_type(RunCreateResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_create(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.create(
+                eval_id="",
+                data_source={
+                    "source": {
+                        "content": [{"item": {"foo": "bar"}}],
+                        "type": "file_content",
+                    },
+                    "type": "jsonl",
+                },
+            )
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        run = await async_client.evals.runs.retrieve(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(RunRetrieveResponse, run, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.runs.with_raw_response.retrieve(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunRetrieveResponse, run, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.runs.with_streaming_response.retrieve(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = await response.parse()
+            assert_matches_type(RunRetrieveResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.retrieve(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.retrieve(
+                run_id="",
+                eval_id="eval_id",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        run = await async_client.evals.runs.list(
+            eval_id="eval_id",
+        )
+        assert_matches_type(AsyncCursorPage[RunListResponse], run, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        run = await async_client.evals.runs.list(
+            eval_id="eval_id",
+            after="after",
+            limit=0,
+            order="asc",
+            status="queued",
+        )
+        assert_matches_type(AsyncCursorPage[RunListResponse], run, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.runs.with_raw_response.list(
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(AsyncCursorPage[RunListResponse], run, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.runs.with_streaming_response.list(
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = await response.parse()
+            assert_matches_type(AsyncCursorPage[RunListResponse], run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_list(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.list(
+                eval_id="",
+            )
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        run = await async_client.evals.runs.delete(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(RunDeleteResponse, run, path=["response"])
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.runs.with_raw_response.delete(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunDeleteResponse, run, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.runs.with_streaming_response.delete(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = await response.parse()
+            assert_matches_type(RunDeleteResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.delete(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.delete(
+                run_id="",
+                eval_id="eval_id",
+            )
+
+    @parametrize
+    async def test_method_cancel(self, async_client: AsyncOpenAI) -> None:
+        run = await async_client.evals.runs.cancel(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+        assert_matches_type(RunCancelResponse, run, path=["response"])
+
+    @parametrize
+    async def test_raw_response_cancel(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.runs.with_raw_response.cancel(
+            run_id="run_id",
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        run = response.parse()
+        assert_matches_type(RunCancelResponse, run, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_cancel(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.runs.with_streaming_response.cancel(
+            run_id="run_id",
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            run = await response.parse()
+            assert_matches_type(RunCancelResponse, run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_cancel(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.cancel(
+                run_id="run_id",
+                eval_id="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `run_id` but received ''"):
+            await async_client.evals.runs.with_raw_response.cancel(
+                run_id="",
+                eval_id="eval_id",
+            )
diff --git a/tests/api_resources/fine_tuning/alpha/__init__.py b/tests/api_resources/fine_tuning/alpha/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/fine_tuning/alpha/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/fine_tuning/alpha/test_graders.py b/tests/api_resources/fine_tuning/alpha/test_graders.py
new file mode 100644
index 0000000000..4a237114b6
--- /dev/null
+++ b/tests/api_resources/fine_tuning/alpha/test_graders.py
@@ -0,0 +1,285 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types.fine_tuning.alpha import (
+    GraderRunResponse,
+    GraderValidateResponse,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestGraders:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_run(self, client: OpenAI) -> None:
+        grader = client.fine_tuning.alpha.graders.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+        )
+        assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+    @parametrize
+    def test_method_run_with_all_params(self, client: OpenAI) -> None:
+        grader = client.fine_tuning.alpha.graders.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+            item={},
+        )
+        assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+    @parametrize
+    def test_raw_response_run(self, client: OpenAI) -> None:
+        response = client.fine_tuning.alpha.graders.with_raw_response.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        grader = response.parse()
+        assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+    @parametrize
+    def test_streaming_response_run(self, client: OpenAI) -> None:
+        with client.fine_tuning.alpha.graders.with_streaming_response.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            grader = response.parse()
+            assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_validate(self, client: OpenAI) -> None:
+        grader = client.fine_tuning.alpha.graders.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        )
+        assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+    @parametrize
+    def test_method_validate_with_all_params(self, client: OpenAI) -> None:
+        grader = client.fine_tuning.alpha.graders.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        )
+        assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+    @parametrize
+    def test_raw_response_validate(self, client: OpenAI) -> None:
+        response = client.fine_tuning.alpha.graders.with_raw_response.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        grader = response.parse()
+        assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+    @parametrize
+    def test_streaming_response_validate(self, client: OpenAI) -> None:
+        with client.fine_tuning.alpha.graders.with_streaming_response.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            grader = response.parse()
+            assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+
+class TestAsyncGraders:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_run(self, async_client: AsyncOpenAI) -> None:
+        grader = await async_client.fine_tuning.alpha.graders.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+        )
+        assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+    @parametrize
+    async def test_method_run_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        grader = await async_client.fine_tuning.alpha.graders.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+            item={},
+        )
+        assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+    @parametrize
+    async def test_raw_response_run(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.fine_tuning.alpha.graders.with_raw_response.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        grader = response.parse()
+        assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_run(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.fine_tuning.alpha.graders.with_streaming_response.run(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+            model_sample="model_sample",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            grader = await response.parse()
+            assert_matches_type(GraderRunResponse, grader, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_validate(self, async_client: AsyncOpenAI) -> None:
+        grader = await async_client.fine_tuning.alpha.graders.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        )
+        assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+    @parametrize
+    async def test_method_validate_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        grader = await async_client.fine_tuning.alpha.graders.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        )
+        assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+    @parametrize
+    async def test_raw_response_validate(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.fine_tuning.alpha.graders.with_raw_response.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        grader = response.parse()
+        assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_validate(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.fine_tuning.alpha.graders.with_streaming_response.validate(
+            grader={
+                "input": "input",
+                "name": "name",
+                "operation": "eq",
+                "reference": "reference",
+                "type": "string_check",
+            },
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            grader = await response.parse()
+            assert_matches_type(GraderValidateResponse, grader, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/fine_tuning/checkpoints/__init__.py b/tests/api_resources/fine_tuning/checkpoints/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/fine_tuning/checkpoints/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/fine_tuning/checkpoints/test_permissions.py b/tests/api_resources/fine_tuning/checkpoints/test_permissions.py
new file mode 100644
index 0000000000..9420e3a34c
--- /dev/null
+++ b/tests/api_resources/fine_tuning/checkpoints/test_permissions.py
@@ -0,0 +1,319 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.pagination import SyncPage, AsyncPage
+from openai.types.fine_tuning.checkpoints import (
+    PermissionCreateResponse,
+    PermissionDeleteResponse,
+    PermissionRetrieveResponse,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestPermissions:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        permission = client.fine_tuning.checkpoints.permissions.create(
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            project_ids=["string"],
+        )
+        assert_matches_type(SyncPage[PermissionCreateResponse], permission, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.fine_tuning.checkpoints.permissions.with_raw_response.create(
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            project_ids=["string"],
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        permission = response.parse()
+        assert_matches_type(SyncPage[PermissionCreateResponse], permission, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.fine_tuning.checkpoints.permissions.with_streaming_response.create(
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            project_ids=["string"],
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            permission = response.parse()
+            assert_matches_type(SyncPage[PermissionCreateResponse], permission, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_create(self, client: OpenAI) -> None:
+        with pytest.raises(
+            ValueError, match=r"Expected a non-empty value for `fine_tuned_model_checkpoint` but received ''"
+        ):
+            client.fine_tuning.checkpoints.permissions.with_raw_response.create(
+                fine_tuned_model_checkpoint="",
+                project_ids=["string"],
+            )
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        permission = client.fine_tuning.checkpoints.permissions.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+        assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+    @parametrize
+    def test_method_retrieve_with_all_params(self, client: OpenAI) -> None:
+        permission = client.fine_tuning.checkpoints.permissions.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+            after="after",
+            limit=0,
+            order="ascending",
+            project_id="project_id",
+        )
+        assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.fine_tuning.checkpoints.permissions.with_raw_response.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        permission = response.parse()
+        assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.fine_tuning.checkpoints.permissions.with_streaming_response.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            permission = response.parse()
+            assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(
+            ValueError, match=r"Expected a non-empty value for `fine_tuned_model_checkpoint` but received ''"
+        ):
+            client.fine_tuning.checkpoints.permissions.with_raw_response.retrieve(
+                fine_tuned_model_checkpoint="",
+            )
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        permission = client.fine_tuning.checkpoints.permissions.delete(
+            permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+        )
+        assert_matches_type(PermissionDeleteResponse, permission, path=["response"])
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.fine_tuning.checkpoints.permissions.with_raw_response.delete(
+            permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        permission = response.parse()
+        assert_matches_type(PermissionDeleteResponse, permission, path=["response"])
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.fine_tuning.checkpoints.permissions.with_streaming_response.delete(
+            permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            permission = response.parse()
+            assert_matches_type(PermissionDeleteResponse, permission, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(
+            ValueError, match=r"Expected a non-empty value for `fine_tuned_model_checkpoint` but received ''"
+        ):
+            client.fine_tuning.checkpoints.permissions.with_raw_response.delete(
+                permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+                fine_tuned_model_checkpoint="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `permission_id` but received ''"):
+            client.fine_tuning.checkpoints.permissions.with_raw_response.delete(
+                permission_id="",
+                fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            )
+
+
+class TestAsyncPermissions:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        permission = await async_client.fine_tuning.checkpoints.permissions.create(
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            project_ids=["string"],
+        )
+        assert_matches_type(AsyncPage[PermissionCreateResponse], permission, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.fine_tuning.checkpoints.permissions.with_raw_response.create(
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            project_ids=["string"],
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        permission = response.parse()
+        assert_matches_type(AsyncPage[PermissionCreateResponse], permission, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.fine_tuning.checkpoints.permissions.with_streaming_response.create(
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            project_ids=["string"],
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            permission = await response.parse()
+            assert_matches_type(AsyncPage[PermissionCreateResponse], permission, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_create(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(
+            ValueError, match=r"Expected a non-empty value for `fine_tuned_model_checkpoint` but received ''"
+        ):
+            await async_client.fine_tuning.checkpoints.permissions.with_raw_response.create(
+                fine_tuned_model_checkpoint="",
+                project_ids=["string"],
+            )
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        permission = await async_client.fine_tuning.checkpoints.permissions.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+        assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+    @parametrize
+    async def test_method_retrieve_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        permission = await async_client.fine_tuning.checkpoints.permissions.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+            after="after",
+            limit=0,
+            order="ascending",
+            project_id="project_id",
+        )
+        assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.fine_tuning.checkpoints.permissions.with_raw_response.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        permission = response.parse()
+        assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.fine_tuning.checkpoints.permissions.with_streaming_response.retrieve(
+            fine_tuned_model_checkpoint="ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            permission = await response.parse()
+            assert_matches_type(PermissionRetrieveResponse, permission, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(
+            ValueError, match=r"Expected a non-empty value for `fine_tuned_model_checkpoint` but received ''"
+        ):
+            await async_client.fine_tuning.checkpoints.permissions.with_raw_response.retrieve(
+                fine_tuned_model_checkpoint="",
+            )
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        permission = await async_client.fine_tuning.checkpoints.permissions.delete(
+            permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+        )
+        assert_matches_type(PermissionDeleteResponse, permission, path=["response"])
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.fine_tuning.checkpoints.permissions.with_raw_response.delete(
+            permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        permission = response.parse()
+        assert_matches_type(PermissionDeleteResponse, permission, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.fine_tuning.checkpoints.permissions.with_streaming_response.delete(
+            permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+            fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            permission = await response.parse()
+            assert_matches_type(PermissionDeleteResponse, permission, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(
+            ValueError, match=r"Expected a non-empty value for `fine_tuned_model_checkpoint` but received ''"
+        ):
+            await async_client.fine_tuning.checkpoints.permissions.with_raw_response.delete(
+                permission_id="cp_zc4Q7MP6XxulcVzj4MZdwsAB",
+                fine_tuned_model_checkpoint="",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `permission_id` but received ''"):
+            await async_client.fine_tuning.checkpoints.permissions.with_raw_response.delete(
+                permission_id="",
+                fine_tuned_model_checkpoint="ft:gpt-4o-mini-2024-07-18:org:weather:B7R9VjQd",
+            )
diff --git a/tests/api_resources/fine_tuning/jobs/test_checkpoints.py b/tests/api_resources/fine_tuning/jobs/test_checkpoints.py
index 915d5c6f63..bb11529263 100644
--- a/tests/api_resources/fine_tuning/jobs/test_checkpoints.py
+++ b/tests/api_resources/fine_tuning/jobs/test_checkpoints.py
@@ -67,7 +67,9 @@ def test_path_params_list(self, client: OpenAI) -> None:
 
 
 class TestAsyncCheckpoints:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_list(self, async_client: AsyncOpenAI) -> None:
diff --git a/tests/api_resources/fine_tuning/test_jobs.py b/tests/api_resources/fine_tuning/test_jobs.py
index 75f72f9d09..8a35255885 100644
--- a/tests/api_resources/fine_tuning/test_jobs.py
+++ b/tests/api_resources/fine_tuning/test_jobs.py
@@ -52,6 +52,7 @@ def test_method_create_with_all_params(self, client: OpenAI) -> None:
             ],
             metadata={"foo": "string"},
             method={
+                "type": "supervised",
                 "dpo": {
                     "hyperparameters": {
                         "batch_size": "auto",
@@ -60,6 +61,24 @@ def test_method_create_with_all_params(self, client: OpenAI) -> None:
                         "n_epochs": "auto",
                     }
                 },
+                "reinforcement": {
+                    "grader": {
+                        "input": "input",
+                        "name": "name",
+                        "operation": "eq",
+                        "reference": "reference",
+                        "type": "string_check",
+                    },
+                    "hyperparameters": {
+                        "batch_size": "auto",
+                        "compute_multiplier": "auto",
+                        "eval_interval": "auto",
+                        "eval_samples": "auto",
+                        "learning_rate_multiplier": "auto",
+                        "n_epochs": "auto",
+                        "reasoning_effort": "default",
+                    },
+                },
                 "supervised": {
                     "hyperparameters": {
                         "batch_size": "auto",
@@ -67,7 +86,6 @@ def test_method_create_with_all_params(self, client: OpenAI) -> None:
                         "n_epochs": "auto",
                     }
                 },
-                "type": "supervised",
             },
             seed=42,
             suffix="x",
@@ -258,9 +276,87 @@ def test_path_params_list_events(self, client: OpenAI) -> None:
                 "",
             )
 
+    @parametrize
+    def test_method_pause(self, client: OpenAI) -> None:
+        job = client.fine_tuning.jobs.pause(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    def test_raw_response_pause(self, client: OpenAI) -> None:
+        response = client.fine_tuning.jobs.with_raw_response.pause(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = response.parse()
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    def test_streaming_response_pause(self, client: OpenAI) -> None:
+        with client.fine_tuning.jobs.with_streaming_response.pause(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = response.parse()
+            assert_matches_type(FineTuningJob, job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_pause(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):
+            client.fine_tuning.jobs.with_raw_response.pause(
+                "",
+            )
+
+    @parametrize
+    def test_method_resume(self, client: OpenAI) -> None:
+        job = client.fine_tuning.jobs.resume(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    def test_raw_response_resume(self, client: OpenAI) -> None:
+        response = client.fine_tuning.jobs.with_raw_response.resume(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = response.parse()
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    def test_streaming_response_resume(self, client: OpenAI) -> None:
+        with client.fine_tuning.jobs.with_streaming_response.resume(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = response.parse()
+            assert_matches_type(FineTuningJob, job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_resume(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):
+            client.fine_tuning.jobs.with_raw_response.resume(
+                "",
+            )
+
 
 class TestAsyncJobs:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
@@ -293,6 +389,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) ->
             ],
             metadata={"foo": "string"},
             method={
+                "type": "supervised",
                 "dpo": {
                     "hyperparameters": {
                         "batch_size": "auto",
@@ -301,6 +398,24 @@ async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) ->
                         "n_epochs": "auto",
                     }
                 },
+                "reinforcement": {
+                    "grader": {
+                        "input": "input",
+                        "name": "name",
+                        "operation": "eq",
+                        "reference": "reference",
+                        "type": "string_check",
+                    },
+                    "hyperparameters": {
+                        "batch_size": "auto",
+                        "compute_multiplier": "auto",
+                        "eval_interval": "auto",
+                        "eval_samples": "auto",
+                        "learning_rate_multiplier": "auto",
+                        "n_epochs": "auto",
+                        "reasoning_effort": "default",
+                    },
+                },
                 "supervised": {
                     "hyperparameters": {
                         "batch_size": "auto",
@@ -308,7 +423,6 @@ async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) ->
                         "n_epochs": "auto",
                     }
                 },
-                "type": "supervised",
             },
             seed=42,
             suffix="x",
@@ -498,3 +612,79 @@ async def test_path_params_list_events(self, async_client: AsyncOpenAI) -> None:
             await async_client.fine_tuning.jobs.with_raw_response.list_events(
                 "",
             )
+
+    @parametrize
+    async def test_method_pause(self, async_client: AsyncOpenAI) -> None:
+        job = await async_client.fine_tuning.jobs.pause(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    async def test_raw_response_pause(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.fine_tuning.jobs.with_raw_response.pause(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = response.parse()
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_pause(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.fine_tuning.jobs.with_streaming_response.pause(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = await response.parse()
+            assert_matches_type(FineTuningJob, job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_pause(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):
+            await async_client.fine_tuning.jobs.with_raw_response.pause(
+                "",
+            )
+
+    @parametrize
+    async def test_method_resume(self, async_client: AsyncOpenAI) -> None:
+        job = await async_client.fine_tuning.jobs.resume(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    async def test_raw_response_resume(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.fine_tuning.jobs.with_raw_response.resume(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        job = response.parse()
+        assert_matches_type(FineTuningJob, job, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_resume(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.fine_tuning.jobs.with_streaming_response.resume(
+            "ft-AF1WoRqd3aJAHsqc9NY7iL8F",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            job = await response.parse()
+            assert_matches_type(FineTuningJob, job, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_resume(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):
+            await async_client.fine_tuning.jobs.with_raw_response.resume(
+                "",
+            )
diff --git a/tests/api_resources/realtime/__init__.py b/tests/api_resources/realtime/__init__.py
new file mode 100644
index 0000000000..fd8019a9a1
--- /dev/null
+++ b/tests/api_resources/realtime/__init__.py
@@ -0,0 +1 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
diff --git a/tests/api_resources/realtime/test_calls.py b/tests/api_resources/realtime/test_calls.py
new file mode 100644
index 0000000000..5495a58a4e
--- /dev/null
+++ b/tests/api_resources/realtime/test_calls.py
@@ -0,0 +1,692 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import httpx
+import pytest
+from respx import MockRouter
+
+import openai._legacy_response as _legacy_response
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+
+# pyright: reportDeprecated=false
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestCalls:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_method_create(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        call = client.realtime.calls.create(
+            sdp="sdp",
+        )
+        assert isinstance(call, _legacy_response.HttpxBinaryResponseContent)
+        assert call.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_method_create_with_all_params(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        call = client.realtime.calls.create(
+            sdp="sdp",
+            session={
+                "type": "realtime",
+                "audio": {
+                    "input": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "noise_reduction": {"type": "near_field"},
+                        "transcription": {
+                            "language": "language",
+                            "model": "whisper-1",
+                            "prompt": "prompt",
+                        },
+                        "turn_detection": {
+                            "type": "server_vad",
+                            "create_response": True,
+                            "idle_timeout_ms": 5000,
+                            "interrupt_response": True,
+                            "prefix_padding_ms": 0,
+                            "silence_duration_ms": 0,
+                            "threshold": 0,
+                        },
+                    },
+                    "output": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "speed": 0.25,
+                        "voice": "ash",
+                    },
+                },
+                "include": ["item.input_audio_transcription.logprobs"],
+                "instructions": "instructions",
+                "max_output_tokens": 0,
+                "model": "string",
+                "output_modalities": ["text"],
+                "prompt": {
+                    "id": "id",
+                    "variables": {"foo": "string"},
+                    "version": "version",
+                },
+                "tool_choice": "none",
+                "tools": [
+                    {
+                        "description": "description",
+                        "name": "name",
+                        "parameters": {},
+                        "type": "function",
+                    }
+                ],
+                "tracing": "auto",
+                "truncation": "auto",
+            },
+        )
+        assert isinstance(call, _legacy_response.HttpxBinaryResponseContent)
+        assert call.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_raw_response_create(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+
+        response = client.realtime.calls.with_raw_response.create(
+            sdp="sdp",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert_matches_type(_legacy_response.HttpxBinaryResponseContent, call, path=["response"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_streaming_response_create(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        with client.realtime.calls.with_streaming_response.create(
+            sdp="sdp",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = response.parse()
+            assert_matches_type(bytes, call, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_accept(self, client: OpenAI) -> None:
+        call = client.realtime.calls.accept(
+            call_id="call_id",
+            type="realtime",
+        )
+        assert call is None
+
+    @parametrize
+    def test_method_accept_with_all_params(self, client: OpenAI) -> None:
+        call = client.realtime.calls.accept(
+            call_id="call_id",
+            type="realtime",
+            audio={
+                "input": {
+                    "format": {
+                        "rate": 24000,
+                        "type": "audio/pcm",
+                    },
+                    "noise_reduction": {"type": "near_field"},
+                    "transcription": {
+                        "language": "language",
+                        "model": "whisper-1",
+                        "prompt": "prompt",
+                    },
+                    "turn_detection": {
+                        "type": "server_vad",
+                        "create_response": True,
+                        "idle_timeout_ms": 5000,
+                        "interrupt_response": True,
+                        "prefix_padding_ms": 0,
+                        "silence_duration_ms": 0,
+                        "threshold": 0,
+                    },
+                },
+                "output": {
+                    "format": {
+                        "rate": 24000,
+                        "type": "audio/pcm",
+                    },
+                    "speed": 0.25,
+                    "voice": "ash",
+                },
+            },
+            include=["item.input_audio_transcription.logprobs"],
+            instructions="instructions",
+            max_output_tokens=0,
+            model="string",
+            output_modalities=["text"],
+            prompt={
+                "id": "id",
+                "variables": {"foo": "string"},
+                "version": "version",
+            },
+            tool_choice="none",
+            tools=[
+                {
+                    "description": "description",
+                    "name": "name",
+                    "parameters": {},
+                    "type": "function",
+                }
+            ],
+            tracing="auto",
+            truncation="auto",
+        )
+        assert call is None
+
+    @parametrize
+    def test_raw_response_accept(self, client: OpenAI) -> None:
+        response = client.realtime.calls.with_raw_response.accept(
+            call_id="call_id",
+            type="realtime",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    def test_streaming_response_accept(self, client: OpenAI) -> None:
+        with client.realtime.calls.with_streaming_response.accept(
+            call_id="call_id",
+            type="realtime",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_accept(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            client.realtime.calls.with_raw_response.accept(
+                call_id="",
+                type="realtime",
+            )
+
+    @parametrize
+    def test_method_hangup(self, client: OpenAI) -> None:
+        call = client.realtime.calls.hangup(
+            "call_id",
+        )
+        assert call is None
+
+    @parametrize
+    def test_raw_response_hangup(self, client: OpenAI) -> None:
+        response = client.realtime.calls.with_raw_response.hangup(
+            "call_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    def test_streaming_response_hangup(self, client: OpenAI) -> None:
+        with client.realtime.calls.with_streaming_response.hangup(
+            "call_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_hangup(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            client.realtime.calls.with_raw_response.hangup(
+                "",
+            )
+
+    @parametrize
+    def test_method_refer(self, client: OpenAI) -> None:
+        call = client.realtime.calls.refer(
+            call_id="call_id",
+            target_uri="tel:+14155550123",
+        )
+        assert call is None
+
+    @parametrize
+    def test_raw_response_refer(self, client: OpenAI) -> None:
+        response = client.realtime.calls.with_raw_response.refer(
+            call_id="call_id",
+            target_uri="tel:+14155550123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    def test_streaming_response_refer(self, client: OpenAI) -> None:
+        with client.realtime.calls.with_streaming_response.refer(
+            call_id="call_id",
+            target_uri="tel:+14155550123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_refer(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            client.realtime.calls.with_raw_response.refer(
+                call_id="",
+                target_uri="tel:+14155550123",
+            )
+
+    @parametrize
+    def test_method_reject(self, client: OpenAI) -> None:
+        call = client.realtime.calls.reject(
+            call_id="call_id",
+        )
+        assert call is None
+
+    @parametrize
+    def test_method_reject_with_all_params(self, client: OpenAI) -> None:
+        call = client.realtime.calls.reject(
+            call_id="call_id",
+            status_code=486,
+        )
+        assert call is None
+
+    @parametrize
+    def test_raw_response_reject(self, client: OpenAI) -> None:
+        response = client.realtime.calls.with_raw_response.reject(
+            call_id="call_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    def test_streaming_response_reject(self, client: OpenAI) -> None:
+        with client.realtime.calls.with_streaming_response.reject(
+            call_id="call_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_reject(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            client.realtime.calls.with_raw_response.reject(
+                call_id="",
+            )
+
+
+class TestAsyncCalls:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_method_create(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        call = await async_client.realtime.calls.create(
+            sdp="sdp",
+        )
+        assert isinstance(call, _legacy_response.HttpxBinaryResponseContent)
+        assert call.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        call = await async_client.realtime.calls.create(
+            sdp="sdp",
+            session={
+                "type": "realtime",
+                "audio": {
+                    "input": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "noise_reduction": {"type": "near_field"},
+                        "transcription": {
+                            "language": "language",
+                            "model": "whisper-1",
+                            "prompt": "prompt",
+                        },
+                        "turn_detection": {
+                            "type": "server_vad",
+                            "create_response": True,
+                            "idle_timeout_ms": 5000,
+                            "interrupt_response": True,
+                            "prefix_padding_ms": 0,
+                            "silence_duration_ms": 0,
+                            "threshold": 0,
+                        },
+                    },
+                    "output": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "speed": 0.25,
+                        "voice": "ash",
+                    },
+                },
+                "include": ["item.input_audio_transcription.logprobs"],
+                "instructions": "instructions",
+                "max_output_tokens": 0,
+                "model": "string",
+                "output_modalities": ["text"],
+                "prompt": {
+                    "id": "id",
+                    "variables": {"foo": "string"},
+                    "version": "version",
+                },
+                "tool_choice": "none",
+                "tools": [
+                    {
+                        "description": "description",
+                        "name": "name",
+                        "parameters": {},
+                        "type": "function",
+                    }
+                ],
+                "tracing": "auto",
+                "truncation": "auto",
+            },
+        )
+        assert isinstance(call, _legacy_response.HttpxBinaryResponseContent)
+        assert call.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_raw_response_create(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+
+        response = await async_client.realtime.calls.with_raw_response.create(
+            sdp="sdp",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert_matches_type(_legacy_response.HttpxBinaryResponseContent, call, path=["response"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.post("/realtime/calls").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        async with async_client.realtime.calls.with_streaming_response.create(
+            sdp="sdp",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = await response.parse()
+            assert_matches_type(bytes, call, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_accept(self, async_client: AsyncOpenAI) -> None:
+        call = await async_client.realtime.calls.accept(
+            call_id="call_id",
+            type="realtime",
+        )
+        assert call is None
+
+    @parametrize
+    async def test_method_accept_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        call = await async_client.realtime.calls.accept(
+            call_id="call_id",
+            type="realtime",
+            audio={
+                "input": {
+                    "format": {
+                        "rate": 24000,
+                        "type": "audio/pcm",
+                    },
+                    "noise_reduction": {"type": "near_field"},
+                    "transcription": {
+                        "language": "language",
+                        "model": "whisper-1",
+                        "prompt": "prompt",
+                    },
+                    "turn_detection": {
+                        "type": "server_vad",
+                        "create_response": True,
+                        "idle_timeout_ms": 5000,
+                        "interrupt_response": True,
+                        "prefix_padding_ms": 0,
+                        "silence_duration_ms": 0,
+                        "threshold": 0,
+                    },
+                },
+                "output": {
+                    "format": {
+                        "rate": 24000,
+                        "type": "audio/pcm",
+                    },
+                    "speed": 0.25,
+                    "voice": "ash",
+                },
+            },
+            include=["item.input_audio_transcription.logprobs"],
+            instructions="instructions",
+            max_output_tokens=0,
+            model="string",
+            output_modalities=["text"],
+            prompt={
+                "id": "id",
+                "variables": {"foo": "string"},
+                "version": "version",
+            },
+            tool_choice="none",
+            tools=[
+                {
+                    "description": "description",
+                    "name": "name",
+                    "parameters": {},
+                    "type": "function",
+                }
+            ],
+            tracing="auto",
+            truncation="auto",
+        )
+        assert call is None
+
+    @parametrize
+    async def test_raw_response_accept(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.realtime.calls.with_raw_response.accept(
+            call_id="call_id",
+            type="realtime",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    async def test_streaming_response_accept(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.realtime.calls.with_streaming_response.accept(
+            call_id="call_id",
+            type="realtime",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = await response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_accept(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            await async_client.realtime.calls.with_raw_response.accept(
+                call_id="",
+                type="realtime",
+            )
+
+    @parametrize
+    async def test_method_hangup(self, async_client: AsyncOpenAI) -> None:
+        call = await async_client.realtime.calls.hangup(
+            "call_id",
+        )
+        assert call is None
+
+    @parametrize
+    async def test_raw_response_hangup(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.realtime.calls.with_raw_response.hangup(
+            "call_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    async def test_streaming_response_hangup(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.realtime.calls.with_streaming_response.hangup(
+            "call_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = await response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_hangup(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            await async_client.realtime.calls.with_raw_response.hangup(
+                "",
+            )
+
+    @parametrize
+    async def test_method_refer(self, async_client: AsyncOpenAI) -> None:
+        call = await async_client.realtime.calls.refer(
+            call_id="call_id",
+            target_uri="tel:+14155550123",
+        )
+        assert call is None
+
+    @parametrize
+    async def test_raw_response_refer(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.realtime.calls.with_raw_response.refer(
+            call_id="call_id",
+            target_uri="tel:+14155550123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    async def test_streaming_response_refer(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.realtime.calls.with_streaming_response.refer(
+            call_id="call_id",
+            target_uri="tel:+14155550123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = await response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_refer(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            await async_client.realtime.calls.with_raw_response.refer(
+                call_id="",
+                target_uri="tel:+14155550123",
+            )
+
+    @parametrize
+    async def test_method_reject(self, async_client: AsyncOpenAI) -> None:
+        call = await async_client.realtime.calls.reject(
+            call_id="call_id",
+        )
+        assert call is None
+
+    @parametrize
+    async def test_method_reject_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        call = await async_client.realtime.calls.reject(
+            call_id="call_id",
+            status_code=486,
+        )
+        assert call is None
+
+    @parametrize
+    async def test_raw_response_reject(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.realtime.calls.with_raw_response.reject(
+            call_id="call_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        call = response.parse()
+        assert call is None
+
+    @parametrize
+    async def test_streaming_response_reject(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.realtime.calls.with_streaming_response.reject(
+            call_id="call_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            call = await response.parse()
+            assert call is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_reject(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `call_id` but received ''"):
+            await async_client.realtime.calls.with_raw_response.reject(
+                call_id="",
+            )
diff --git a/tests/api_resources/realtime/test_client_secrets.py b/tests/api_resources/realtime/test_client_secrets.py
new file mode 100644
index 0000000000..cd15b4be52
--- /dev/null
+++ b/tests/api_resources/realtime/test_client_secrets.py
@@ -0,0 +1,204 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types.realtime import ClientSecretCreateResponse
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestClientSecrets:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        client_secret = client.realtime.client_secrets.create()
+        assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        client_secret = client.realtime.client_secrets.create(
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 10,
+            },
+            session={
+                "type": "realtime",
+                "audio": {
+                    "input": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "noise_reduction": {"type": "near_field"},
+                        "transcription": {
+                            "language": "language",
+                            "model": "whisper-1",
+                            "prompt": "prompt",
+                        },
+                        "turn_detection": {
+                            "type": "server_vad",
+                            "create_response": True,
+                            "idle_timeout_ms": 5000,
+                            "interrupt_response": True,
+                            "prefix_padding_ms": 0,
+                            "silence_duration_ms": 0,
+                            "threshold": 0,
+                        },
+                    },
+                    "output": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "speed": 0.25,
+                        "voice": "ash",
+                    },
+                },
+                "include": ["item.input_audio_transcription.logprobs"],
+                "instructions": "instructions",
+                "max_output_tokens": 0,
+                "model": "string",
+                "output_modalities": ["text"],
+                "prompt": {
+                    "id": "id",
+                    "variables": {"foo": "string"},
+                    "version": "version",
+                },
+                "tool_choice": "none",
+                "tools": [
+                    {
+                        "description": "description",
+                        "name": "name",
+                        "parameters": {},
+                        "type": "function",
+                    }
+                ],
+                "tracing": "auto",
+                "truncation": "auto",
+            },
+        )
+        assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.realtime.client_secrets.with_raw_response.create()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        client_secret = response.parse()
+        assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.realtime.client_secrets.with_streaming_response.create() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            client_secret = response.parse()
+            assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+
+class TestAsyncClientSecrets:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        client_secret = await async_client.realtime.client_secrets.create()
+        assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        client_secret = await async_client.realtime.client_secrets.create(
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 10,
+            },
+            session={
+                "type": "realtime",
+                "audio": {
+                    "input": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "noise_reduction": {"type": "near_field"},
+                        "transcription": {
+                            "language": "language",
+                            "model": "whisper-1",
+                            "prompt": "prompt",
+                        },
+                        "turn_detection": {
+                            "type": "server_vad",
+                            "create_response": True,
+                            "idle_timeout_ms": 5000,
+                            "interrupt_response": True,
+                            "prefix_padding_ms": 0,
+                            "silence_duration_ms": 0,
+                            "threshold": 0,
+                        },
+                    },
+                    "output": {
+                        "format": {
+                            "rate": 24000,
+                            "type": "audio/pcm",
+                        },
+                        "speed": 0.25,
+                        "voice": "ash",
+                    },
+                },
+                "include": ["item.input_audio_transcription.logprobs"],
+                "instructions": "instructions",
+                "max_output_tokens": 0,
+                "model": "string",
+                "output_modalities": ["text"],
+                "prompt": {
+                    "id": "id",
+                    "variables": {"foo": "string"},
+                    "version": "version",
+                },
+                "tool_choice": "none",
+                "tools": [
+                    {
+                        "description": "description",
+                        "name": "name",
+                        "parameters": {},
+                        "type": "function",
+                    }
+                ],
+                "tracing": "auto",
+                "truncation": "auto",
+            },
+        )
+        assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.realtime.client_secrets.with_raw_response.create()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        client_secret = response.parse()
+        assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.realtime.client_secrets.with_streaming_response.create() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            client_secret = await response.parse()
+            assert_matches_type(ClientSecretCreateResponse, client_secret, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/responses/test_input_items.py b/tests/api_resources/responses/test_input_items.py
index 28c5e8ca1f..ed6fddf33a 100644
--- a/tests/api_resources/responses/test_input_items.py
+++ b/tests/api_resources/responses/test_input_items.py
@@ -10,7 +10,7 @@
 from openai import OpenAI, AsyncOpenAI
 from tests.utils import assert_matches_type
 from openai.pagination import SyncCursorPage, AsyncCursorPage
-from openai.types.responses.response_item_list import Data
+from openai.types.responses import ResponseItem
 
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
@@ -23,18 +23,18 @@ def test_method_list(self, client: OpenAI) -> None:
         input_item = client.responses.input_items.list(
             response_id="response_id",
         )
-        assert_matches_type(SyncCursorPage[Data], input_item, path=["response"])
+        assert_matches_type(SyncCursorPage[ResponseItem], input_item, path=["response"])
 
     @parametrize
     def test_method_list_with_all_params(self, client: OpenAI) -> None:
         input_item = client.responses.input_items.list(
             response_id="response_id",
             after="after",
-            before="before",
+            include=["file_search_call.results"],
             limit=0,
             order="asc",
         )
-        assert_matches_type(SyncCursorPage[Data], input_item, path=["response"])
+        assert_matches_type(SyncCursorPage[ResponseItem], input_item, path=["response"])
 
     @parametrize
     def test_raw_response_list(self, client: OpenAI) -> None:
@@ -45,7 +45,7 @@ def test_raw_response_list(self, client: OpenAI) -> None:
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         input_item = response.parse()
-        assert_matches_type(SyncCursorPage[Data], input_item, path=["response"])
+        assert_matches_type(SyncCursorPage[ResponseItem], input_item, path=["response"])
 
     @parametrize
     def test_streaming_response_list(self, client: OpenAI) -> None:
@@ -56,7 +56,7 @@ def test_streaming_response_list(self, client: OpenAI) -> None:
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
             input_item = response.parse()
-            assert_matches_type(SyncCursorPage[Data], input_item, path=["response"])
+            assert_matches_type(SyncCursorPage[ResponseItem], input_item, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
@@ -69,25 +69,27 @@ def test_path_params_list(self, client: OpenAI) -> None:
 
 
 class TestAsyncInputItems:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_list(self, async_client: AsyncOpenAI) -> None:
         input_item = await async_client.responses.input_items.list(
             response_id="response_id",
         )
-        assert_matches_type(AsyncCursorPage[Data], input_item, path=["response"])
+        assert_matches_type(AsyncCursorPage[ResponseItem], input_item, path=["response"])
 
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
         input_item = await async_client.responses.input_items.list(
             response_id="response_id",
             after="after",
-            before="before",
+            include=["file_search_call.results"],
             limit=0,
             order="asc",
         )
-        assert_matches_type(AsyncCursorPage[Data], input_item, path=["response"])
+        assert_matches_type(AsyncCursorPage[ResponseItem], input_item, path=["response"])
 
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
@@ -98,7 +100,7 @@ async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
         input_item = response.parse()
-        assert_matches_type(AsyncCursorPage[Data], input_item, path=["response"])
+        assert_matches_type(AsyncCursorPage[ResponseItem], input_item, path=["response"])
 
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
@@ -109,7 +111,7 @@ async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
             input_item = await response.parse()
-            assert_matches_type(AsyncCursorPage[Data], input_item, path=["response"])
+            assert_matches_type(AsyncCursorPage[ResponseItem], input_item, path=["response"])
 
         assert cast(Any, response.is_closed) is True
 
diff --git a/tests/api_resources/responses/test_input_tokens.py b/tests/api_resources/responses/test_input_tokens.py
new file mode 100644
index 0000000000..d9aecc33bd
--- /dev/null
+++ b/tests/api_resources/responses/test_input_tokens.py
@@ -0,0 +1,138 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types.responses import InputTokenCountResponse
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestInputTokens:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_count(self, client: OpenAI) -> None:
+        input_token = client.responses.input_tokens.count()
+        assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+    @parametrize
+    def test_method_count_with_all_params(self, client: OpenAI) -> None:
+        input_token = client.responses.input_tokens.count(
+            conversation="string",
+            input="string",
+            instructions="instructions",
+            model="model",
+            parallel_tool_calls=True,
+            previous_response_id="resp_123",
+            reasoning={
+                "effort": "none",
+                "generate_summary": "auto",
+                "summary": "auto",
+            },
+            text={
+                "format": {"type": "text"},
+                "verbosity": "low",
+            },
+            tool_choice="none",
+            tools=[
+                {
+                    "name": "name",
+                    "parameters": {"foo": "bar"},
+                    "strict": True,
+                    "type": "function",
+                    "description": "description",
+                }
+            ],
+            truncation="auto",
+        )
+        assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+    @parametrize
+    def test_raw_response_count(self, client: OpenAI) -> None:
+        response = client.responses.input_tokens.with_raw_response.count()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        input_token = response.parse()
+        assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+    @parametrize
+    def test_streaming_response_count(self, client: OpenAI) -> None:
+        with client.responses.input_tokens.with_streaming_response.count() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            input_token = response.parse()
+            assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+
+class TestAsyncInputTokens:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_count(self, async_client: AsyncOpenAI) -> None:
+        input_token = await async_client.responses.input_tokens.count()
+        assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+    @parametrize
+    async def test_method_count_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        input_token = await async_client.responses.input_tokens.count(
+            conversation="string",
+            input="string",
+            instructions="instructions",
+            model="model",
+            parallel_tool_calls=True,
+            previous_response_id="resp_123",
+            reasoning={
+                "effort": "none",
+                "generate_summary": "auto",
+                "summary": "auto",
+            },
+            text={
+                "format": {"type": "text"},
+                "verbosity": "low",
+            },
+            tool_choice="none",
+            tools=[
+                {
+                    "name": "name",
+                    "parameters": {"foo": "bar"},
+                    "strict": True,
+                    "type": "function",
+                    "description": "description",
+                }
+            ],
+            truncation="auto",
+        )
+        assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+    @parametrize
+    async def test_raw_response_count(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.responses.input_tokens.with_raw_response.count()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        input_token = response.parse()
+        assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_count(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.responses.input_tokens.with_streaming_response.count() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            input_token = await response.parse()
+            assert_matches_type(InputTokenCountResponse, input_token, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/test_batches.py b/tests/api_resources/test_batches.py
index 6f9b598e61..95b94c4846 100644
--- a/tests/api_resources/test_batches.py
+++ b/tests/api_resources/test_batches.py
@@ -22,7 +22,7 @@ class TestBatches:
     def test_method_create(self, client: OpenAI) -> None:
         batch = client.batches.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
         )
         assert_matches_type(Batch, batch, path=["response"])
@@ -31,9 +31,13 @@ def test_method_create(self, client: OpenAI) -> None:
     def test_method_create_with_all_params(self, client: OpenAI) -> None:
         batch = client.batches.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
             metadata={"foo": "string"},
+            output_expires_after={
+                "anchor": "created_at",
+                "seconds": 3600,
+            },
         )
         assert_matches_type(Batch, batch, path=["response"])
 
@@ -41,7 +45,7 @@ def test_method_create_with_all_params(self, client: OpenAI) -> None:
     def test_raw_response_create(self, client: OpenAI) -> None:
         response = client.batches.with_raw_response.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
         )
 
@@ -54,7 +58,7 @@ def test_raw_response_create(self, client: OpenAI) -> None:
     def test_streaming_response_create(self, client: OpenAI) -> None:
         with client.batches.with_streaming_response.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
         ) as response:
             assert not response.is_closed
@@ -176,13 +180,15 @@ def test_path_params_cancel(self, client: OpenAI) -> None:
 
 
 class TestAsyncBatches:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
         batch = await async_client.batches.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
         )
         assert_matches_type(Batch, batch, path=["response"])
@@ -191,9 +197,13 @@ async def test_method_create(self, async_client: AsyncOpenAI) -> None:
     async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
         batch = await async_client.batches.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
             metadata={"foo": "string"},
+            output_expires_after={
+                "anchor": "created_at",
+                "seconds": 3600,
+            },
         )
         assert_matches_type(Batch, batch, path=["response"])
 
@@ -201,7 +211,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) ->
     async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.batches.with_raw_response.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
         )
 
@@ -214,7 +224,7 @@ async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
     async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
         async with async_client.batches.with_streaming_response.create(
             completion_window="24h",
-            endpoint="/v1/chat/completions",
+            endpoint="/v1/responses",
             input_file_id="string",
         ) as response:
             assert not response.is_closed
diff --git a/tests/api_resources/test_completions.py b/tests/api_resources/test_completions.py
index 9ec503c1e3..a8fb0e59eb 100644
--- a/tests/api_resources/test_completions.py
+++ b/tests/api_resources/test_completions.py
@@ -41,7 +41,10 @@ def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
             seed=0,
             stop="\n",
             stream=False,
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             suffix="test.",
             temperature=1,
             top_p=1,
@@ -100,7 +103,10 @@ def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
             presence_penalty=-2,
             seed=0,
             stop="\n",
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             suffix="test.",
             temperature=1,
             top_p=1,
@@ -137,7 +143,9 @@ def test_streaming_response_create_overload_2(self, client: OpenAI) -> None:
 
 
 class TestAsyncCompletions:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create_overload_1(self, async_client: AsyncOpenAI) -> None:
@@ -163,7 +171,10 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
             seed=0,
             stop="\n",
             stream=False,
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             suffix="test.",
             temperature=1,
             top_p=1,
@@ -222,7 +233,10 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
             presence_penalty=-2,
             seed=0,
             stop="\n",
-            stream_options={"include_usage": True},
+            stream_options={
+                "include_obfuscation": True,
+                "include_usage": True,
+            },
             suffix="test.",
             temperature=1,
             top_p=1,
diff --git a/tests/api_resources/test_containers.py b/tests/api_resources/test_containers.py
new file mode 100644
index 0000000000..c972f6539d
--- /dev/null
+++ b/tests/api_resources/test_containers.py
@@ -0,0 +1,335 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types import (
+    ContainerListResponse,
+    ContainerCreateResponse,
+    ContainerRetrieveResponse,
+)
+from openai.pagination import SyncCursorPage, AsyncCursorPage
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestContainers:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        container = client.containers.create(
+            name="name",
+        )
+        assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        container = client.containers.create(
+            name="name",
+            expires_after={
+                "anchor": "last_active_at",
+                "minutes": 0,
+            },
+            file_ids=["string"],
+        )
+        assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.containers.with_raw_response.create(
+            name="name",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.containers.with_streaming_response.create(
+            name="name",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = response.parse()
+            assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        container = client.containers.retrieve(
+            "container_id",
+        )
+        assert_matches_type(ContainerRetrieveResponse, container, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.containers.with_raw_response.retrieve(
+            "container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert_matches_type(ContainerRetrieveResponse, container, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.containers.with_streaming_response.retrieve(
+            "container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = response.parse()
+            assert_matches_type(ContainerRetrieveResponse, container, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            client.containers.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        container = client.containers.list()
+        assert_matches_type(SyncCursorPage[ContainerListResponse], container, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        container = client.containers.list(
+            after="after",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(SyncCursorPage[ContainerListResponse], container, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.containers.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert_matches_type(SyncCursorPage[ContainerListResponse], container, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.containers.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = response.parse()
+            assert_matches_type(SyncCursorPage[ContainerListResponse], container, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        container = client.containers.delete(
+            "container_id",
+        )
+        assert container is None
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.containers.with_raw_response.delete(
+            "container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert container is None
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.containers.with_streaming_response.delete(
+            "container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = response.parse()
+            assert container is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            client.containers.with_raw_response.delete(
+                "",
+            )
+
+
+class TestAsyncContainers:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        container = await async_client.containers.create(
+            name="name",
+        )
+        assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        container = await async_client.containers.create(
+            name="name",
+            expires_after={
+                "anchor": "last_active_at",
+                "minutes": 0,
+            },
+            file_ids=["string"],
+        )
+        assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.with_raw_response.create(
+            name="name",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.with_streaming_response.create(
+            name="name",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = await response.parse()
+            assert_matches_type(ContainerCreateResponse, container, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        container = await async_client.containers.retrieve(
+            "container_id",
+        )
+        assert_matches_type(ContainerRetrieveResponse, container, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.with_raw_response.retrieve(
+            "container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert_matches_type(ContainerRetrieveResponse, container, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.with_streaming_response.retrieve(
+            "container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = await response.parse()
+            assert_matches_type(ContainerRetrieveResponse, container, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            await async_client.containers.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        container = await async_client.containers.list()
+        assert_matches_type(AsyncCursorPage[ContainerListResponse], container, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        container = await async_client.containers.list(
+            after="after",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(AsyncCursorPage[ContainerListResponse], container, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert_matches_type(AsyncCursorPage[ContainerListResponse], container, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = await response.parse()
+            assert_matches_type(AsyncCursorPage[ContainerListResponse], container, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        container = await async_client.containers.delete(
+            "container_id",
+        )
+        assert container is None
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.containers.with_raw_response.delete(
+            "container_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        container = response.parse()
+        assert container is None
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.containers.with_streaming_response.delete(
+            "container_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            container = await response.parse()
+            assert container is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `container_id` but received ''"):
+            await async_client.containers.with_raw_response.delete(
+                "",
+            )
diff --git a/tests/api_resources/test_conversations.py b/tests/api_resources/test_conversations.py
new file mode 100644
index 0000000000..d21e685a04
--- /dev/null
+++ b/tests/api_resources/test_conversations.py
@@ -0,0 +1,341 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types.conversations import (
+    Conversation,
+    ConversationDeletedResource,
+)
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestConversations:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        conversation = client.conversations.create()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        conversation = client.conversations.create(
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+            metadata={"foo": "string"},
+        )
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.conversations.with_raw_response.create()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.conversations.with_streaming_response.create() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = response.parse()
+            assert_matches_type(Conversation, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        conversation = client.conversations.retrieve(
+            "conv_123",
+        )
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.conversations.with_raw_response.retrieve(
+            "conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.conversations.with_streaming_response.retrieve(
+            "conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = response.parse()
+            assert_matches_type(Conversation, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            client.conversations.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    def test_method_update(self, client: OpenAI) -> None:
+        conversation = client.conversations.update(
+            conversation_id="conv_123",
+            metadata={"foo": "string"},
+        )
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    def test_raw_response_update(self, client: OpenAI) -> None:
+        response = client.conversations.with_raw_response.update(
+            conversation_id="conv_123",
+            metadata={"foo": "string"},
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    def test_streaming_response_update(self, client: OpenAI) -> None:
+        with client.conversations.with_streaming_response.update(
+            conversation_id="conv_123",
+            metadata={"foo": "string"},
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = response.parse()
+            assert_matches_type(Conversation, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_update(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            client.conversations.with_raw_response.update(
+                conversation_id="",
+                metadata={"foo": "string"},
+            )
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        conversation = client.conversations.delete(
+            "conv_123",
+        )
+        assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.conversations.with_raw_response.delete(
+            "conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.conversations.with_streaming_response.delete(
+            "conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = response.parse()
+            assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            client.conversations.with_raw_response.delete(
+                "",
+            )
+
+
+class TestAsyncConversations:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        conversation = await async_client.conversations.create()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        conversation = await async_client.conversations.create(
+            items=[
+                {
+                    "content": "string",
+                    "role": "user",
+                    "type": "message",
+                }
+            ],
+            metadata={"foo": "string"},
+        )
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.with_raw_response.create()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.with_streaming_response.create() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = await response.parse()
+            assert_matches_type(Conversation, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        conversation = await async_client.conversations.retrieve(
+            "conv_123",
+        )
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.with_raw_response.retrieve(
+            "conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.with_streaming_response.retrieve(
+            "conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = await response.parse()
+            assert_matches_type(Conversation, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            await async_client.conversations.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    async def test_method_update(self, async_client: AsyncOpenAI) -> None:
+        conversation = await async_client.conversations.update(
+            conversation_id="conv_123",
+            metadata={"foo": "string"},
+        )
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.with_raw_response.update(
+            conversation_id="conv_123",
+            metadata={"foo": "string"},
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(Conversation, conversation, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_update(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.with_streaming_response.update(
+            conversation_id="conv_123",
+            metadata={"foo": "string"},
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = await response.parse()
+            assert_matches_type(Conversation, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_update(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            await async_client.conversations.with_raw_response.update(
+                conversation_id="",
+                metadata={"foo": "string"},
+            )
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        conversation = await async_client.conversations.delete(
+            "conv_123",
+        )
+        assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.conversations.with_raw_response.delete(
+            "conv_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        conversation = response.parse()
+        assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.conversations.with_streaming_response.delete(
+            "conv_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            conversation = await response.parse()
+            assert_matches_type(ConversationDeletedResource, conversation, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `conversation_id` but received ''"):
+            await async_client.conversations.with_raw_response.delete(
+                "",
+            )
diff --git a/tests/api_resources/test_embeddings.py b/tests/api_resources/test_embeddings.py
index e75545b4e2..ce6e213d59 100644
--- a/tests/api_resources/test_embeddings.py
+++ b/tests/api_resources/test_embeddings.py
@@ -64,7 +64,9 @@ def test_streaming_response_create(self, client: OpenAI) -> None:
 
 
 class TestAsyncEmbeddings:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
diff --git a/tests/api_resources/test_evals.py b/tests/api_resources/test_evals.py
new file mode 100644
index 0000000000..473a4711ca
--- /dev/null
+++ b/tests/api_resources/test_evals.py
@@ -0,0 +1,573 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types import (
+    EvalListResponse,
+    EvalCreateResponse,
+    EvalDeleteResponse,
+    EvalUpdateResponse,
+    EvalRetrieveResponse,
+)
+from openai.pagination import SyncCursorPage, AsyncCursorPage
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestEvals:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        eval = client.evals.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+        )
+        assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        eval = client.evals.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+                "include_sample_schema": True,
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+            metadata={"foo": "string"},
+            name="name",
+        )
+        assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.evals.with_raw_response.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.evals.with_streaming_response.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = response.parse()
+            assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        eval = client.evals.retrieve(
+            "eval_id",
+        )
+        assert_matches_type(EvalRetrieveResponse, eval, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.evals.with_raw_response.retrieve(
+            "eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalRetrieveResponse, eval, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.evals.with_streaming_response.retrieve(
+            "eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = response.parse()
+            assert_matches_type(EvalRetrieveResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    def test_method_update(self, client: OpenAI) -> None:
+        eval = client.evals.update(
+            eval_id="eval_id",
+        )
+        assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+    @parametrize
+    def test_method_update_with_all_params(self, client: OpenAI) -> None:
+        eval = client.evals.update(
+            eval_id="eval_id",
+            metadata={"foo": "string"},
+            name="name",
+        )
+        assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+    @parametrize
+    def test_raw_response_update(self, client: OpenAI) -> None:
+        response = client.evals.with_raw_response.update(
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+    @parametrize
+    def test_streaming_response_update(self, client: OpenAI) -> None:
+        with client.evals.with_streaming_response.update(
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = response.parse()
+            assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_update(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.with_raw_response.update(
+                eval_id="",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        eval = client.evals.list()
+        assert_matches_type(SyncCursorPage[EvalListResponse], eval, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        eval = client.evals.list(
+            after="after",
+            limit=0,
+            order="asc",
+            order_by="created_at",
+        )
+        assert_matches_type(SyncCursorPage[EvalListResponse], eval, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.evals.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(SyncCursorPage[EvalListResponse], eval, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.evals.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = response.parse()
+            assert_matches_type(SyncCursorPage[EvalListResponse], eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        eval = client.evals.delete(
+            "eval_id",
+        )
+        assert_matches_type(EvalDeleteResponse, eval, path=["response"])
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.evals.with_raw_response.delete(
+            "eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalDeleteResponse, eval, path=["response"])
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.evals.with_streaming_response.delete(
+            "eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = response.parse()
+            assert_matches_type(EvalDeleteResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            client.evals.with_raw_response.delete(
+                "",
+            )
+
+
+class TestAsyncEvals:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+        )
+        assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+                "include_sample_schema": True,
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+            metadata={"foo": "string"},
+            name="name",
+        )
+        assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.with_raw_response.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.with_streaming_response.create(
+            data_source_config={
+                "item_schema": {"foo": "bar"},
+                "type": "custom",
+            },
+            testing_criteria=[
+                {
+                    "input": [
+                        {
+                            "content": "content",
+                            "role": "role",
+                        }
+                    ],
+                    "labels": ["string"],
+                    "model": "model",
+                    "name": "name",
+                    "passing_labels": ["string"],
+                    "type": "label_model",
+                }
+            ],
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = await response.parse()
+            assert_matches_type(EvalCreateResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.retrieve(
+            "eval_id",
+        )
+        assert_matches_type(EvalRetrieveResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.with_raw_response.retrieve(
+            "eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalRetrieveResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.with_streaming_response.retrieve(
+            "eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = await response.parse()
+            assert_matches_type(EvalRetrieveResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    async def test_method_update(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.update(
+            eval_id="eval_id",
+        )
+        assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_method_update_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.update(
+            eval_id="eval_id",
+            metadata={"foo": "string"},
+            name="name",
+        )
+        assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_raw_response_update(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.with_raw_response.update(
+            eval_id="eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_update(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.with_streaming_response.update(
+            eval_id="eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = await response.parse()
+            assert_matches_type(EvalUpdateResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_update(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.with_raw_response.update(
+                eval_id="",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.list()
+        assert_matches_type(AsyncCursorPage[EvalListResponse], eval, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.list(
+            after="after",
+            limit=0,
+            order="asc",
+            order_by="created_at",
+        )
+        assert_matches_type(AsyncCursorPage[EvalListResponse], eval, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(AsyncCursorPage[EvalListResponse], eval, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = await response.parse()
+            assert_matches_type(AsyncCursorPage[EvalListResponse], eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        eval = await async_client.evals.delete(
+            "eval_id",
+        )
+        assert_matches_type(EvalDeleteResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.evals.with_raw_response.delete(
+            "eval_id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        eval = response.parse()
+        assert_matches_type(EvalDeleteResponse, eval, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.evals.with_streaming_response.delete(
+            "eval_id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            eval = await response.parse()
+            assert_matches_type(EvalDeleteResponse, eval, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `eval_id` but received ''"):
+            await async_client.evals.with_raw_response.delete(
+                "",
+            )
diff --git a/tests/api_resources/test_files.py b/tests/api_resources/test_files.py
index 7402566d95..67c809f155 100644
--- a/tests/api_resources/test_files.py
+++ b/tests/api_resources/test_files.py
@@ -31,6 +31,18 @@ def test_method_create(self, client: OpenAI) -> None:
         )
         assert_matches_type(FileObject, file, path=["response"])
 
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        file = client.files.create(
+            file=b"raw file contents",
+            purpose="assistants",
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 3600,
+            },
+        )
+        assert_matches_type(FileObject, file, path=["response"])
+
     @parametrize
     def test_raw_response_create(self, client: OpenAI) -> None:
         response = client.files.with_raw_response.create(
@@ -260,7 +272,9 @@ def test_path_params_retrieve_content(self, client: OpenAI) -> None:
 
 
 class TestAsyncFiles:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
@@ -270,6 +284,18 @@ async def test_method_create(self, async_client: AsyncOpenAI) -> None:
         )
         assert_matches_type(FileObject, file, path=["response"])
 
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        file = await async_client.files.create(
+            file=b"raw file contents",
+            purpose="assistants",
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 3600,
+            },
+        )
+        assert_matches_type(FileObject, file, path=["response"])
+
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.files.with_raw_response.create(
diff --git a/tests/api_resources/test_images.py b/tests/api_resources/test_images.py
index 9bc9719bc5..99fe77d8e0 100644
--- a/tests/api_resources/test_images.py
+++ b/tests/api_resources/test_images.py
@@ -28,10 +28,10 @@ def test_method_create_variation(self, client: OpenAI) -> None:
     def test_method_create_variation_with_all_params(self, client: OpenAI) -> None:
         image = client.images.create_variation(
             image=b"raw file contents",
-            model="dall-e-2",
+            model="string",
             n=1,
             response_format="url",
-            size="256x256",
+            size="1024x1024",
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
@@ -61,7 +61,7 @@ def test_streaming_response_create_variation(self, client: OpenAI) -> None:
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    def test_method_edit(self, client: OpenAI) -> None:
+    def test_method_edit_overload_1(self, client: OpenAI) -> None:
         image = client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -69,21 +69,28 @@ def test_method_edit(self, client: OpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_method_edit_with_all_params(self, client: OpenAI) -> None:
+    def test_method_edit_with_all_params_overload_1(self, client: OpenAI) -> None:
         image = client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
+            background="transparent",
+            input_fidelity="high",
             mask=b"raw file contents",
-            model="dall-e-2",
+            model="string",
             n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="high",
             response_format="url",
-            size="256x256",
+            size="1024x1024",
+            stream=False,
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_raw_response_edit(self, client: OpenAI) -> None:
+    def test_raw_response_edit_overload_1(self, client: OpenAI) -> None:
         response = client.images.with_raw_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -95,7 +102,7 @@ def test_raw_response_edit(self, client: OpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_streaming_response_edit(self, client: OpenAI) -> None:
+    def test_streaming_response_edit_overload_1(self, client: OpenAI) -> None:
         with client.images.with_streaming_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -109,28 +116,91 @@ def test_streaming_response_edit(self, client: OpenAI) -> None:
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    def test_method_generate(self, client: OpenAI) -> None:
+    def test_method_edit_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_method_edit_with_all_params_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+            background="transparent",
+            input_fidelity="high",
+            mask=b"raw file contents",
+            model="string",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="high",
+            response_format="url",
+            size="1024x1024",
+            user="user-1234",
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_raw_response_edit_overload_2(self, client: OpenAI) -> None:
+        response = client.images.with_raw_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @parametrize
+    def test_streaming_response_edit_overload_2(self, client: OpenAI) -> None:
+        with client.images.with_streaming_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_generate_overload_1(self, client: OpenAI) -> None:
         image = client.images.generate(
             prompt="A cute baby sea otter",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_method_generate_with_all_params(self, client: OpenAI) -> None:
+    def test_method_generate_with_all_params_overload_1(self, client: OpenAI) -> None:
         image = client.images.generate(
             prompt="A cute baby sea otter",
-            model="dall-e-3",
+            background="transparent",
+            model="string",
+            moderation="low",
             n=1,
-            quality="standard",
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="medium",
             response_format="url",
-            size="256x256",
+            size="1024x1024",
+            stream=False,
             style="vivid",
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_raw_response_generate(self, client: OpenAI) -> None:
+    def test_raw_response_generate_overload_1(self, client: OpenAI) -> None:
         response = client.images.with_raw_response.generate(
             prompt="A cute baby sea otter",
         )
@@ -141,7 +211,7 @@ def test_raw_response_generate(self, client: OpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_streaming_response_generate(self, client: OpenAI) -> None:
+    def test_streaming_response_generate_overload_1(self, client: OpenAI) -> None:
         with client.images.with_streaming_response.generate(
             prompt="A cute baby sea otter",
         ) as response:
@@ -153,9 +223,64 @@ def test_streaming_response_generate(self, client: OpenAI) -> None:
 
         assert cast(Any, response.is_closed) is True
 
+    @parametrize
+    def test_method_generate_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_method_generate_with_all_params_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+            background="transparent",
+            model="string",
+            moderation="low",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="medium",
+            response_format="url",
+            size="1024x1024",
+            style="vivid",
+            user="user-1234",
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_raw_response_generate_overload_2(self, client: OpenAI) -> None:
+        response = client.images.with_raw_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @parametrize
+    def test_streaming_response_generate_overload_2(self, client: OpenAI) -> None:
+        with client.images.with_streaming_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
 
 class TestAsyncImages:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create_variation(self, async_client: AsyncOpenAI) -> None:
@@ -168,10 +293,10 @@ async def test_method_create_variation(self, async_client: AsyncOpenAI) -> None:
     async def test_method_create_variation_with_all_params(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.create_variation(
             image=b"raw file contents",
-            model="dall-e-2",
+            model="string",
             n=1,
             response_format="url",
-            size="256x256",
+            size="1024x1024",
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
@@ -201,7 +326,7 @@ async def test_streaming_response_create_variation(self, async_client: AsyncOpen
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    async def test_method_edit(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_edit_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -209,21 +334,28 @@ async def test_method_edit(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_method_edit_with_all_params(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_edit_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
+            background="transparent",
+            input_fidelity="high",
             mask=b"raw file contents",
-            model="dall-e-2",
+            model="string",
             n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="high",
             response_format="url",
-            size="256x256",
+            size="1024x1024",
+            stream=False,
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_raw_response_edit(self, async_client: AsyncOpenAI) -> None:
+    async def test_raw_response_edit_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.images.with_raw_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -235,7 +367,7 @@ async def test_raw_response_edit(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_streaming_response_edit(self, async_client: AsyncOpenAI) -> None:
+    async def test_streaming_response_edit_overload_1(self, async_client: AsyncOpenAI) -> None:
         async with async_client.images.with_streaming_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -249,28 +381,91 @@ async def test_streaming_response_edit(self, async_client: AsyncOpenAI) -> None:
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    async def test_method_generate(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_edit_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_method_edit_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+            background="transparent",
+            input_fidelity="high",
+            mask=b"raw file contents",
+            model="string",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="high",
+            response_format="url",
+            size="1024x1024",
+            user="user-1234",
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_raw_response_edit_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.images.with_raw_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        await stream.close()
+
+    @parametrize
+    async def test_streaming_response_edit_overload_2(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.images.with_streaming_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_generate_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.generate(
             prompt="A cute baby sea otter",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_method_generate_with_all_params(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_generate_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.generate(
             prompt="A cute baby sea otter",
-            model="dall-e-3",
+            background="transparent",
+            model="string",
+            moderation="low",
             n=1,
-            quality="standard",
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="medium",
             response_format="url",
-            size="256x256",
+            size="1024x1024",
+            stream=False,
             style="vivid",
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_raw_response_generate(self, async_client: AsyncOpenAI) -> None:
+    async def test_raw_response_generate_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.images.with_raw_response.generate(
             prompt="A cute baby sea otter",
         )
@@ -281,7 +476,7 @@ async def test_raw_response_generate(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_streaming_response_generate(self, async_client: AsyncOpenAI) -> None:
+    async def test_streaming_response_generate_overload_1(self, async_client: AsyncOpenAI) -> None:
         async with async_client.images.with_streaming_response.generate(
             prompt="A cute baby sea otter",
         ) as response:
@@ -292,3 +487,56 @@ async def test_streaming_response_generate(self, async_client: AsyncOpenAI) -> N
             assert_matches_type(ImagesResponse, image, path=["response"])
 
         assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_generate_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_method_generate_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+            background="transparent",
+            model="string",
+            moderation="low",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="medium",
+            response_format="url",
+            size="1024x1024",
+            style="vivid",
+            user="user-1234",
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_raw_response_generate_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.images.with_raw_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        await stream.close()
+
+    @parametrize
+    async def test_streaming_response_generate_overload_2(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.images.with_streaming_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/test_models.py b/tests/api_resources/test_models.py
index 8791507c3e..cf70871ade 100644
--- a/tests/api_resources/test_models.py
+++ b/tests/api_resources/test_models.py
@@ -121,7 +121,9 @@ def test_path_params_delete(self, client: OpenAI) -> None:
 
 
 class TestAsyncModels:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
diff --git a/tests/api_resources/test_moderations.py b/tests/api_resources/test_moderations.py
index bbdeb63e49..870c9e342f 100644
--- a/tests/api_resources/test_moderations.py
+++ b/tests/api_resources/test_moderations.py
@@ -28,7 +28,7 @@ def test_method_create(self, client: OpenAI) -> None:
     def test_method_create_with_all_params(self, client: OpenAI) -> None:
         moderation = client.moderations.create(
             input="I want to kill them.",
-            model="omni-moderation-2024-09-26",
+            model="string",
         )
         assert_matches_type(ModerationCreateResponse, moderation, path=["response"])
 
@@ -58,7 +58,9 @@ def test_streaming_response_create(self, client: OpenAI) -> None:
 
 
 class TestAsyncModerations:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
@@ -71,7 +73,7 @@ async def test_method_create(self, async_client: AsyncOpenAI) -> None:
     async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
         moderation = await async_client.moderations.create(
             input="I want to kill them.",
-            model="omni-moderation-2024-09-26",
+            model="string",
         )
         assert_matches_type(ModerationCreateResponse, moderation, path=["response"])
 
diff --git a/tests/api_resources/test_realtime.py b/tests/api_resources/test_realtime.py
new file mode 100644
index 0000000000..2b0c7f7d8d
--- /dev/null
+++ b/tests/api_resources/test_realtime.py
@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestRealtime:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+
+class TestAsyncRealtime:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
diff --git a/tests/api_resources/test_responses.py b/tests/api_resources/test_responses.py
index e45a5becf3..b57e6099c4 100644
--- a/tests/api_resources/test_responses.py
+++ b/tests/api_resources/test_responses.py
@@ -9,7 +9,10 @@
 
 from openai import OpenAI, AsyncOpenAI
 from tests.utils import assert_matches_type
-from openai.types.responses import Response
+from openai._utils import assert_signatures_in_sync
+from openai.types.responses import (
+    Response,
+)
 
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
@@ -19,48 +22,56 @@ class TestResponses:
 
     @parametrize
     def test_method_create_overload_1(self, client: OpenAI) -> None:
-        response = client.responses.create(
-            input="string",
-            model="gpt-4o",
-        )
+        response = client.responses.create()
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
     def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
         response = client.responses.create(
-            input="string",
-            model="gpt-4o",
+            background=True,
+            conversation="string",
             include=["file_search_call.results"],
+            input="string",
             instructions="instructions",
             max_output_tokens=0,
+            max_tool_calls=0,
             metadata={"foo": "string"},
+            model="gpt-4o",
             parallel_tool_calls=True,
             previous_response_id="previous_response_id",
+            prompt={
+                "id": "id",
+                "variables": {"foo": "string"},
+                "version": "version",
+            },
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
             reasoning={
-                "effort": "low",
-                "generate_summary": "concise",
+                "effort": "none",
+                "generate_summary": "auto",
+                "summary": "auto",
             },
+            safety_identifier="safety-identifier-1234",
+            service_tier="auto",
             store=True,
             stream=False,
+            stream_options={"include_obfuscation": True},
             temperature=1,
-            text={"format": {"type": "text"}},
+            text={
+                "format": {"type": "text"},
+                "verbosity": "low",
+            },
             tool_choice="none",
             tools=[
                 {
-                    "type": "file_search",
-                    "vector_store_ids": ["string"],
-                    "filters": {
-                        "key": "key",
-                        "type": "eq",
-                        "value": "string",
-                    },
-                    "max_num_results": 0,
-                    "ranking_options": {
-                        "ranker": "auto",
-                        "score_threshold": 0,
-                    },
+                    "name": "name",
+                    "parameters": {"foo": "bar"},
+                    "strict": True,
+                    "type": "function",
+                    "description": "description",
                 }
             ],
+            top_logprobs=0,
             top_p=1,
             truncation="auto",
             user="user-1234",
@@ -69,10 +80,7 @@ def test_method_create_with_all_params_overload_1(self, client: OpenAI) -> None:
 
     @parametrize
     def test_raw_response_create_overload_1(self, client: OpenAI) -> None:
-        http_response = client.responses.with_raw_response.create(
-            input="string",
-            model="gpt-4o",
-        )
+        http_response = client.responses.with_raw_response.create()
 
         assert http_response.is_closed is True
         assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -81,10 +89,7 @@ def test_raw_response_create_overload_1(self, client: OpenAI) -> None:
 
     @parametrize
     def test_streaming_response_create_overload_1(self, client: OpenAI) -> None:
-        with client.responses.with_streaming_response.create(
-            input="string",
-            model="gpt-4o",
-        ) as http_response:
+        with client.responses.with_streaming_response.create() as http_response:
             assert not http_response.is_closed
             assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
 
@@ -96,8 +101,6 @@ def test_streaming_response_create_overload_1(self, client: OpenAI) -> None:
     @parametrize
     def test_method_create_overload_2(self, client: OpenAI) -> None:
         response_stream = client.responses.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
         )
         response_stream.response.close()
@@ -105,39 +108,50 @@ def test_method_create_overload_2(self, client: OpenAI) -> None:
     @parametrize
     def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
         response_stream = client.responses.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
+            background=True,
+            conversation="string",
             include=["file_search_call.results"],
+            input="string",
             instructions="instructions",
             max_output_tokens=0,
+            max_tool_calls=0,
             metadata={"foo": "string"},
+            model="gpt-4o",
             parallel_tool_calls=True,
             previous_response_id="previous_response_id",
+            prompt={
+                "id": "id",
+                "variables": {"foo": "string"},
+                "version": "version",
+            },
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
             reasoning={
-                "effort": "low",
-                "generate_summary": "concise",
+                "effort": "none",
+                "generate_summary": "auto",
+                "summary": "auto",
             },
+            safety_identifier="safety-identifier-1234",
+            service_tier="auto",
             store=True,
+            stream_options={"include_obfuscation": True},
             temperature=1,
-            text={"format": {"type": "text"}},
+            text={
+                "format": {"type": "text"},
+                "verbosity": "low",
+            },
             tool_choice="none",
             tools=[
                 {
-                    "type": "file_search",
-                    "vector_store_ids": ["string"],
-                    "filters": {
-                        "key": "key",
-                        "type": "eq",
-                        "value": "string",
-                    },
-                    "max_num_results": 0,
-                    "ranking_options": {
-                        "ranker": "auto",
-                        "score_threshold": 0,
-                    },
+                    "name": "name",
+                    "parameters": {"foo": "bar"},
+                    "strict": True,
+                    "type": "function",
+                    "description": "description",
                 }
             ],
+            top_logprobs=0,
             top_p=1,
             truncation="auto",
             user="user-1234",
@@ -147,8 +161,6 @@ def test_method_create_with_all_params_overload_2(self, client: OpenAI) -> None:
     @parametrize
     def test_raw_response_create_overload_2(self, client: OpenAI) -> None:
         response = client.responses.with_raw_response.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
         )
 
@@ -159,8 +171,6 @@ def test_raw_response_create_overload_2(self, client: OpenAI) -> None:
     @parametrize
     def test_streaming_response_create_overload_2(self, client: OpenAI) -> None:
         with client.responses.with_streaming_response.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
         ) as response:
             assert not response.is_closed
@@ -172,22 +182,25 @@ def test_streaming_response_create_overload_2(self, client: OpenAI) -> None:
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    def test_method_retrieve(self, client: OpenAI) -> None:
+    def test_method_retrieve_overload_1(self, client: OpenAI) -> None:
         response = client.responses.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
         )
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
-    def test_method_retrieve_with_all_params(self, client: OpenAI) -> None:
+    def test_method_retrieve_with_all_params_overload_1(self, client: OpenAI) -> None:
         response = client.responses.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
             include=["file_search_call.results"],
+            include_obfuscation=True,
+            starting_after=0,
+            stream=False,
         )
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
-    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+    def test_raw_response_retrieve_overload_1(self, client: OpenAI) -> None:
         http_response = client.responses.with_raw_response.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
         )
@@ -198,7 +211,7 @@ def test_raw_response_retrieve(self, client: OpenAI) -> None:
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
-    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+    def test_streaming_response_retrieve_overload_1(self, client: OpenAI) -> None:
         with client.responses.with_streaming_response.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
         ) as http_response:
@@ -211,12 +224,64 @@ def test_streaming_response_retrieve(self, client: OpenAI) -> None:
         assert cast(Any, http_response.is_closed) is True
 
     @parametrize
-    def test_path_params_retrieve(self, client: OpenAI) -> None:
+    def test_path_params_retrieve_overload_1(self, client: OpenAI) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):
             client.responses.with_raw_response.retrieve(
                 response_id="",
             )
 
+    @parametrize
+    def test_method_retrieve_overload_2(self, client: OpenAI) -> None:
+        response_stream = client.responses.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+        )
+        response_stream.response.close()
+
+    @parametrize
+    def test_method_retrieve_with_all_params_overload_2(self, client: OpenAI) -> None:
+        response_stream = client.responses.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+            include=["file_search_call.results"],
+            include_obfuscation=True,
+            starting_after=0,
+        )
+        response_stream.response.close()
+
+    @parametrize
+    def test_raw_response_retrieve_overload_2(self, client: OpenAI) -> None:
+        response = client.responses.with_raw_response.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @parametrize
+    def test_streaming_response_retrieve_overload_2(self, client: OpenAI) -> None:
+        with client.responses.with_streaming_response.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve_overload_2(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):
+            client.responses.with_raw_response.retrieve(
+                response_id="",
+                stream=True,
+            )
+
     @parametrize
     def test_method_delete(self, client: OpenAI) -> None:
         response = client.responses.delete(
@@ -255,54 +320,113 @@ def test_path_params_delete(self, client: OpenAI) -> None:
                 "",
             )
 
+    @parametrize
+    def test_method_cancel(self, client: OpenAI) -> None:
+        response = client.responses.cancel(
+            "resp_677efb5139a88190b512bc3fef8e535d",
+        )
+        assert_matches_type(Response, response, path=["response"])
+
+    @parametrize
+    def test_raw_response_cancel(self, client: OpenAI) -> None:
+        http_response = client.responses.with_raw_response.cancel(
+            "resp_677efb5139a88190b512bc3fef8e535d",
+        )
+
+        assert http_response.is_closed is True
+        assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
+        response = http_response.parse()
+        assert_matches_type(Response, response, path=["response"])
+
+    @parametrize
+    def test_streaming_response_cancel(self, client: OpenAI) -> None:
+        with client.responses.with_streaming_response.cancel(
+            "resp_677efb5139a88190b512bc3fef8e535d",
+        ) as http_response:
+            assert not http_response.is_closed
+            assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            response = http_response.parse()
+            assert_matches_type(Response, response, path=["response"])
+
+        assert cast(Any, http_response.is_closed) is True
+
+    @parametrize
+    def test_path_params_cancel(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):
+            client.responses.with_raw_response.cancel(
+                "",
+            )
+
+
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_parse_method_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpenAI) -> None:
+    checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
+
+    assert_signatures_in_sync(
+        checking_client.responses.create,
+        checking_client.responses.parse,
+        exclude_params={"stream", "tools"},
+    )
+
 
 class TestAsyncResponses:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create_overload_1(self, async_client: AsyncOpenAI) -> None:
-        response = await async_client.responses.create(
-            input="string",
-            model="gpt-4o",
-        )
+        response = await async_client.responses.create()
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
     async def test_method_create_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.responses.create(
-            input="string",
-            model="gpt-4o",
+            background=True,
+            conversation="string",
             include=["file_search_call.results"],
+            input="string",
             instructions="instructions",
             max_output_tokens=0,
+            max_tool_calls=0,
             metadata={"foo": "string"},
+            model="gpt-4o",
             parallel_tool_calls=True,
             previous_response_id="previous_response_id",
+            prompt={
+                "id": "id",
+                "variables": {"foo": "string"},
+                "version": "version",
+            },
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
             reasoning={
-                "effort": "low",
-                "generate_summary": "concise",
+                "effort": "none",
+                "generate_summary": "auto",
+                "summary": "auto",
             },
+            safety_identifier="safety-identifier-1234",
+            service_tier="auto",
             store=True,
             stream=False,
+            stream_options={"include_obfuscation": True},
             temperature=1,
-            text={"format": {"type": "text"}},
+            text={
+                "format": {"type": "text"},
+                "verbosity": "low",
+            },
             tool_choice="none",
             tools=[
                 {
-                    "type": "file_search",
-                    "vector_store_ids": ["string"],
-                    "filters": {
-                        "key": "key",
-                        "type": "eq",
-                        "value": "string",
-                    },
-                    "max_num_results": 0,
-                    "ranking_options": {
-                        "ranker": "auto",
-                        "score_threshold": 0,
-                    },
+                    "name": "name",
+                    "parameters": {"foo": "bar"},
+                    "strict": True,
+                    "type": "function",
+                    "description": "description",
                 }
             ],
+            top_logprobs=0,
             top_p=1,
             truncation="auto",
             user="user-1234",
@@ -311,10 +435,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn
 
     @parametrize
     async def test_raw_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
-        http_response = await async_client.responses.with_raw_response.create(
-            input="string",
-            model="gpt-4o",
-        )
+        http_response = await async_client.responses.with_raw_response.create()
 
         assert http_response.is_closed is True
         assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -323,10 +444,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncOpenAI) -
 
     @parametrize
     async def test_streaming_response_create_overload_1(self, async_client: AsyncOpenAI) -> None:
-        async with async_client.responses.with_streaming_response.create(
-            input="string",
-            model="gpt-4o",
-        ) as http_response:
+        async with async_client.responses.with_streaming_response.create() as http_response:
             assert not http_response.is_closed
             assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
 
@@ -338,8 +456,6 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncOpe
     @parametrize
     async def test_method_create_overload_2(self, async_client: AsyncOpenAI) -> None:
         response_stream = await async_client.responses.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
         )
         await response_stream.response.aclose()
@@ -347,39 +463,50 @@ async def test_method_create_overload_2(self, async_client: AsyncOpenAI) -> None
     @parametrize
     async def test_method_create_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
         response_stream = await async_client.responses.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
+            background=True,
+            conversation="string",
             include=["file_search_call.results"],
+            input="string",
             instructions="instructions",
             max_output_tokens=0,
+            max_tool_calls=0,
             metadata={"foo": "string"},
+            model="gpt-4o",
             parallel_tool_calls=True,
             previous_response_id="previous_response_id",
+            prompt={
+                "id": "id",
+                "variables": {"foo": "string"},
+                "version": "version",
+            },
+            prompt_cache_key="prompt-cache-key-1234",
+            prompt_cache_retention="in-memory",
             reasoning={
-                "effort": "low",
-                "generate_summary": "concise",
+                "effort": "none",
+                "generate_summary": "auto",
+                "summary": "auto",
             },
+            safety_identifier="safety-identifier-1234",
+            service_tier="auto",
             store=True,
+            stream_options={"include_obfuscation": True},
             temperature=1,
-            text={"format": {"type": "text"}},
+            text={
+                "format": {"type": "text"},
+                "verbosity": "low",
+            },
             tool_choice="none",
             tools=[
                 {
-                    "type": "file_search",
-                    "vector_store_ids": ["string"],
-                    "filters": {
-                        "key": "key",
-                        "type": "eq",
-                        "value": "string",
-                    },
-                    "max_num_results": 0,
-                    "ranking_options": {
-                        "ranker": "auto",
-                        "score_threshold": 0,
-                    },
+                    "name": "name",
+                    "parameters": {"foo": "bar"},
+                    "strict": True,
+                    "type": "function",
+                    "description": "description",
                 }
             ],
+            top_logprobs=0,
             top_p=1,
             truncation="auto",
             user="user-1234",
@@ -389,8 +516,6 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn
     @parametrize
     async def test_raw_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.responses.with_raw_response.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
         )
 
@@ -401,8 +526,6 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncOpenAI) -
     @parametrize
     async def test_streaming_response_create_overload_2(self, async_client: AsyncOpenAI) -> None:
         async with async_client.responses.with_streaming_response.create(
-            input="string",
-            model="gpt-4o",
             stream=True,
         ) as response:
             assert not response.is_closed
@@ -414,22 +537,25 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncOpe
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_retrieve_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.responses.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
         )
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
-    async def test_method_retrieve_with_all_params(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_retrieve_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.responses.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
             include=["file_search_call.results"],
+            include_obfuscation=True,
+            starting_after=0,
+            stream=False,
         )
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
-    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+    async def test_raw_response_retrieve_overload_1(self, async_client: AsyncOpenAI) -> None:
         http_response = await async_client.responses.with_raw_response.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
         )
@@ -440,7 +566,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(Response, response, path=["response"])
 
     @parametrize
-    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+    async def test_streaming_response_retrieve_overload_1(self, async_client: AsyncOpenAI) -> None:
         async with async_client.responses.with_streaming_response.retrieve(
             response_id="resp_677efb5139a88190b512bc3fef8e535d",
         ) as http_response:
@@ -453,10 +579,62 @@ async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> N
         assert cast(Any, http_response.is_closed) is True
 
     @parametrize
-    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+    async def test_path_params_retrieve_overload_1(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):
+            await async_client.responses.with_raw_response.retrieve(
+                response_id="",
+            )
+
+    @parametrize
+    async def test_method_retrieve_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response_stream = await async_client.responses.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+        )
+        await response_stream.response.aclose()
+
+    @parametrize
+    async def test_method_retrieve_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response_stream = await async_client.responses.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+            include=["file_search_call.results"],
+            include_obfuscation=True,
+            starting_after=0,
+        )
+        await response_stream.response.aclose()
+
+    @parametrize
+    async def test_raw_response_retrieve_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.responses.with_raw_response.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        await stream.close()
+
+    @parametrize
+    async def test_streaming_response_retrieve_overload_2(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.responses.with_streaming_response.retrieve(
+            response_id="resp_677efb5139a88190b512bc3fef8e535d",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve_overload_2(self, async_client: AsyncOpenAI) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):
             await async_client.responses.with_raw_response.retrieve(
                 response_id="",
+                stream=True,
             )
 
     @parametrize
@@ -496,3 +674,41 @@ async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
             await async_client.responses.with_raw_response.delete(
                 "",
             )
+
+    @parametrize
+    async def test_method_cancel(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.responses.cancel(
+            "resp_677efb5139a88190b512bc3fef8e535d",
+        )
+        assert_matches_type(Response, response, path=["response"])
+
+    @parametrize
+    async def test_raw_response_cancel(self, async_client: AsyncOpenAI) -> None:
+        http_response = await async_client.responses.with_raw_response.cancel(
+            "resp_677efb5139a88190b512bc3fef8e535d",
+        )
+
+        assert http_response.is_closed is True
+        assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
+        response = http_response.parse()
+        assert_matches_type(Response, response, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_cancel(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.responses.with_streaming_response.cancel(
+            "resp_677efb5139a88190b512bc3fef8e535d",
+        ) as http_response:
+            assert not http_response.is_closed
+            assert http_response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            response = await http_response.parse()
+            assert_matches_type(Response, response, path=["response"])
+
+        assert cast(Any, http_response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_cancel(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):
+            await async_client.responses.with_raw_response.cancel(
+                "",
+            )
diff --git a/tests/api_resources/test_uploads.py b/tests/api_resources/test_uploads.py
index a14c4f8da2..0e438a3c61 100644
--- a/tests/api_resources/test_uploads.py
+++ b/tests/api_resources/test_uploads.py
@@ -27,6 +27,20 @@ def test_method_create(self, client: OpenAI) -> None:
         )
         assert_matches_type(Upload, upload, path=["response"])
 
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        upload = client.uploads.create(
+            bytes=0,
+            filename="filename",
+            mime_type="mime_type",
+            purpose="assistants",
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 3600,
+            },
+        )
+        assert_matches_type(Upload, upload, path=["response"])
+
     @parametrize
     def test_raw_response_create(self, client: OpenAI) -> None:
         response = client.uploads.with_raw_response.create(
@@ -148,7 +162,9 @@ def test_path_params_complete(self, client: OpenAI) -> None:
 
 
 class TestAsyncUploads:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
@@ -160,6 +176,20 @@ async def test_method_create(self, async_client: AsyncOpenAI) -> None:
         )
         assert_matches_type(Upload, upload, path=["response"])
 
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        upload = await async_client.uploads.create(
+            bytes=0,
+            filename="filename",
+            mime_type="mime_type",
+            purpose="assistants",
+            expires_after={
+                "anchor": "created_at",
+                "seconds": 3600,
+            },
+        )
+        assert_matches_type(Upload, upload, path=["response"])
+
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.uploads.with_raw_response.create(
diff --git a/tests/api_resources/test_vector_stores.py b/tests/api_resources/test_vector_stores.py
index 54bb75bc1d..cce9c52cea 100644
--- a/tests/api_resources/test_vector_stores.py
+++ b/tests/api_resources/test_vector_stores.py
@@ -31,6 +31,7 @@ def test_method_create(self, client: OpenAI) -> None:
     def test_method_create_with_all_params(self, client: OpenAI) -> None:
         vector_store = client.vector_stores.create(
             chunking_strategy={"type": "auto"},
+            description="description",
             expires_after={
                 "anchor": "last_active_at",
                 "days": 1,
@@ -243,7 +244,7 @@ def test_method_search_with_all_params(self, client: OpenAI) -> None:
             },
             max_num_results=1,
             ranking_options={
-                "ranker": "auto",
+                "ranker": "none",
                 "score_threshold": 0,
             },
             rewrite_query=True,
@@ -286,7 +287,9 @@ def test_path_params_search(self, client: OpenAI) -> None:
 
 
 class TestAsyncVectorStores:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
@@ -297,6 +300,7 @@ async def test_method_create(self, async_client: AsyncOpenAI) -> None:
     async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
         vector_store = await async_client.vector_stores.create(
             chunking_strategy={"type": "auto"},
+            description="description",
             expires_after={
                 "anchor": "last_active_at",
                 "days": 1,
@@ -509,7 +513,7 @@ async def test_method_search_with_all_params(self, async_client: AsyncOpenAI) ->
             },
             max_num_results=1,
             ranking_options={
-                "ranker": "auto",
+                "ranker": "none",
                 "score_threshold": 0,
             },
             rewrite_query=True,
diff --git a/tests/api_resources/test_videos.py b/tests/api_resources/test_videos.py
new file mode 100644
index 0000000000..623cfc2153
--- /dev/null
+++ b/tests/api_resources/test_videos.py
@@ -0,0 +1,551 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import httpx
+import pytest
+from respx import MockRouter
+
+import openai._legacy_response as _legacy_response
+from openai import OpenAI, AsyncOpenAI
+from tests.utils import assert_matches_type
+from openai.types import (
+    Video,
+    VideoDeleteResponse,
+)
+from openai._utils import assert_signatures_in_sync
+from openai.pagination import SyncConversationCursorPage, AsyncConversationCursorPage
+
+# pyright: reportDeprecated=false
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestVideos:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_create(self, client: OpenAI) -> None:
+        video = client.videos.create(
+            prompt="x",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    def test_method_create_with_all_params(self, client: OpenAI) -> None:
+        video = client.videos.create(
+            prompt="x",
+            input_reference=b"raw file contents",
+            model="sora-2",
+            seconds="4",
+            size="720x1280",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    def test_raw_response_create(self, client: OpenAI) -> None:
+        response = client.videos.with_raw_response.create(
+            prompt="x",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    def test_streaming_response_create(self, client: OpenAI) -> None:
+        with client.videos.with_streaming_response.create(
+            prompt="x",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = response.parse()
+            assert_matches_type(Video, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_retrieve(self, client: OpenAI) -> None:
+        video = client.videos.retrieve(
+            "video_123",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    def test_raw_response_retrieve(self, client: OpenAI) -> None:
+        response = client.videos.with_raw_response.retrieve(
+            "video_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    def test_streaming_response_retrieve(self, client: OpenAI) -> None:
+        with client.videos.with_streaming_response.retrieve(
+            "video_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = response.parse()
+            assert_matches_type(Video, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_retrieve(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            client.videos.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    def test_method_list(self, client: OpenAI) -> None:
+        video = client.videos.list()
+        assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: OpenAI) -> None:
+        video = client.videos.list(
+            after="after",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: OpenAI) -> None:
+        response = client.videos.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: OpenAI) -> None:
+        with client.videos.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = response.parse()
+            assert_matches_type(SyncConversationCursorPage[Video], video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_delete(self, client: OpenAI) -> None:
+        video = client.videos.delete(
+            "video_123",
+        )
+        assert_matches_type(VideoDeleteResponse, video, path=["response"])
+
+    @parametrize
+    def test_raw_response_delete(self, client: OpenAI) -> None:
+        response = client.videos.with_raw_response.delete(
+            "video_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(VideoDeleteResponse, video, path=["response"])
+
+    @parametrize
+    def test_streaming_response_delete(self, client: OpenAI) -> None:
+        with client.videos.with_streaming_response.delete(
+            "video_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = response.parse()
+            assert_matches_type(VideoDeleteResponse, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_delete(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            client.videos.with_raw_response.delete(
+                "",
+            )
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_method_download_content(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        video = client.videos.download_content(
+            video_id="video_123",
+        )
+        assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
+        assert video.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_method_download_content_with_all_params(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        video = client.videos.download_content(
+            video_id="video_123",
+            variant="video",
+        )
+        assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
+        assert video.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_raw_response_download_content(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+
+        response = client.videos.with_raw_response.download_content(
+            video_id="video_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(_legacy_response.HttpxBinaryResponseContent, video, path=["response"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_streaming_response_download_content(self, client: OpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        with client.videos.with_streaming_response.download_content(
+            video_id="video_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = response.parse()
+            assert_matches_type(bytes, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    def test_path_params_download_content(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            client.videos.with_raw_response.download_content(
+                video_id="",
+            )
+
+    @parametrize
+    def test_method_remix(self, client: OpenAI) -> None:
+        video = client.videos.remix(
+            video_id="video_123",
+            prompt="x",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    def test_raw_response_remix(self, client: OpenAI) -> None:
+        response = client.videos.with_raw_response.remix(
+            video_id="video_123",
+            prompt="x",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    def test_streaming_response_remix(self, client: OpenAI) -> None:
+        with client.videos.with_streaming_response.remix(
+            video_id="video_123",
+            prompt="x",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = response.parse()
+            assert_matches_type(Video, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_remix(self, client: OpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            client.videos.with_raw_response.remix(
+                video_id="",
+                prompt="x",
+            )
+
+
+class TestAsyncVideos:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_create(self, async_client: AsyncOpenAI) -> None:
+        video = await async_client.videos.create(
+            prompt="x",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        video = await async_client.videos.create(
+            prompt="x",
+            input_reference=b"raw file contents",
+            model="sora-2",
+            seconds="4",
+            size="720x1280",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.videos.with_raw_response.create(
+            prompt="x",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.videos.with_streaming_response.create(
+            prompt="x",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = await response.parse()
+            assert_matches_type(Video, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_retrieve(self, async_client: AsyncOpenAI) -> None:
+        video = await async_client.videos.retrieve(
+            "video_123",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    async def test_raw_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.videos.with_raw_response.retrieve(
+            "video_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_retrieve(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.videos.with_streaming_response.retrieve(
+            "video_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = await response.parse()
+            assert_matches_type(Video, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_retrieve(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            await async_client.videos.with_raw_response.retrieve(
+                "",
+            )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncOpenAI) -> None:
+        video = await async_client.videos.list()
+        assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncOpenAI) -> None:
+        video = await async_client.videos.list(
+            after="after",
+            limit=0,
+            order="asc",
+        )
+        assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.videos.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.videos.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = await response.parse()
+            assert_matches_type(AsyncConversationCursorPage[Video], video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_delete(self, async_client: AsyncOpenAI) -> None:
+        video = await async_client.videos.delete(
+            "video_123",
+        )
+        assert_matches_type(VideoDeleteResponse, video, path=["response"])
+
+    @parametrize
+    async def test_raw_response_delete(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.videos.with_raw_response.delete(
+            "video_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(VideoDeleteResponse, video, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_delete(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.videos.with_streaming_response.delete(
+            "video_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = await response.parse()
+            assert_matches_type(VideoDeleteResponse, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_delete(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            await async_client.videos.with_raw_response.delete(
+                "",
+            )
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_method_download_content(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        video = await async_client.videos.download_content(
+            video_id="video_123",
+        )
+        assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
+        assert video.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_method_download_content_with_all_params(
+        self, async_client: AsyncOpenAI, respx_mock: MockRouter
+    ) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        video = await async_client.videos.download_content(
+            video_id="video_123",
+            variant="video",
+        )
+        assert isinstance(video, _legacy_response.HttpxBinaryResponseContent)
+        assert video.json() == {"foo": "bar"}
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_raw_response_download_content(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+
+        response = await async_client.videos.with_raw_response.download_content(
+            video_id="video_123",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(_legacy_response.HttpxBinaryResponseContent, video, path=["response"])
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_streaming_response_download_content(self, async_client: AsyncOpenAI, respx_mock: MockRouter) -> None:
+        respx_mock.get("/videos/video_123/content").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
+        async with async_client.videos.with_streaming_response.download_content(
+            video_id="video_123",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = await response.parse()
+            assert_matches_type(bytes, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    @pytest.mark.respx(base_url=base_url)
+    async def test_path_params_download_content(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            await async_client.videos.with_raw_response.download_content(
+                video_id="",
+            )
+
+    @parametrize
+    async def test_method_remix(self, async_client: AsyncOpenAI) -> None:
+        video = await async_client.videos.remix(
+            video_id="video_123",
+            prompt="x",
+        )
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    async def test_raw_response_remix(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.videos.with_raw_response.remix(
+            video_id="video_123",
+            prompt="x",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        video = response.parse()
+        assert_matches_type(Video, video, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_remix(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.videos.with_streaming_response.remix(
+            video_id="video_123",
+            prompt="x",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            video = await response.parse()
+            assert_matches_type(Video, video, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_remix(self, async_client: AsyncOpenAI) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `video_id` but received ''"):
+            await async_client.videos.with_raw_response.remix(
+                video_id="",
+                prompt="x",
+            )
+
+
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_create_and_poll_method_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpenAI) -> None:
+    checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
+
+    assert_signatures_in_sync(
+        checking_client.videos.create,
+        checking_client.videos.create_and_poll,
+        exclude_params={"extra_headers", "extra_query", "extra_body", "timeout"},
+    )
diff --git a/tests/api_resources/test_webhooks.py b/tests/api_resources/test_webhooks.py
new file mode 100644
index 0000000000..6b404998e1
--- /dev/null
+++ b/tests/api_resources/test_webhooks.py
@@ -0,0 +1,284 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from unittest import mock
+
+import pytest
+
+import openai
+from openai._exceptions import InvalidWebhookSignatureError
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+# Standardized test constants (matches TypeScript implementation)
+TEST_SECRET = "whsec_RdvaYFYUXuIFuEbvZHwMfYFhUf7aMYjYcmM24+Aj40c="
+TEST_PAYLOAD = '{"id": "evt_685c059ae3a481909bdc86819b066fb6", "object": "event", "created_at": 1750861210, "type": "response.completed", "data": {"id": "resp_123"}}'
+TEST_TIMESTAMP = 1750861210  # Fixed timestamp that matches our test signature
+TEST_WEBHOOK_ID = "wh_685c059ae39c8190af8c71ed1022a24d"
+TEST_SIGNATURE = "v1,gUAg4R2hWouRZqRQG4uJypNS8YK885G838+EHb4nKBY="
+
+
+def create_test_headers(
+    timestamp: int | None = None, signature: str | None = None, webhook_id: str | None = None
+) -> dict[str, str]:
+    """Helper function to create test headers"""
+    return {
+        "webhook-signature": signature or TEST_SIGNATURE,
+        "webhook-timestamp": str(timestamp or TEST_TIMESTAMP),
+        "webhook-id": webhook_id or TEST_WEBHOOK_ID,
+    }
+
+
+class TestWebhooks:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_unwrap_with_secret(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        unwrapped = client.webhooks.unwrap(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+        assert unwrapped.id == "evt_685c059ae3a481909bdc86819b066fb6"
+        assert unwrapped.created_at == 1750861210
+
+    @parametrize
+    def test_unwrap_without_secret(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        with pytest.raises(ValueError, match="The webhook secret must either be set"):
+            client.webhooks.unwrap(TEST_PAYLOAD, headers)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_valid(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        # Should not raise - this is a truly valid signature for this timestamp
+        client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @parametrize
+    def test_verify_signature_invalid_secret_format(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        with pytest.raises(ValueError, match="The webhook secret must either be set"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=None)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_invalid(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        with pytest.raises(InvalidWebhookSignatureError, match="The given webhook signature does not match"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret="invalid_secret")
+
+    @parametrize
+    def test_verify_signature_missing_webhook_signature_header(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers(signature=None)
+        del headers["webhook-signature"]
+        with pytest.raises(ValueError, match="Could not find webhook-signature header"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @parametrize
+    def test_verify_signature_missing_webhook_timestamp_header(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        del headers["webhook-timestamp"]
+        with pytest.raises(ValueError, match="Could not find webhook-timestamp header"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @parametrize
+    def test_verify_signature_missing_webhook_id_header(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        del headers["webhook-id"]
+        with pytest.raises(ValueError, match="Could not find webhook-id header"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_payload_bytes(self, client: openai.OpenAI) -> None:
+        headers = create_test_headers()
+        client.webhooks.verify_signature(TEST_PAYLOAD.encode("utf-8"), headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    def test_unwrap_with_client_secret(self) -> None:
+        test_client = openai.OpenAI(base_url=base_url, api_key="test-api-key", webhook_secret=TEST_SECRET)
+        headers = create_test_headers()
+
+        unwrapped = test_client.webhooks.unwrap(TEST_PAYLOAD, headers)
+        assert unwrapped.id == "evt_685c059ae3a481909bdc86819b066fb6"
+        assert unwrapped.created_at == 1750861210
+
+    @parametrize
+    def test_verify_signature_timestamp_too_old(self, client: openai.OpenAI) -> None:
+        # Use a timestamp that's older than 5 minutes from our test timestamp
+        old_timestamp = TEST_TIMESTAMP - 400  # 6 minutes 40 seconds ago
+        headers = create_test_headers(timestamp=old_timestamp, signature="v1,dummy_signature")
+
+        with pytest.raises(InvalidWebhookSignatureError, match="Webhook timestamp is too old"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_timestamp_too_new(self, client: openai.OpenAI) -> None:
+        # Use a timestamp that's in the future beyond tolerance from our test timestamp
+        future_timestamp = TEST_TIMESTAMP + 400  # 6 minutes 40 seconds in the future
+        headers = create_test_headers(timestamp=future_timestamp, signature="v1,dummy_signature")
+
+        with pytest.raises(InvalidWebhookSignatureError, match="Webhook timestamp is too new"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_custom_tolerance(self, client: openai.OpenAI) -> None:
+        # Use a timestamp that's older than default tolerance but within custom tolerance
+        old_timestamp = TEST_TIMESTAMP - 400  # 6 minutes 40 seconds ago from test timestamp
+        headers = create_test_headers(timestamp=old_timestamp, signature="v1,dummy_signature")
+
+        # Should fail with default tolerance
+        with pytest.raises(InvalidWebhookSignatureError, match="Webhook timestamp is too old"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+        # Should also fail with custom tolerance of 10 minutes (signature won't match)
+        with pytest.raises(InvalidWebhookSignatureError, match="The given webhook signature does not match"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET, tolerance=600)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_recent_timestamp_succeeds(self, client: openai.OpenAI) -> None:
+        # Use a recent timestamp with dummy signature
+        headers = create_test_headers(signature="v1,dummy_signature")
+
+        # Should fail on signature verification (not timestamp validation)
+        with pytest.raises(InvalidWebhookSignatureError, match="The given webhook signature does not match"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_multiple_signatures_one_valid(self, client: openai.OpenAI) -> None:
+        # Test multiple signatures: one invalid, one valid
+        multiple_signatures = f"v1,invalid_signature {TEST_SIGNATURE}"
+        headers = create_test_headers(signature=multiple_signatures)
+
+        # Should not raise when at least one signature is valid
+        client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    def test_verify_signature_multiple_signatures_all_invalid(self, client: openai.OpenAI) -> None:
+        # Test multiple invalid signatures
+        multiple_invalid_signatures = "v1,invalid_signature1 v1,invalid_signature2"
+        headers = create_test_headers(signature=multiple_invalid_signatures)
+
+        with pytest.raises(InvalidWebhookSignatureError, match="The given webhook signature does not match"):
+            client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+
+class TestAsyncWebhooks:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    async def test_unwrap_with_secret(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        unwrapped = async_client.webhooks.unwrap(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+        assert unwrapped.id == "evt_685c059ae3a481909bdc86819b066fb6"
+        assert unwrapped.created_at == 1750861210
+
+    @parametrize
+    async def test_unwrap_without_secret(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        with pytest.raises(ValueError, match="The webhook secret must either be set"):
+            async_client.webhooks.unwrap(TEST_PAYLOAD, headers)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    async def test_verify_signature_valid(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        # Should not raise - this is a truly valid signature for this timestamp
+        async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @parametrize
+    async def test_verify_signature_invalid_secret_format(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        with pytest.raises(ValueError, match="The webhook secret must either be set"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=None)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    async def test_verify_signature_invalid(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        with pytest.raises(InvalidWebhookSignatureError, match="The given webhook signature does not match"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret="invalid_secret")
+
+    @parametrize
+    async def test_verify_signature_missing_webhook_signature_header(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        del headers["webhook-signature"]
+        with pytest.raises(ValueError, match="Could not find webhook-signature header"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @parametrize
+    async def test_verify_signature_missing_webhook_timestamp_header(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        del headers["webhook-timestamp"]
+        with pytest.raises(ValueError, match="Could not find webhook-timestamp header"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @parametrize
+    async def test_verify_signature_missing_webhook_id_header(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        del headers["webhook-id"]
+        with pytest.raises(ValueError, match="Could not find webhook-id header"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    async def test_verify_signature_payload_bytes(self, async_client: openai.AsyncOpenAI) -> None:
+        headers = create_test_headers()
+        async_client.webhooks.verify_signature(TEST_PAYLOAD.encode("utf-8"), headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    async def test_unwrap_with_client_secret(self) -> None:
+        test_async_client = openai.AsyncOpenAI(base_url=base_url, api_key="test-api-key", webhook_secret=TEST_SECRET)
+        headers = create_test_headers()
+
+        unwrapped = test_async_client.webhooks.unwrap(TEST_PAYLOAD, headers)
+        assert unwrapped.id == "evt_685c059ae3a481909bdc86819b066fb6"
+        assert unwrapped.created_at == 1750861210
+
+    @parametrize
+    async def test_verify_signature_timestamp_too_old(self, async_client: openai.AsyncOpenAI) -> None:
+        # Use a timestamp that's older than 5 minutes from our test timestamp
+        old_timestamp = TEST_TIMESTAMP - 400  # 6 minutes 40 seconds ago
+        headers = create_test_headers(timestamp=old_timestamp, signature="v1,dummy_signature")
+
+        with pytest.raises(InvalidWebhookSignatureError, match="Webhook timestamp is too old"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    async def test_verify_signature_timestamp_too_new(self, async_client: openai.AsyncOpenAI) -> None:
+        # Use a timestamp that's in the future beyond tolerance from our test timestamp
+        future_timestamp = TEST_TIMESTAMP + 400  # 6 minutes 40 seconds in the future
+        headers = create_test_headers(timestamp=future_timestamp, signature="v1,dummy_signature")
+
+        with pytest.raises(InvalidWebhookSignatureError, match="Webhook timestamp is too new"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    async def test_verify_signature_multiple_signatures_one_valid(self, async_client: openai.AsyncOpenAI) -> None:
+        # Test multiple signatures: one invalid, one valid
+        multiple_signatures = f"v1,invalid_signature {TEST_SIGNATURE}"
+        headers = create_test_headers(signature=multiple_signatures)
+
+        # Should not raise when at least one signature is valid
+        async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
+
+    @mock.patch("time.time", mock.MagicMock(return_value=TEST_TIMESTAMP))
+    @parametrize
+    async def test_verify_signature_multiple_signatures_all_invalid(self, async_client: openai.AsyncOpenAI) -> None:
+        # Test multiple invalid signatures
+        multiple_invalid_signatures = "v1,invalid_signature1 v1,invalid_signature2"
+        headers = create_test_headers(signature=multiple_invalid_signatures)
+
+        with pytest.raises(InvalidWebhookSignatureError, match="The given webhook signature does not match"):
+            async_client.webhooks.verify_signature(TEST_PAYLOAD, headers, secret=TEST_SECRET)
diff --git a/tests/api_resources/uploads/test_parts.py b/tests/api_resources/uploads/test_parts.py
index 2bba241a6d..191d3a1b04 100644
--- a/tests/api_resources/uploads/test_parts.py
+++ b/tests/api_resources/uploads/test_parts.py
@@ -61,7 +61,9 @@ def test_path_params_create(self, client: OpenAI) -> None:
 
 
 class TestAsyncParts:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
diff --git a/tests/api_resources/vector_stores/test_file_batches.py b/tests/api_resources/vector_stores/test_file_batches.py
index 0587cfc56a..abbefc20e9 100644
--- a/tests/api_resources/vector_stores/test_file_batches.py
+++ b/tests/api_resources/vector_stores/test_file_batches.py
@@ -25,7 +25,6 @@ class TestFileBatches:
     def test_method_create(self, client: OpenAI) -> None:
         file_batch = client.vector_stores.file_batches.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
         )
         assert_matches_type(VectorStoreFileBatch, file_batch, path=["response"])
 
@@ -33,9 +32,16 @@ def test_method_create(self, client: OpenAI) -> None:
     def test_method_create_with_all_params(self, client: OpenAI) -> None:
         file_batch = client.vector_stores.file_batches.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
             attributes={"foo": "string"},
             chunking_strategy={"type": "auto"},
+            file_ids=["string"],
+            files=[
+                {
+                    "file_id": "file_id",
+                    "attributes": {"foo": "string"},
+                    "chunking_strategy": {"type": "auto"},
+                }
+            ],
         )
         assert_matches_type(VectorStoreFileBatch, file_batch, path=["response"])
 
@@ -43,7 +49,6 @@ def test_method_create_with_all_params(self, client: OpenAI) -> None:
     def test_raw_response_create(self, client: OpenAI) -> None:
         response = client.vector_stores.file_batches.with_raw_response.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
         )
 
         assert response.is_closed is True
@@ -55,7 +60,6 @@ def test_raw_response_create(self, client: OpenAI) -> None:
     def test_streaming_response_create(self, client: OpenAI) -> None:
         with client.vector_stores.file_batches.with_streaming_response.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -70,7 +74,6 @@ def test_path_params_create(self, client: OpenAI) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `vector_store_id` but received ''"):
             client.vector_stores.file_batches.with_raw_response.create(
                 vector_store_id="",
-                file_ids=["string"],
             )
 
     @parametrize
@@ -232,13 +235,14 @@ def test_path_params_list_files(self, client: OpenAI) -> None:
 
 
 class TestAsyncFileBatches:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
         file_batch = await async_client.vector_stores.file_batches.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
         )
         assert_matches_type(VectorStoreFileBatch, file_batch, path=["response"])
 
@@ -246,9 +250,16 @@ async def test_method_create(self, async_client: AsyncOpenAI) -> None:
     async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) -> None:
         file_batch = await async_client.vector_stores.file_batches.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
             attributes={"foo": "string"},
             chunking_strategy={"type": "auto"},
+            file_ids=["string"],
+            files=[
+                {
+                    "file_id": "file_id",
+                    "attributes": {"foo": "string"},
+                    "chunking_strategy": {"type": "auto"},
+                }
+            ],
         )
         assert_matches_type(VectorStoreFileBatch, file_batch, path=["response"])
 
@@ -256,7 +267,6 @@ async def test_method_create_with_all_params(self, async_client: AsyncOpenAI) ->
     async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.vector_stores.file_batches.with_raw_response.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
         )
 
         assert response.is_closed is True
@@ -268,7 +278,6 @@ async def test_raw_response_create(self, async_client: AsyncOpenAI) -> None:
     async def test_streaming_response_create(self, async_client: AsyncOpenAI) -> None:
         async with async_client.vector_stores.file_batches.with_streaming_response.create(
             vector_store_id="vs_abc123",
-            file_ids=["string"],
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -283,7 +292,6 @@ async def test_path_params_create(self, async_client: AsyncOpenAI) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `vector_store_id` but received ''"):
             await async_client.vector_stores.file_batches.with_raw_response.create(
                 vector_store_id="",
-                file_ids=["string"],
             )
 
     @parametrize
diff --git a/tests/api_resources/vector_stores/test_files.py b/tests/api_resources/vector_stores/test_files.py
index c13442261e..7394b50d95 100644
--- a/tests/api_resources/vector_stores/test_files.py
+++ b/tests/api_resources/vector_stores/test_files.py
@@ -9,6 +9,7 @@
 
 from openai import OpenAI, AsyncOpenAI
 from tests.utils import assert_matches_type
+from openai._utils import assert_signatures_in_sync
 from openai.pagination import SyncPage, AsyncPage, SyncCursorPage, AsyncCursorPage
 from openai.types.vector_stores import (
     VectorStoreFile,
@@ -323,7 +324,9 @@ def test_path_params_content(self, client: OpenAI) -> None:
 
 
 class TestAsyncFiles:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
 
     @parametrize
     async def test_method_create(self, async_client: AsyncOpenAI) -> None:
@@ -623,3 +626,25 @@ async def test_path_params_content(self, async_client: AsyncOpenAI) -> None:
                 file_id="",
                 vector_store_id="vs_abc123",
             )
+
+
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_create_and_poll_method_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpenAI) -> None:
+    checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
+
+    assert_signatures_in_sync(
+        checking_client.vector_stores.files.create,
+        checking_client.vector_stores.files.create_and_poll,
+        exclude_params={"extra_headers", "extra_query", "extra_body", "timeout"},
+    )
+
+
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_upload_and_poll_method_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpenAI) -> None:
+    checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
+
+    assert_signatures_in_sync(
+        checking_client.vector_stores.files.create,
+        checking_client.vector_stores.files.upload_and_poll,
+        exclude_params={"file_id", "extra_headers", "extra_query", "extra_body", "timeout"},
+    )
diff --git a/tests/compat/test_tool_param.py b/tests/compat/test_tool_param.py
new file mode 100644
index 0000000000..f2f84c6e94
--- /dev/null
+++ b/tests/compat/test_tool_param.py
@@ -0,0 +1,8 @@
+from openai.types.chat import ChatCompletionToolParam
+
+
+def test_tool_param_can_be_instantiated() -> None:
+    assert ChatCompletionToolParam(type="function", function={"name": "test"}) == {
+        "function": {"name": "test"},
+        "type": "function",
+    }
diff --git a/tests/conftest.py b/tests/conftest.py
index fa82d39d86..408bcf76c0 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,16 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
 from __future__ import annotations
 
 import os
 import logging
 from typing import TYPE_CHECKING, Iterator, AsyncIterator
 
+import httpx
 import pytest
 from pytest_asyncio import is_async_test
 
-from openai import OpenAI, AsyncOpenAI
+from openai import OpenAI, AsyncOpenAI, DefaultAioHttpClient
+from openai._utils import is_dict
 
 if TYPE_CHECKING:
-    from _pytest.fixtures import FixtureRequest
+    from _pytest.fixtures import FixtureRequest  # pyright: ignore[reportPrivateImportUsage]
 
 pytest.register_assert_rewrite("tests.utils")
 
@@ -25,6 +29,19 @@ def pytest_collection_modifyitems(items: list[pytest.Function]) -> None:
     for async_test in pytest_asyncio_tests:
         async_test.add_marker(session_scope_marker, append=False)
 
+    # We skip tests that use both the aiohttp client and respx_mock as respx_mock
+    # doesn't support custom transports.
+    for item in items:
+        if "async_client" not in item.fixturenames or "respx_mock" not in item.fixturenames:
+            continue
+
+        if not hasattr(item, "callspec"):
+            continue
+
+        async_client_param = item.callspec.params.get("async_client")
+        if is_dict(async_client_param) and async_client_param.get("http_client") == "aiohttp":
+            item.add_marker(pytest.mark.skip(reason="aiohttp client is not compatible with respx_mock"))
+
 
 base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 
@@ -43,9 +60,25 @@ def client(request: FixtureRequest) -> Iterator[OpenAI]:
 
 @pytest.fixture(scope="session")
 async def async_client(request: FixtureRequest) -> AsyncIterator[AsyncOpenAI]:
-    strict = getattr(request, "param", True)
-    if not isinstance(strict, bool):
-        raise TypeError(f"Unexpected fixture parameter type {type(strict)}, expected {bool}")
-
-    async with AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=strict) as client:
+    param = getattr(request, "param", True)
+
+    # defaults
+    strict = True
+    http_client: None | httpx.AsyncClient = None
+
+    if isinstance(param, bool):
+        strict = param
+    elif is_dict(param):
+        strict = param.get("strict", True)
+        assert isinstance(strict, bool)
+
+        http_client_type = param.get("http_client", "httpx")
+        if http_client_type == "aiohttp":
+            http_client = DefaultAioHttpClient()
+    else:
+        raise TypeError(f"Unexpected fixture parameter type {type(param)}, expected bool or dict")
+
+    async with AsyncOpenAI(
+        base_url=base_url, api_key=api_key, _strict_response_validation=strict, http_client=http_client
+    ) as client:
         yield client
diff --git a/tests/lib/chat/test_completions.py b/tests/lib/chat/test_completions.py
index 62fdd34c0a..afad5a1391 100644
--- a/tests/lib/chat/test_completions.py
+++ b/tests/lib/chat/test_completions.py
@@ -1,12 +1,9 @@
 from __future__ import annotations
 
-import os
-import json
 from enum import Enum
-from typing import Any, List, Callable, Optional, Awaitable
+from typing import List, Optional
 from typing_extensions import Literal, TypeVar
 
-import httpx
 import pytest
 from respx import MockRouter
 from pydantic import Field, BaseModel
@@ -15,10 +12,11 @@
 import openai
 from openai import OpenAI, AsyncOpenAI
 from openai._utils import assert_signatures_in_sync
-from openai._compat import PYDANTIC_V2
+from openai._compat import PYDANTIC_V1
 
-from ._utils import print_obj
+from ..utils import print_obj
 from ...conftest import base_url
+from ..snapshots import make_snapshot_request, make_async_snapshot_request
 from ..schema_types.query import Query
 
 _T = TypeVar("_T")
@@ -27,13 +25,13 @@
 #
 # you can update them with
 #
-# `OPENAI_LIVE=1 pytest --inline-snapshot=fix`
+# `OPENAI_LIVE=1 pytest --inline-snapshot=fix -p no:xdist -o addopts=""`
 
 
 @pytest.mark.respx(base_url=base_url)
 def test_parse_nothing(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -45,6 +43,7 @@ def test_parse_nothing(client: OpenAI, respx_mock: MockRouter, monkeypatch: pyte
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvaueLEMLNYbT8YzpJxsmiQ6HSY", "object": "chat.completion", "created": 1727346142, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "I\'m unable to provide real-time weather updates. To get the current weather in San Francisco, I recommend checking a reliable weather website or app like the Weather Channel or a local news station.", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 14, "completion_tokens": 37, "total_tokens": 51, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_b40fb1c6fb"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -100,8 +99,8 @@ class Location(BaseModel):
         temperature: float
         units: Literal["c", "f"]
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -114,6 +113,7 @@ class Location(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvbtVnTu5DeC4EFnRYj8mtfOM99", "object": "chat.completion", "created": 1727346143, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"city\\":\\"San Francisco\\",\\"temperature\\":65,\\"units\\":\\"f\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 79, "completion_tokens": 14, "total_tokens": 93, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_5050236cbd"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -170,8 +170,8 @@ class Location(BaseModel):
         temperature: float
         units: Optional[Literal["c", "f"]] = None
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -184,6 +184,7 @@ class Location(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvcC8grKYsRkSoMp9CCAhbXAd0b", "object": "chat.completion", "created": 1727346144, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"city\\":\\"San Francisco\\",\\"temperature\\":65,\\"units\\":\\"f\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 88, "completion_tokens": 14, "total_tokens": 102, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_b40fb1c6fb"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -244,11 +245,11 @@ class ColorDetection(BaseModel):
         color: Color
         hex_color_code: str = Field(description="The hex color code of the detected color")
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         ColorDetection.update_forward_refs(**locals())  # type: ignore
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {"role": "user", "content": "What color is a Coke can?"},
@@ -258,6 +259,7 @@ class ColorDetection(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvjIatz0zrZu50gRbMtlp0asZpz", "object": "chat.completion", "created": 1727346151, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"color\\":\\"red\\",\\"hex_color_code\\":\\"#FF0000\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 109, "completion_tokens": 14, "total_tokens": 123, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_5050236cbd"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -292,8 +294,8 @@ class Location(BaseModel):
         temperature: float
         units: Literal["c", "f"]
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -307,6 +309,7 @@ class Location(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvp8qzboW92q8ONDF4DPHlI7ckC", "object": "chat.completion", "created": 1727346157, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"city\\":\\"San Francisco\\",\\"temperature\\":64,\\"units\\":\\"f\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}, {"index": 1, "message": {"role": "assistant", "content": "{\\"city\\":\\"San Francisco\\",\\"temperature\\":65,\\"units\\":\\"f\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}, {"index": 2, "message": {"role": "assistant", "content": "{\\"city\\":\\"San Francisco\\",\\"temperature\\":63.0,\\"units\\":\\"f\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 79, "completion_tokens": 44, "total_tokens": 123, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_b40fb1c6fb"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -365,7 +368,7 @@ class Location(BaseModel):
 
 
 @pytest.mark.respx(base_url=base_url)
-@pytest.mark.skipif(not PYDANTIC_V2, reason="dataclasses only supported in v2")
+@pytest.mark.skipif(PYDANTIC_V1, reason="dataclasses only supported in v2")
 def test_parse_pydantic_dataclass(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
     from pydantic.dataclasses import dataclass
 
@@ -375,8 +378,8 @@ class CalendarEvent:
         date: str
         participants: List[str]
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {"role": "system", "content": "Extract the event information."},
@@ -387,6 +390,7 @@ class CalendarEvent:
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvqhz4uUUWsw8Ohw2Mp9B4sKKV8", "object": "chat.completion", "created": 1727346158, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"name\\":\\"Science Fair\\",\\"date\\":\\"Friday\\",\\"participants\\":[\\"Alice\\",\\"Bob\\"]}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 92, "completion_tokens": 17, "total_tokens": 109, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_7568d46099"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -436,8 +440,8 @@ class CalendarEvent:
 
 @pytest.mark.respx(base_url=base_url)
 def test_pydantic_tool_model_all_types(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -451,6 +455,7 @@ def test_pydantic_tool_model_all_types(client: OpenAI, respx_mock: MockRouter, m
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvtNiaTNUF6OymZUnEFc9lPq9p1", "object": "chat.completion", "created": 1727346161, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": null, "tool_calls": [{"id": "call_NKpApJybW1MzOjZO2FzwYw0d", "type": "function", "function": {"name": "Query", "arguments": "{\\"name\\":\\"May 2022 Fulfilled Orders Not Delivered on Time\\",\\"table_name\\":\\"orders\\",\\"columns\\":[\\"id\\",\\"status\\",\\"expected_delivery_date\\",\\"delivered_at\\",\\"shipped_at\\",\\"ordered_at\\",\\"canceled_at\\"],\\"conditions\\":[{\\"column\\":\\"ordered_at\\",\\"operator\\":\\">=\\",\\"value\\":\\"2022-05-01\\"},{\\"column\\":\\"ordered_at\\",\\"operator\\":\\"<=\\",\\"value\\":\\"2022-05-31\\"},{\\"column\\":\\"status\\",\\"operator\\":\\"=\\",\\"value\\":\\"fulfilled\\"},{\\"column\\":\\"delivered_at\\",\\"operator\\":\\">\\",\\"value\\":{\\"column_name\\":\\"expected_delivery_date\\"}}],\\"order_by\\":\\"asc\\"}"}}], "refusal": null}, "logprobs": null, "finish_reason": "tool_calls"}], "usage": {"prompt_tokens": 512, "completion_tokens": 132, "total_tokens": 644, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_7568d46099"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -521,8 +526,8 @@ class Location(BaseModel):
         units: Literal["c", "f"]
 
     with pytest.raises(openai.LengthFinishReasonError):
-        _make_snapshot_request(
-            lambda c: c.beta.chat.completions.parse(
+        make_snapshot_request(
+            lambda c: c.chat.completions.parse(
                 model="gpt-4o-2024-08-06",
                 messages=[
                     {
@@ -536,6 +541,7 @@ class Location(BaseModel):
             content_snapshot=snapshot(
                 '{"id": "chatcmpl-ABfvvX7eB1KsfeZj8VcF3z7G7SbaA", "object": "chat.completion", "created": 1727346163, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"", "refusal": null}, "logprobs": null, "finish_reason": "length"}], "usage": {"prompt_tokens": 79, "completion_tokens": 1, "total_tokens": 80, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_7568d46099"}'
             ),
+            path="/chat/completions",
             mock_client=client,
             respx_mock=respx_mock,
         )
@@ -548,8 +554,8 @@ class Location(BaseModel):
         temperature: float
         units: Literal["c", "f"]
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -562,6 +568,7 @@ class Location(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvwoKVWPQj2UPlAcAKM7s40GsRx", "object": "chat.completion", "created": 1727346164, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": null, "refusal": "I\'m very sorry, but I can\'t assist with that."}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 79, "completion_tokens": 12, "total_tokens": 91, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_5050236cbd"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -596,8 +603,8 @@ class GetWeatherArgs(BaseModel):
         country: str
         units: Literal["c", "f"] = "c"
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -612,6 +619,7 @@ class GetWeatherArgs(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvx6Z4dchiW2nya1N8KMsHFrQRE", "object": "chat.completion", "created": 1727346165, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": null, "tool_calls": [{"id": "call_Y6qJ7ofLgOrBnMD5WbVAeiRV", "type": "function", "function": {"name": "GetWeatherArgs", "arguments": "{\\"city\\":\\"Edinburgh\\",\\"country\\":\\"UK\\",\\"units\\":\\"c\\"}"}}], "refusal": null}, "logprobs": null, "finish_reason": "tool_calls"}], "usage": {"prompt_tokens": 76, "completion_tokens": 24, "total_tokens": 100, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_e45dabd248"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -662,8 +670,8 @@ class GetStockPrice(BaseModel):
         ticker: str
         exchange: str
 
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -685,6 +693,7 @@ class GetStockPrice(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvyvfNWKcl7Ohqos4UFrmMs1v4C", "object": "chat.completion", "created": 1727346166, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": null, "tool_calls": [{"id": "call_fdNz3vOBKYgOIpMdWotB9MjY", "type": "function", "function": {"name": "GetWeatherArgs", "arguments": "{\\"city\\": \\"Edinburgh\\", \\"country\\": \\"GB\\", \\"units\\": \\"c\\"}"}}, {"id": "call_h1DWI1POMJLb0KwIyQHWXD4p", "type": "function", "function": {"name": "get_stock_price", "arguments": "{\\"ticker\\": \\"AAPL\\", \\"exchange\\": \\"NASDAQ\\"}"}}], "refusal": null}, "logprobs": null, "finish_reason": "tool_calls"}], "usage": {"prompt_tokens": 149, "completion_tokens": 60, "total_tokens": 209, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_b40fb1c6fb"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -733,8 +742,8 @@ class GetStockPrice(BaseModel):
 
 @pytest.mark.respx(base_url=base_url)
 def test_parse_strict_tools(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
-    completion = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.parse(
+    completion = make_snapshot_request(
+        lambda c: c.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -767,6 +776,7 @@ def test_parse_strict_tools(client: OpenAI, respx_mock: MockRouter, monkeypatch:
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABfvzdvCI6RaIkiEFNjqGXCSYnlzf", "object": "chat.completion", "created": 1727346167, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": null, "tool_calls": [{"id": "call_CUdUoJpsWWVdxXntucvnol1M", "type": "function", "function": {"name": "get_weather", "arguments": "{\\"city\\":\\"San Francisco\\",\\"state\\":\\"CA\\"}"}}], "refusal": null}, "logprobs": null, "finish_reason": "tool_calls"}], "usage": {"prompt_tokens": 48, "completion_tokens": 19, "total_tokens": 67, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_5050236cbd"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
@@ -808,7 +818,7 @@ def test_parse_non_strict_tools(client: OpenAI) -> None:
     with pytest.raises(
         ValueError, match="`get_weather` is not strict. Only `strict` function tools can be auto-parsed"
     ):
-        client.beta.chat.completions.parse(
+        client.chat.completions.parse(
             model="gpt-4o-2024-08-06",
             messages=[],
             tools=[
@@ -830,8 +840,8 @@ class Location(BaseModel):
         temperature: float
         units: Literal["c", "f"]
 
-    response = _make_snapshot_request(
-        lambda c: c.beta.chat.completions.with_raw_response.parse(
+    response = make_snapshot_request(
+        lambda c: c.chat.completions.with_raw_response.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -844,10 +854,11 @@ class Location(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABrDYCa8W1w66eUxKDO8TQF1m6trT", "object": "chat.completion", "created": 1727389540, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"city\\":\\"San Francisco\\",\\"temperature\\":58,\\"units\\":\\"f\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 79, "completion_tokens": 14, "total_tokens": 93, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_5050236cbd"}'
         ),
+        path="/chat/completions",
         mock_client=client,
         respx_mock=respx_mock,
     )
-    assert response.http_request.headers.get("x-stainless-helper-method") == "beta.chat.completions.parse"
+    assert response.http_request.headers.get("x-stainless-helper-method") == "chat.completions.parse"
 
     completion = response.parse()
     message = completion.choices[0].message
@@ -906,8 +917,8 @@ class Location(BaseModel):
         temperature: float
         units: Literal["c", "f"]
 
-    response = await _make_async_snapshot_request(
-        lambda c: c.beta.chat.completions.with_raw_response.parse(
+    response = await make_async_snapshot_request(
+        lambda c: c.chat.completions.with_raw_response.parse(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -920,10 +931,11 @@ class Location(BaseModel):
         content_snapshot=snapshot(
             '{"id": "chatcmpl-ABrDQWOiw0PK5JOsxl1D9ooeQgznq", "object": "chat.completion", "created": 1727389532, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\\"city\\":\\"San Francisco\\",\\"temperature\\":65,\\"units\\":\\"f\\"}", "refusal": null}, "logprobs": null, "finish_reason": "stop"}], "usage": {"prompt_tokens": 79, "completion_tokens": 14, "total_tokens": 93, "completion_tokens_details": {"reasoning_tokens": 0}}, "system_fingerprint": "fp_5050236cbd"}'
         ),
+        path="/chat/completions",
         mock_client=async_client,
         respx_mock=respx_mock,
     )
-    assert response.http_request.headers.get("x-stainless-helper-method") == "beta.chat.completions.parse"
+    assert response.http_request.headers.get("x-stainless-helper-method") == "chat.completions.parse"
 
     completion = response.parse()
     message = completion.choices[0].message
@@ -978,90 +990,6 @@ def test_parse_method_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpe
 
     assert_signatures_in_sync(
         checking_client.chat.completions.create,
-        checking_client.beta.chat.completions.parse,
+        checking_client.chat.completions.parse,
         exclude_params={"response_format", "stream"},
     )
-
-
-def _make_snapshot_request(
-    func: Callable[[OpenAI], _T],
-    *,
-    content_snapshot: Any,
-    respx_mock: MockRouter,
-    mock_client: OpenAI,
-) -> _T:
-    live = os.environ.get("OPENAI_LIVE") == "1"
-    if live:
-
-        def _on_response(response: httpx.Response) -> None:
-            # update the content snapshot
-            assert json.dumps(json.loads(response.read())) == content_snapshot
-
-        respx_mock.stop()
-
-        client = OpenAI(
-            http_client=httpx.Client(
-                event_hooks={
-                    "response": [_on_response],
-                }
-            )
-        )
-    else:
-        respx_mock.post("/chat/completions").mock(
-            return_value=httpx.Response(
-                200,
-                content=content_snapshot._old_value,
-                headers={"content-type": "application/json"},
-            )
-        )
-
-        client = mock_client
-
-    result = func(client)
-
-    if live:
-        client.close()
-
-    return result
-
-
-async def _make_async_snapshot_request(
-    func: Callable[[AsyncOpenAI], Awaitable[_T]],
-    *,
-    content_snapshot: Any,
-    respx_mock: MockRouter,
-    mock_client: AsyncOpenAI,
-) -> _T:
-    live = os.environ.get("OPENAI_LIVE") == "1"
-    if live:
-
-        async def _on_response(response: httpx.Response) -> None:
-            # update the content snapshot
-            assert json.dumps(json.loads(await response.aread())) == content_snapshot
-
-        respx_mock.stop()
-
-        client = AsyncOpenAI(
-            http_client=httpx.AsyncClient(
-                event_hooks={
-                    "response": [_on_response],
-                }
-            )
-        )
-    else:
-        respx_mock.post("/chat/completions").mock(
-            return_value=httpx.Response(
-                200,
-                content=content_snapshot._old_value,
-                headers={"content-type": "application/json"},
-            )
-        )
-
-        client = mock_client
-
-    result = await func(client)
-
-    if live:
-        await client.close()
-
-    return result
diff --git a/tests/lib/chat/test_completions_streaming.py b/tests/lib/chat/test_completions_streaming.py
index 5852c5a343..548416dfe2 100644
--- a/tests/lib/chat/test_completions_streaming.py
+++ b/tests/lib/chat/test_completions_streaming.py
@@ -9,7 +9,12 @@
 import pytest
 from respx import MockRouter
 from pydantic import BaseModel
-from inline_snapshot import external, snapshot, outsource
+from inline_snapshot import (
+    external,
+    snapshot,
+    outsource,  # pyright: ignore[reportUnknownVariableType]
+    get_snapshot_value,
+)
 
 import openai
 from openai import OpenAI, AsyncOpenAI
@@ -26,7 +31,7 @@
 )
 from openai.lib._parsing._completions import ResponseFormatT
 
-from ._utils import print_obj
+from ..utils import print_obj
 from ...conftest import base_url
 
 _T = TypeVar("_T")
@@ -35,13 +40,13 @@
 #
 # you can update them with
 #
-# `OPENAI_LIVE=1 pytest --inline-snapshot=fix`
+# `OPENAI_LIVE=1 pytest --inline-snapshot=fix -p no:xdist -o addopts=""`
 
 
 @pytest.mark.respx(base_url=base_url)
 def test_parse_nothing(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -103,7 +108,7 @@ def on_event(stream: ChatCompletionStream[Location], event: ChatCompletionStream
             done_snapshots.append(model_copy(stream.current_completion_snapshot, deep=True))
 
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -195,7 +200,7 @@ class Location(BaseModel):
         units: Literal["c", "f"]
 
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -374,7 +379,7 @@ class Location(BaseModel):
 
     with pytest.raises(openai.LengthFinishReasonError):
         _make_stream_snapshot_request(
-            lambda c: c.beta.chat.completions.stream(
+            lambda c: c.chat.completions.stream(
                 model="gpt-4o-2024-08-06",
                 messages=[
                     {
@@ -399,7 +404,7 @@ class Location(BaseModel):
         units: Literal["c", "f"]
 
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -444,7 +449,7 @@ class Location(BaseModel):
 @pytest.mark.respx(base_url=base_url)
 def test_content_logprobs_events(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -523,7 +528,7 @@ class Location(BaseModel):
         units: Literal["c", "f"]
 
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -635,7 +640,7 @@ class GetWeatherArgs(BaseModel):
         units: Literal["c", "f"] = "c"
 
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -733,7 +738,7 @@ class GetStockPrice(BaseModel):
         exchange: str
 
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -831,7 +836,7 @@ class GetStockPrice(BaseModel):
 @pytest.mark.respx(base_url=base_url)
 def test_parse_strict_tools(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -903,7 +908,7 @@ def test_parse_strict_tools(client: OpenAI, respx_mock: MockRouter, monkeypatch:
 @pytest.mark.respx(base_url=base_url)
 def test_non_pydantic_response_format(client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch) -> None:
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[
                 {
@@ -951,7 +956,7 @@ def test_allows_non_strict_tools_but_no_parsing(
     client: OpenAI, respx_mock: MockRouter, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     listener = _make_stream_snapshot_request(
-        lambda c: c.beta.chat.completions.stream(
+        lambda c: c.chat.completions.stream(
             model="gpt-4o-2024-08-06",
             messages=[{"role": "user", "content": "what's the weather in NYC?"}],
             tools=[
@@ -1069,7 +1074,7 @@ def test_stream_method_in_sync(sync: bool, client: OpenAI, async_client: AsyncOp
 
     assert_signatures_in_sync(
         checking_client.chat.completions.create,
-        checking_client.beta.chat.completions.stream,
+        checking_client.chat.completions.stream,
         exclude_params={"response_format", "stream"},
     )
 
@@ -1123,7 +1128,7 @@ def _on_response(response: httpx.Response) -> None:
         respx_mock.post("/chat/completions").mock(
             return_value=httpx.Response(
                 200,
-                content=content_snapshot._old_value._load_value(),
+                content=get_snapshot_value(content_snapshot),
                 headers={"content-type": "text/event-stream"},
             )
         )
@@ -1170,7 +1175,7 @@ def _on_response(response: httpx.Response) -> None:
         respx_mock.post("/chat/completions").mock(
             return_value=httpx.Response(
                 200,
-                content=content_snapshot._old_value._load_value(),
+                content=get_snapshot_value(content_snapshot),
                 headers={"content-type": "text/event-stream"},
             )
         )
diff --git a/tests/lib/responses/__init__.py b/tests/lib/responses/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/lib/responses/test_responses.py b/tests/lib/responses/test_responses.py
new file mode 100644
index 0000000000..8e5f16df95
--- /dev/null
+++ b/tests/lib/responses/test_responses.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing_extensions import TypeVar
+
+import pytest
+from respx import MockRouter
+from inline_snapshot import snapshot
+
+from openai import OpenAI, AsyncOpenAI
+from openai._utils import assert_signatures_in_sync
+
+from ...conftest import base_url
+from ..snapshots import make_snapshot_request
+
+_T = TypeVar("_T")
+
+# all the snapshots in this file are auto-generated from the live API
+#
+# you can update them with
+#
+# `OPENAI_LIVE=1 pytest --inline-snapshot=fix -p no:xdist -o addopts=""`
+
+
+@pytest.mark.respx(base_url=base_url)
+def test_output_text(client: OpenAI, respx_mock: MockRouter) -> None:
+    response = make_snapshot_request(
+        lambda c: c.responses.create(
+            model="gpt-4o-mini",
+            input="What's the weather like in SF?",
+        ),
+        content_snapshot=snapshot(
+            '{"id": "resp_689a0b2545288193953c892439b42e2800b2e36c65a1fd4b", "object": "response", "created_at": 1754925861, "status": "completed", "background": false, "error": null, "incomplete_details": null, "instructions": null, "max_output_tokens": null, "max_tool_calls": null, "model": "gpt-4o-mini-2024-07-18", "output": [{"id": "msg_689a0b2637b08193ac478e568f49e3f900b2e36c65a1fd4b", "type": "message", "status": "completed", "content": [{"type": "output_text", "annotations": [], "logprobs": [], "text": "I can\'t provide real-time updates, but you can easily check the current weather in San Francisco using a weather website or app. Typically, San Francisco has cool, foggy summers and mild winters, so it\'s good to be prepared for variable weather!"}], "role": "assistant"}], "parallel_tool_calls": true, "previous_response_id": null, "prompt_cache_key": null, "reasoning": {"effort": null, "summary": null}, "safety_identifier": null, "service_tier": "default", "store": true, "temperature": 1.0, "text": {"format": {"type": "text"}, "verbosity": "medium"}, "tool_choice": "auto", "tools": [], "top_logprobs": 0, "top_p": 1.0, "truncation": "disabled", "usage": {"input_tokens": 14, "input_tokens_details": {"cached_tokens": 0}, "output_tokens": 50, "output_tokens_details": {"reasoning_tokens": 0}, "total_tokens": 64}, "user": null, "metadata": {}}'
+        ),
+        path="/responses",
+        mock_client=client,
+        respx_mock=respx_mock,
+    )
+
+    assert response.output_text == snapshot(
+        "I can't provide real-time updates, but you can easily check the current weather in San Francisco using a weather website or app. Typically, San Francisco has cool, foggy summers and mild winters, so it's good to be prepared for variable weather!"
+    )
+
+
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_stream_method_definition_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpenAI) -> None:
+    checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
+
+    assert_signatures_in_sync(
+        checking_client.responses.create,
+        checking_client.responses.stream,
+        exclude_params={"stream", "tools"},
+    )
+
+
+@pytest.mark.parametrize("sync", [True, False], ids=["sync", "async"])
+def test_parse_method_definition_in_sync(sync: bool, client: OpenAI, async_client: AsyncOpenAI) -> None:
+    checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
+
+    assert_signatures_in_sync(
+        checking_client.responses.create,
+        checking_client.responses.parse,
+        exclude_params={"tools"},
+    )
diff --git a/tests/lib/snapshots.py b/tests/lib/snapshots.py
new file mode 100644
index 0000000000..91222acda1
--- /dev/null
+++ b/tests/lib/snapshots.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import os
+import json
+from typing import Any, Callable, Awaitable
+from typing_extensions import TypeVar
+
+import httpx
+from respx import MockRouter
+from inline_snapshot import get_snapshot_value
+
+from openai import OpenAI, AsyncOpenAI
+
+_T = TypeVar("_T")
+
+
+def make_snapshot_request(
+    func: Callable[[OpenAI], _T],
+    *,
+    content_snapshot: Any,
+    respx_mock: MockRouter,
+    mock_client: OpenAI,
+    path: str,
+) -> _T:
+    live = os.environ.get("OPENAI_LIVE") == "1"
+    if live:
+
+        def _on_response(response: httpx.Response) -> None:
+            # update the content snapshot
+            assert json.dumps(json.loads(response.read())) == content_snapshot
+
+        respx_mock.stop()
+
+        client = OpenAI(
+            http_client=httpx.Client(
+                event_hooks={
+                    "response": [_on_response],
+                }
+            )
+        )
+    else:
+        respx_mock.post(path).mock(
+            return_value=httpx.Response(
+                200,
+                content=get_snapshot_value(content_snapshot),
+                headers={"content-type": "application/json"},
+            )
+        )
+
+        client = mock_client
+
+    result = func(client)
+
+    if live:
+        client.close()
+
+    return result
+
+
+async def make_async_snapshot_request(
+    func: Callable[[AsyncOpenAI], Awaitable[_T]],
+    *,
+    content_snapshot: Any,
+    respx_mock: MockRouter,
+    mock_client: AsyncOpenAI,
+    path: str,
+) -> _T:
+    live = os.environ.get("OPENAI_LIVE") == "1"
+    if live:
+
+        async def _on_response(response: httpx.Response) -> None:
+            # update the content snapshot
+            assert json.dumps(json.loads(await response.aread())) == content_snapshot
+
+        respx_mock.stop()
+
+        client = AsyncOpenAI(
+            http_client=httpx.AsyncClient(
+                event_hooks={
+                    "response": [_on_response],
+                }
+            )
+        )
+    else:
+        respx_mock.post(path).mock(
+            return_value=httpx.Response(
+                200,
+                content=get_snapshot_value(content_snapshot),
+                headers={"content-type": "application/json"},
+            )
+        )
+
+        client = mock_client
+
+    result = await func(client)
+
+    if live:
+        await client.close()
+
+    return result
diff --git a/tests/lib/test_assistants.py b/tests/lib/test_assistants.py
index 67d021ec35..08ea9300c3 100644
--- a/tests/lib/test_assistants.py
+++ b/tests/lib/test_assistants.py
@@ -11,7 +11,7 @@ def test_create_and_run_poll_method_definition_in_sync(sync: bool, client: OpenA
     checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
 
     assert_signatures_in_sync(
-        checking_client.beta.threads.create_and_run,
+        checking_client.beta.threads.create_and_run,  # pyright: ignore[reportDeprecated]
         checking_client.beta.threads.create_and_run_poll,
         exclude_params={"stream"},
     )
@@ -22,7 +22,7 @@ def test_create_and_run_stream_method_definition_in_sync(sync: bool, client: Ope
     checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
 
     assert_signatures_in_sync(
-        checking_client.beta.threads.create_and_run,
+        checking_client.beta.threads.create_and_run,  # pyright: ignore[reportDeprecated]
         checking_client.beta.threads.create_and_run_stream,
         exclude_params={"stream"},
     )
@@ -33,8 +33,8 @@ def test_run_stream_method_definition_in_sync(sync: bool, client: OpenAI, async_
     checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
 
     assert_signatures_in_sync(
-        checking_client.beta.threads.runs.create,
-        checking_client.beta.threads.runs.stream,
+        checking_client.beta.threads.runs.create,  # pyright: ignore[reportDeprecated]
+        checking_client.beta.threads.runs.stream,  # pyright: ignore[reportDeprecated]
         exclude_params={"stream"},
     )
 
@@ -44,7 +44,7 @@ def test_create_and_poll_method_definition_in_sync(sync: bool, client: OpenAI, a
     checking_client: OpenAI | AsyncOpenAI = client if sync else async_client
 
     assert_signatures_in_sync(
-        checking_client.beta.threads.runs.create,
-        checking_client.beta.threads.runs.create_and_poll,
+        checking_client.beta.threads.runs.create,  # pyright: ignore[reportDeprecated]
+        checking_client.beta.threads.runs.create_and_poll,  # pyright: ignore[reportDeprecated]
         exclude_params={"stream"},
     )
diff --git a/tests/lib/test_audio.py b/tests/lib/test_audio.py
index 0f53b316ba..93ed3a33b2 100644
--- a/tests/lib/test_audio.py
+++ b/tests/lib/test_audio.py
@@ -26,7 +26,7 @@ def test_translation_create_overloads_in_sync(sync: bool, client: OpenAI, async_
         assert_signatures_in_sync(
             fn,
             overload,
-            exclude_params={"response_format"},
+            exclude_params={"response_format", "stream"},
             description=f" for overload {i}",
         )
 
@@ -44,7 +44,8 @@ def test_translation_create_overloads_in_sync(sync: bool, client: OpenAI, async_
         elif is_literal_type(typ):
             overload_response_formats.update(get_args(typ))
 
-    src_response_formats: set[str] = set(get_args(AudioResponseFormat))
+    # 'diarized_json' applies only to transcriptions, not translations.
+    src_response_formats: set[str] = set(get_args(AudioResponseFormat)) - {"diarized_json"}
     diff = src_response_formats.difference(overload_response_formats)
     assert len(diff) == 0, f"some response format options don't have overloads"
 
@@ -57,18 +58,27 @@ def test_transcription_create_overloads_in_sync(sync: bool, client: OpenAI, asyn
     overload_response_formats: set[str] = set()
 
     for i, overload in enumerate(typing_extensions.get_overloads(fn)):
-        assert_signatures_in_sync(
-            fn,
-            overload,
-            exclude_params={"response_format"},
-            description=f" for overload {i}",
-        )
-
         sig = inspect.signature(overload)
         typ = evaluate_forwardref(
             sig.parameters["response_format"].annotation,
             globalns=sys.modules[fn.__module__].__dict__,
         )
+
+        exclude_params = {"response_format", "stream"}
+        # known_speaker_names and known_speaker_references are only supported by diarized_json
+        if not (is_literal_type(typ) and set(get_args(typ)) == {"diarized_json"}):
+            exclude_params.update({"known_speaker_names", "known_speaker_references"})
+
+        # diarized_json does not support these parameters
+        if is_literal_type(typ) and set(get_args(typ)) == {"diarized_json"}:
+            exclude_params.update({"include", "prompt", "timestamp_granularities"})
+
+        assert_signatures_in_sync(
+            fn,
+            overload,
+            exclude_params=exclude_params,
+            description=f" for overload {i}",
+        )
         if is_union_type(typ):
             for arg in get_args(typ):
                 if not is_literal_type(arg):
diff --git a/tests/lib/test_pydantic.py b/tests/lib/test_pydantic.py
index 7e128b70c0..754a15151c 100644
--- a/tests/lib/test_pydantic.py
+++ b/tests/lib/test_pydantic.py
@@ -6,14 +6,14 @@
 from inline_snapshot import snapshot
 
 import openai
-from openai._compat import PYDANTIC_V2
+from openai._compat import PYDANTIC_V1
 from openai.lib._pydantic import to_strict_json_schema
 
 from .schema_types.query import Query
 
 
 def test_most_types() -> None:
-    if PYDANTIC_V2:
+    if not PYDANTIC_V1:
         assert openai.pydantic_function_tool(Query)["function"] == snapshot(
             {
                 "name": "Query",
@@ -181,7 +181,7 @@ class ColorDetection(BaseModel):
 
 
 def test_enums() -> None:
-    if PYDANTIC_V2:
+    if not PYDANTIC_V1:
         assert openai.pydantic_function_tool(ColorDetection)["function"] == snapshot(
             {
                 "name": "ColorDetection",
@@ -253,7 +253,7 @@ class Universe(BaseModel):
 
 
 def test_nested_inline_ref_expansion() -> None:
-    if PYDANTIC_V2:
+    if not PYDANTIC_V1:
         assert to_strict_json_schema(Universe) == snapshot(
             {
                 "title": "Universe",
diff --git a/tests/lib/chat/_utils.py b/tests/lib/utils.py
similarity index 94%
rename from tests/lib/chat/_utils.py
rename to tests/lib/utils.py
index af08db417c..e6b6a29434 100644
--- a/tests/lib/chat/_utils.py
+++ b/tests/lib/utils.py
@@ -7,7 +7,7 @@
 import pytest
 import pydantic
 
-from ...utils import rich_print_str
+from ..utils import rich_print_str
 
 ReprArgs: TypeAlias = "Iterable[tuple[str | None, Any]]"
 
@@ -28,7 +28,7 @@ def __repr_args__(self: pydantic.BaseModel) -> ReprArgs:
 
         string = rich_print_str(obj)
 
-        # we remove all `fn_name.<locals>.` occurences
+        # we remove all `fn_name.<locals>.` occurrences
         # so that we can share the same snapshots between
         # pydantic v1 and pydantic v2 as their output for
         # generic models differs, e.g.
diff --git a/tests/test_client.py b/tests/test_client.py
index 62654afe1e..e8d62f17f7 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -6,13 +6,10 @@
 import os
 import sys
 import json
-import time
 import asyncio
 import inspect
-import subprocess
 import tracemalloc
-from typing import Any, Union, cast
-from textwrap import dedent
+from typing import Any, Union, Protocol, cast
 from unittest import mock
 from typing_extensions import Literal
 
@@ -23,13 +20,20 @@
 
 from openai import OpenAI, AsyncOpenAI, APIResponseValidationError
 from openai._types import Omit
-from openai._utils import maybe_transform
+from openai._utils import asyncify
 from openai._models import BaseModel, FinalRequestOptions
-from openai._constants import RAW_RESPONSE_HEADER
 from openai._streaming import Stream, AsyncStream
 from openai._exceptions import OpenAIError, APIStatusError, APITimeoutError, APIResponseValidationError
-from openai._base_client import DEFAULT_TIMEOUT, HTTPX_DEFAULT_TIMEOUT, BaseClient, make_request_options
-from openai.types.chat.completion_create_params import CompletionCreateParamsNonStreaming
+from openai._base_client import (
+    DEFAULT_TIMEOUT,
+    HTTPX_DEFAULT_TIMEOUT,
+    BaseClient,
+    OtherPlatform,
+    DefaultHttpxClient,
+    DefaultAsyncHttpxClient,
+    get_platform,
+    make_request_options,
+)
 
 from .utils import update_env
 
@@ -37,6 +41,10 @@
 api_key = "My API Key"
 
 
+class MockRequestCall(Protocol):
+    request: httpx.Request
+
+
 def _get_params(client: BaseClient[Any, Any]) -> dict[str, str]:
     request = client._build_request(FinalRequestOptions(method="get", url="/foo"))
     url = httpx.URL(request.url)
@@ -56,51 +64,49 @@ def _get_open_connections(client: OpenAI | AsyncOpenAI) -> int:
 
 
 class TestOpenAI:
-    client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-
     @pytest.mark.respx(base_url=base_url)
-    def test_raw_response(self, respx_mock: MockRouter) -> None:
+    def test_raw_response(self, respx_mock: MockRouter, client: OpenAI) -> None:
         respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        response = self.client.post("/foo", cast_to=httpx.Response)
+        response = client.post("/foo", cast_to=httpx.Response)
         assert response.status_code == 200
         assert isinstance(response, httpx.Response)
         assert response.json() == {"foo": "bar"}
 
     @pytest.mark.respx(base_url=base_url)
-    def test_raw_response_for_binary(self, respx_mock: MockRouter) -> None:
+    def test_raw_response_for_binary(self, respx_mock: MockRouter, client: OpenAI) -> None:
         respx_mock.post("/foo").mock(
             return_value=httpx.Response(200, headers={"Content-Type": "application/binary"}, content='{"foo": "bar"}')
         )
 
-        response = self.client.post("/foo", cast_to=httpx.Response)
+        response = client.post("/foo", cast_to=httpx.Response)
         assert response.status_code == 200
         assert isinstance(response, httpx.Response)
         assert response.json() == {"foo": "bar"}
 
-    def test_copy(self) -> None:
-        copied = self.client.copy()
-        assert id(copied) != id(self.client)
+    def test_copy(self, client: OpenAI) -> None:
+        copied = client.copy()
+        assert id(copied) != id(client)
 
-        copied = self.client.copy(api_key="another My API Key")
+        copied = client.copy(api_key="another My API Key")
         assert copied.api_key == "another My API Key"
-        assert self.client.api_key == "My API Key"
+        assert client.api_key == "My API Key"
 
-    def test_copy_default_options(self) -> None:
+    def test_copy_default_options(self, client: OpenAI) -> None:
         # options that have a default are overridden correctly
-        copied = self.client.copy(max_retries=7)
+        copied = client.copy(max_retries=7)
         assert copied.max_retries == 7
-        assert self.client.max_retries == 2
+        assert client.max_retries == 2
 
         copied2 = copied.copy(max_retries=6)
         assert copied2.max_retries == 6
         assert copied.max_retries == 7
 
         # timeout
-        assert isinstance(self.client.timeout, httpx.Timeout)
-        copied = self.client.copy(timeout=None)
+        assert isinstance(client.timeout, httpx.Timeout)
+        copied = client.copy(timeout=None)
         assert copied.timeout is None
-        assert isinstance(self.client.timeout, httpx.Timeout)
+        assert isinstance(client.timeout, httpx.Timeout)
 
     def test_copy_default_headers(self) -> None:
         client = OpenAI(
@@ -135,6 +141,7 @@ def test_copy_default_headers(self) -> None:
             match="`default_headers` and `set_default_headers` arguments are mutually exclusive",
         ):
             client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"})
+        client.close()
 
     def test_copy_default_query(self) -> None:
         client = OpenAI(
@@ -172,13 +179,15 @@ def test_copy_default_query(self) -> None:
         ):
             client.copy(set_default_query={}, default_query={"foo": "Bar"})
 
-    def test_copy_signature(self) -> None:
+        client.close()
+
+    def test_copy_signature(self, client: OpenAI) -> None:
         # ensure the same parameters that can be passed to the client are defined in the `.copy()` method
         init_signature = inspect.signature(
             # mypy doesn't like that we access the `__init__` property.
-            self.client.__init__,  # type: ignore[misc]
+            client.__init__,  # type: ignore[misc]
         )
-        copy_signature = inspect.signature(self.client.copy)
+        copy_signature = inspect.signature(client.copy)
         exclude_params = {"transport", "proxies", "_strict_response_validation"}
 
         for name in init_signature.parameters.keys():
@@ -188,12 +197,13 @@ def test_copy_signature(self) -> None:
             copy_param = copy_signature.parameters.get(name)
             assert copy_param is not None, f"copy() signature is missing the {name} param"
 
-    def test_copy_build_request(self) -> None:
+    @pytest.mark.skipif(sys.version_info >= (3, 10), reason="fails because of a memory leak that started from 3.12")
+    def test_copy_build_request(self, client: OpenAI) -> None:
         options = FinalRequestOptions(method="get", url="/foo")
 
         def build_request(options: FinalRequestOptions) -> None:
-            client = self.client.copy()
-            client._build_request(options)
+            client_copy = client.copy()
+            client_copy._build_request(options)
 
         # ensure that the machinery is warmed up before tracing starts.
         build_request(options)
@@ -250,14 +260,12 @@ def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.Statistic
                     print(frame)
             raise AssertionError()
 
-    def test_request_timeout(self) -> None:
-        request = self.client._build_request(FinalRequestOptions(method="get", url="/foo"))
+    def test_request_timeout(self, client: OpenAI) -> None:
+        request = client._build_request(FinalRequestOptions(method="get", url="/foo"))
         timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
         assert timeout == DEFAULT_TIMEOUT
 
-        request = self.client._build_request(
-            FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0))
-        )
+        request = client._build_request(FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0)))
         timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
         assert timeout == httpx.Timeout(100.0)
 
@@ -268,6 +276,8 @@ def test_client_timeout_option(self) -> None:
         timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
         assert timeout == httpx.Timeout(0)
 
+        client.close()
+
     def test_http_client_timeout_option(self) -> None:
         # custom timeout given to the httpx client should be used
         with httpx.Client(timeout=None) as http_client:
@@ -279,6 +289,8 @@ def test_http_client_timeout_option(self) -> None:
             timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
             assert timeout == httpx.Timeout(None)
 
+            client.close()
+
         # no timeout given to the httpx client should not use the httpx default
         with httpx.Client() as http_client:
             client = OpenAI(
@@ -289,6 +301,8 @@ def test_http_client_timeout_option(self) -> None:
             timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
             assert timeout == DEFAULT_TIMEOUT
 
+            client.close()
+
         # explicitly passing the default timeout currently results in it being ignored
         with httpx.Client(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client:
             client = OpenAI(
@@ -299,6 +313,8 @@ def test_http_client_timeout_option(self) -> None:
             timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
             assert timeout == DEFAULT_TIMEOUT  # our default
 
+            client.close()
+
     async def test_invalid_http_client(self) -> None:
         with pytest.raises(TypeError, match="Invalid `http_client` arg"):
             async with httpx.AsyncClient() as http_client:
@@ -310,14 +326,14 @@ async def test_invalid_http_client(self) -> None:
                 )
 
     def test_default_headers_option(self) -> None:
-        client = OpenAI(
+        test_client = OpenAI(
             base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"}
         )
-        request = client._build_request(FinalRequestOptions(method="get", url="/foo"))
+        request = test_client._build_request(FinalRequestOptions(method="get", url="/foo"))
         assert request.headers.get("x-foo") == "bar"
         assert request.headers.get("x-stainless-lang") == "python"
 
-        client2 = OpenAI(
+        test_client2 = OpenAI(
             base_url=base_url,
             api_key=api_key,
             _strict_response_validation=True,
@@ -326,13 +342,18 @@ def test_default_headers_option(self) -> None:
                 "X-Stainless-Lang": "my-overriding-header",
             },
         )
-        request = client2._build_request(FinalRequestOptions(method="get", url="/foo"))
+        request = test_client2._build_request(FinalRequestOptions(method="get", url="/foo"))
         assert request.headers.get("x-foo") == "stainless"
         assert request.headers.get("x-stainless-lang") == "my-overriding-header"
 
+        test_client.close()
+        test_client2.close()
+
     def test_validate_headers(self) -> None:
         client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-        request = client._build_request(FinalRequestOptions(method="get", url="/foo"))
+        options = client._prepare_options(FinalRequestOptions(method="get", url="/foo"))
+        request = client._build_request(options)
+
         assert request.headers.get("Authorization") == f"Bearer {api_key}"
 
         with pytest.raises(OpenAIError):
@@ -358,8 +379,10 @@ def test_default_query_option(self) -> None:
         url = httpx.URL(request.url)
         assert dict(url.params) == {"foo": "baz", "query_param": "overridden"}
 
-    def test_request_extra_json(self) -> None:
-        request = self.client._build_request(
+        client.close()
+
+    def test_request_extra_json(self, client: OpenAI) -> None:
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -370,7 +393,7 @@ def test_request_extra_json(self) -> None:
         data = json.loads(request.content.decode("utf-8"))
         assert data == {"foo": "bar", "baz": False}
 
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -381,7 +404,7 @@ def test_request_extra_json(self) -> None:
         assert data == {"baz": False}
 
         # `extra_json` takes priority over `json_data` when keys clash
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -392,8 +415,8 @@ def test_request_extra_json(self) -> None:
         data = json.loads(request.content.decode("utf-8"))
         assert data == {"foo": "bar", "baz": None}
 
-    def test_request_extra_headers(self) -> None:
-        request = self.client._build_request(
+    def test_request_extra_headers(self, client: OpenAI) -> None:
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -403,7 +426,7 @@ def test_request_extra_headers(self) -> None:
         assert request.headers.get("X-Foo") == "Foo"
 
         # `extra_headers` takes priority over `default_headers` when keys clash
-        request = self.client.with_options(default_headers={"X-Bar": "true"})._build_request(
+        request = client.with_options(default_headers={"X-Bar": "true"})._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -414,8 +437,8 @@ def test_request_extra_headers(self) -> None:
         )
         assert request.headers.get("X-Bar") == "false"
 
-    def test_request_extra_query(self) -> None:
-        request = self.client._build_request(
+    def test_request_extra_query(self, client: OpenAI) -> None:
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -428,7 +451,7 @@ def test_request_extra_query(self) -> None:
         assert params == {"my_query_param": "Foo"}
 
         # if both `query` and `extra_query` are given, they are merged
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -442,7 +465,7 @@ def test_request_extra_query(self) -> None:
         assert params == {"bar": "1", "foo": "2"}
 
         # `extra_query` takes priority over `query` when keys clash
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -458,7 +481,7 @@ def test_request_extra_query(self) -> None:
     def test_multipart_repeating_array(self, client: OpenAI) -> None:
         request = client._build_request(
             FinalRequestOptions.construct(
-                method="get",
+                method="post",
                 url="/foo",
                 headers={"Content-Type": "multipart/form-data; boundary=6b7ba517decee4a450543ea6ae821c82"},
                 json_data={"array": ["foo", "bar"]},
@@ -485,7 +508,7 @@ def test_multipart_repeating_array(self, client: OpenAI) -> None:
         ]
 
     @pytest.mark.respx(base_url=base_url)
-    def test_basic_union_response(self, respx_mock: MockRouter) -> None:
+    def test_basic_union_response(self, respx_mock: MockRouter, client: OpenAI) -> None:
         class Model1(BaseModel):
             name: str
 
@@ -494,12 +517,12 @@ class Model2(BaseModel):
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
+        response = client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
         assert isinstance(response, Model2)
         assert response.foo == "bar"
 
     @pytest.mark.respx(base_url=base_url)
-    def test_union_response_different_types(self, respx_mock: MockRouter) -> None:
+    def test_union_response_different_types(self, respx_mock: MockRouter, client: OpenAI) -> None:
         """Union of objects with the same field name using a different type"""
 
         class Model1(BaseModel):
@@ -510,18 +533,18 @@ class Model2(BaseModel):
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
+        response = client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
         assert isinstance(response, Model2)
         assert response.foo == "bar"
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": 1}))
 
-        response = self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
+        response = client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
         assert isinstance(response, Model1)
         assert response.foo == 1
 
     @pytest.mark.respx(base_url=base_url)
-    def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter) -> None:
+    def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter, client: OpenAI) -> None:
         """
         Response that sets Content-Type to something other than application/json but returns json data
         """
@@ -537,7 +560,7 @@ class Model(BaseModel):
             )
         )
 
-        response = self.client.get("/foo", cast_to=Model)
+        response = client.get("/foo", cast_to=Model)
         assert isinstance(response, Model)
         assert response.foo == 2
 
@@ -549,6 +572,8 @@ def test_base_url_setter(self) -> None:
 
         assert client.base_url == "https://example.com/from_setter/"
 
+        client.close()
+
     def test_base_url_env(self) -> None:
         with update_env(OPENAI_BASE_URL="http://localhost:5000/from/env"):
             client = OpenAI(api_key=api_key, _strict_response_validation=True)
@@ -576,6 +601,7 @@ def test_base_url_trailing_slash(self, client: OpenAI) -> None:
             ),
         )
         assert request.url == "http://localhost:5000/custom/path/foo"
+        client.close()
 
     @pytest.mark.parametrize(
         "client",
@@ -599,6 +625,7 @@ def test_base_url_no_trailing_slash(self, client: OpenAI) -> None:
             ),
         )
         assert request.url == "http://localhost:5000/custom/path/foo"
+        client.close()
 
     @pytest.mark.parametrize(
         "client",
@@ -622,35 +649,36 @@ def test_absolute_request_url(self, client: OpenAI) -> None:
             ),
         )
         assert request.url == "https://myapi.com/foo"
+        client.close()
 
     def test_copied_client_does_not_close_http(self) -> None:
-        client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-        assert not client.is_closed()
+        test_client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
+        assert not test_client.is_closed()
 
-        copied = client.copy()
-        assert copied is not client
+        copied = test_client.copy()
+        assert copied is not test_client
 
         del copied
 
-        assert not client.is_closed()
+        assert not test_client.is_closed()
 
     def test_client_context_manager(self) -> None:
-        client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-        with client as c2:
-            assert c2 is client
+        test_client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
+        with test_client as c2:
+            assert c2 is test_client
             assert not c2.is_closed()
-            assert not client.is_closed()
-        assert client.is_closed()
+            assert not test_client.is_closed()
+        assert test_client.is_closed()
 
     @pytest.mark.respx(base_url=base_url)
-    def test_client_response_validation_error(self, respx_mock: MockRouter) -> None:
+    def test_client_response_validation_error(self, respx_mock: MockRouter, client: OpenAI) -> None:
         class Model(BaseModel):
             foo: str
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": {"invalid": True}}))
 
         with pytest.raises(APIResponseValidationError) as exc:
-            self.client.get("/foo", cast_to=Model)
+            client.get("/foo", cast_to=Model)
 
         assert isinstance(exc.value.__cause__, ValidationError)
 
@@ -659,13 +687,13 @@ def test_client_max_retries_validation(self) -> None:
             OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True, max_retries=cast(Any, None))
 
     @pytest.mark.respx(base_url=base_url)
-    def test_default_stream_cls(self, respx_mock: MockRouter) -> None:
+    def test_default_stream_cls(self, respx_mock: MockRouter, client: OpenAI) -> None:
         class Model(BaseModel):
             name: str
 
         respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        stream = self.client.post("/foo", cast_to=Model, stream=True, stream_cls=Stream[Model])
+        stream = client.post("/foo", cast_to=Model, stream=True, stream_cls=Stream[Model])
         assert isinstance(stream, Stream)
         stream.response.close()
 
@@ -681,11 +709,14 @@ class Model(BaseModel):
         with pytest.raises(APIResponseValidationError):
             strict_client.get("/foo", cast_to=Model)
 
-        client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=False)
+        non_strict_client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=False)
 
-        response = client.get("/foo", cast_to=Model)
+        response = non_strict_client.get("/foo", cast_to=Model)
         assert isinstance(response, str)  # type: ignore[unreachable]
 
+        strict_client.close()
+        non_strict_client.close()
+
     @pytest.mark.parametrize(
         "remaining_retries,retry_after,timeout",
         [
@@ -708,9 +739,9 @@ class Model(BaseModel):
         ],
     )
     @mock.patch("time.time", mock.MagicMock(return_value=1696004797))
-    def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None:
-        client = OpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-
+    def test_parse_retry_after_header(
+        self, remaining_retries: int, retry_after: str, timeout: float, client: OpenAI
+    ) -> None:
         headers = httpx.Headers({"retry-after": retry_after})
         options = FinalRequestOptions(method="get", url="/foo", max_retries=3)
         calculated = client._calculate_retry_timeout(remaining_retries, options, headers)
@@ -718,61 +749,38 @@ def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str
 
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter) -> None:
+    def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, client: OpenAI) -> None:
         respx_mock.post("/chat/completions").mock(side_effect=httpx.TimeoutException("Test timeout error"))
 
         with pytest.raises(APITimeoutError):
-            self.client.post(
-                "/chat/completions",
-                body=cast(
-                    object,
-                    maybe_transform(
-                        dict(
-                            messages=[
-                                {
-                                    "role": "user",
-                                    "content": "Say this is a test",
-                                }
-                            ],
-                            model="gpt-4o",
-                        ),
-                        CompletionCreateParamsNonStreaming,
-                    ),
-                ),
-                cast_to=httpx.Response,
-                options={"headers": {RAW_RESPONSE_HEADER: "stream"}},
-            )
-
-        assert _get_open_connections(self.client) == 0
+            client.chat.completions.with_streaming_response.create(
+                messages=[
+                    {
+                        "content": "string",
+                        "role": "developer",
+                    }
+                ],
+                model="gpt-4o",
+            ).__enter__()
+
+        assert _get_open_connections(client) == 0
 
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter) -> None:
+    def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client: OpenAI) -> None:
         respx_mock.post("/chat/completions").mock(return_value=httpx.Response(500))
 
         with pytest.raises(APIStatusError):
-            self.client.post(
-                "/chat/completions",
-                body=cast(
-                    object,
-                    maybe_transform(
-                        dict(
-                            messages=[
-                                {
-                                    "role": "user",
-                                    "content": "Say this is a test",
-                                }
-                            ],
-                            model="gpt-4o",
-                        ),
-                        CompletionCreateParamsNonStreaming,
-                    ),
-                ),
-                cast_to=httpx.Response,
-                options={"headers": {RAW_RESPONSE_HEADER: "stream"}},
-            )
-
-        assert _get_open_connections(self.client) == 0
+            client.chat.completions.with_streaming_response.create(
+                messages=[
+                    {
+                        "content": "string",
+                        "role": "developer",
+                    }
+                ],
+                model="gpt-4o",
+            ).__enter__()
+        assert _get_open_connections(client) == 0
 
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
@@ -908,57 +916,156 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
             assert response.retries_taken == failures_before_success
             assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success
 
+    def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        # Test that the proxy environment variables are set correctly
+        monkeypatch.setenv("HTTPS_PROXY", "https://example.org")
+
+        client = DefaultHttpxClient()
+
+        mounts = tuple(client._mounts.items())
+        assert len(mounts) == 1
+        assert mounts[0][0].pattern == "https://"
+
+    @pytest.mark.filterwarnings("ignore:.*deprecated.*:DeprecationWarning")
+    def test_default_client_creation(self) -> None:
+        # Ensure that the client can be initialized without any exceptions
+        DefaultHttpxClient(
+            verify=True,
+            cert=None,
+            trust_env=True,
+            http1=True,
+            http2=False,
+            limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
+        )
 
-class TestAsyncOpenAI:
-    client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
+    @pytest.mark.respx(base_url=base_url)
+    def test_follow_redirects(self, respx_mock: MockRouter, client: OpenAI) -> None:
+        # Test that the default follow_redirects=True allows following redirects
+        respx_mock.post("/redirect").mock(
+            return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"})
+        )
+        respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"}))
+
+        response = client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response)
+        assert response.status_code == 200
+        assert response.json() == {"status": "ok"}
 
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
-    async def test_raw_response(self, respx_mock: MockRouter) -> None:
+    def test_follow_redirects_disabled(self, respx_mock: MockRouter, client: OpenAI) -> None:
+        # Test that follow_redirects=False prevents following redirects
+        respx_mock.post("/redirect").mock(
+            return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"})
+        )
+
+        with pytest.raises(APIStatusError) as exc_info:
+            client.post("/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response)
+
+        assert exc_info.value.response.status_code == 302
+        assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected"
+
+    def test_api_key_before_after_refresh_provider(self) -> None:
+        client = OpenAI(base_url=base_url, api_key=lambda: "test_bearer_token")
+
+        assert client.api_key == ""
+        assert "Authorization" not in client.auth_headers
+
+        client._refresh_api_key()
+
+        assert client.api_key == "test_bearer_token"
+        assert client.auth_headers.get("Authorization") == "Bearer test_bearer_token"
+
+    def test_api_key_before_after_refresh_str(self) -> None:
+        client = OpenAI(base_url=base_url, api_key="test_api_key")
+
+        assert client.auth_headers.get("Authorization") == "Bearer test_api_key"
+        client._refresh_api_key()
+
+        assert client.auth_headers.get("Authorization") == "Bearer test_api_key"
+
+    @pytest.mark.respx()
+    def test_api_key_refresh_on_retry(self, respx_mock: MockRouter) -> None:
+        respx_mock.post(base_url + "/chat/completions").mock(
+            side_effect=[
+                httpx.Response(500, json={"error": "server error"}),
+                httpx.Response(200, json={"foo": "bar"}),
+            ]
+        )
+
+        counter = 0
+
+        def token_provider() -> str:
+            nonlocal counter
+
+            counter += 1
+
+            if counter == 1:
+                return "first"
+
+            return "second"
+
+        client = OpenAI(base_url=base_url, api_key=token_provider)
+        client.chat.completions.create(messages=[], model="gpt-4")
+
+        calls = cast("list[MockRequestCall]", respx_mock.calls)
+        assert len(calls) == 2
+
+        assert calls[0].request.headers.get("Authorization") == "Bearer first"
+        assert calls[1].request.headers.get("Authorization") == "Bearer second"
+
+    def test_copy_auth(self) -> None:
+        client = OpenAI(base_url=base_url, api_key=lambda: "test_bearer_token_1").copy(
+            api_key=lambda: "test_bearer_token_2"
+        )
+        client._refresh_api_key()
+        assert client.auth_headers == {"Authorization": "Bearer test_bearer_token_2"}
+
+
+class TestAsyncOpenAI:
+    @pytest.mark.respx(base_url=base_url)
+    async def test_raw_response(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        response = await self.client.post("/foo", cast_to=httpx.Response)
+        response = await async_client.post("/foo", cast_to=httpx.Response)
         assert response.status_code == 200
         assert isinstance(response, httpx.Response)
         assert response.json() == {"foo": "bar"}
 
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
-    async def test_raw_response_for_binary(self, respx_mock: MockRouter) -> None:
+    async def test_raw_response_for_binary(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         respx_mock.post("/foo").mock(
             return_value=httpx.Response(200, headers={"Content-Type": "application/binary"}, content='{"foo": "bar"}')
         )
 
-        response = await self.client.post("/foo", cast_to=httpx.Response)
+        response = await async_client.post("/foo", cast_to=httpx.Response)
         assert response.status_code == 200
         assert isinstance(response, httpx.Response)
         assert response.json() == {"foo": "bar"}
 
-    def test_copy(self) -> None:
-        copied = self.client.copy()
-        assert id(copied) != id(self.client)
+    def test_copy(self, async_client: AsyncOpenAI) -> None:
+        copied = async_client.copy()
+        assert id(copied) != id(async_client)
 
-        copied = self.client.copy(api_key="another My API Key")
+        copied = async_client.copy(api_key="another My API Key")
         assert copied.api_key == "another My API Key"
-        assert self.client.api_key == "My API Key"
+        assert async_client.api_key == "My API Key"
 
-    def test_copy_default_options(self) -> None:
+    def test_copy_default_options(self, async_client: AsyncOpenAI) -> None:
         # options that have a default are overridden correctly
-        copied = self.client.copy(max_retries=7)
+        copied = async_client.copy(max_retries=7)
         assert copied.max_retries == 7
-        assert self.client.max_retries == 2
+        assert async_client.max_retries == 2
 
         copied2 = copied.copy(max_retries=6)
         assert copied2.max_retries == 6
         assert copied.max_retries == 7
 
         # timeout
-        assert isinstance(self.client.timeout, httpx.Timeout)
-        copied = self.client.copy(timeout=None)
+        assert isinstance(async_client.timeout, httpx.Timeout)
+        copied = async_client.copy(timeout=None)
         assert copied.timeout is None
-        assert isinstance(self.client.timeout, httpx.Timeout)
+        assert isinstance(async_client.timeout, httpx.Timeout)
 
-    def test_copy_default_headers(self) -> None:
+    async def test_copy_default_headers(self) -> None:
         client = AsyncOpenAI(
             base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"}
         )
@@ -991,8 +1098,9 @@ def test_copy_default_headers(self) -> None:
             match="`default_headers` and `set_default_headers` arguments are mutually exclusive",
         ):
             client.copy(set_default_headers={}, default_headers={"X-Foo": "Bar"})
+        await client.close()
 
-    def test_copy_default_query(self) -> None:
+    async def test_copy_default_query(self) -> None:
         client = AsyncOpenAI(
             base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"foo": "bar"}
         )
@@ -1028,13 +1136,15 @@ def test_copy_default_query(self) -> None:
         ):
             client.copy(set_default_query={}, default_query={"foo": "Bar"})
 
-    def test_copy_signature(self) -> None:
+        await client.close()
+
+    def test_copy_signature(self, async_client: AsyncOpenAI) -> None:
         # ensure the same parameters that can be passed to the client are defined in the `.copy()` method
         init_signature = inspect.signature(
             # mypy doesn't like that we access the `__init__` property.
-            self.client.__init__,  # type: ignore[misc]
+            async_client.__init__,  # type: ignore[misc]
         )
-        copy_signature = inspect.signature(self.client.copy)
+        copy_signature = inspect.signature(async_client.copy)
         exclude_params = {"transport", "proxies", "_strict_response_validation"}
 
         for name in init_signature.parameters.keys():
@@ -1044,12 +1154,13 @@ def test_copy_signature(self) -> None:
             copy_param = copy_signature.parameters.get(name)
             assert copy_param is not None, f"copy() signature is missing the {name} param"
 
-    def test_copy_build_request(self) -> None:
+    @pytest.mark.skipif(sys.version_info >= (3, 10), reason="fails because of a memory leak that started from 3.12")
+    def test_copy_build_request(self, async_client: AsyncOpenAI) -> None:
         options = FinalRequestOptions(method="get", url="/foo")
 
         def build_request(options: FinalRequestOptions) -> None:
-            client = self.client.copy()
-            client._build_request(options)
+            client_copy = async_client.copy()
+            client_copy._build_request(options)
 
         # ensure that the machinery is warmed up before tracing starts.
         build_request(options)
@@ -1106,12 +1217,12 @@ def add_leak(leaks: list[tracemalloc.StatisticDiff], diff: tracemalloc.Statistic
                     print(frame)
             raise AssertionError()
 
-    async def test_request_timeout(self) -> None:
-        request = self.client._build_request(FinalRequestOptions(method="get", url="/foo"))
+    async def test_request_timeout(self, async_client: AsyncOpenAI) -> None:
+        request = async_client._build_request(FinalRequestOptions(method="get", url="/foo"))
         timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
         assert timeout == DEFAULT_TIMEOUT
 
-        request = self.client._build_request(
+        request = async_client._build_request(
             FinalRequestOptions(method="get", url="/foo", timeout=httpx.Timeout(100.0))
         )
         timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
@@ -1126,6 +1237,8 @@ async def test_client_timeout_option(self) -> None:
         timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
         assert timeout == httpx.Timeout(0)
 
+        await client.close()
+
     async def test_http_client_timeout_option(self) -> None:
         # custom timeout given to the httpx client should be used
         async with httpx.AsyncClient(timeout=None) as http_client:
@@ -1137,6 +1250,8 @@ async def test_http_client_timeout_option(self) -> None:
             timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
             assert timeout == httpx.Timeout(None)
 
+            await client.close()
+
         # no timeout given to the httpx client should not use the httpx default
         async with httpx.AsyncClient() as http_client:
             client = AsyncOpenAI(
@@ -1147,6 +1262,8 @@ async def test_http_client_timeout_option(self) -> None:
             timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
             assert timeout == DEFAULT_TIMEOUT
 
+            await client.close()
+
         # explicitly passing the default timeout currently results in it being ignored
         async with httpx.AsyncClient(timeout=HTTPX_DEFAULT_TIMEOUT) as http_client:
             client = AsyncOpenAI(
@@ -1157,6 +1274,8 @@ async def test_http_client_timeout_option(self) -> None:
             timeout = httpx.Timeout(**request.extensions["timeout"])  # type: ignore
             assert timeout == DEFAULT_TIMEOUT  # our default
 
+            await client.close()
+
     def test_invalid_http_client(self) -> None:
         with pytest.raises(TypeError, match="Invalid `http_client` arg"):
             with httpx.Client() as http_client:
@@ -1167,15 +1286,15 @@ def test_invalid_http_client(self) -> None:
                     http_client=cast(Any, http_client),
                 )
 
-    def test_default_headers_option(self) -> None:
-        client = AsyncOpenAI(
+    async def test_default_headers_option(self) -> None:
+        test_client = AsyncOpenAI(
             base_url=base_url, api_key=api_key, _strict_response_validation=True, default_headers={"X-Foo": "bar"}
         )
-        request = client._build_request(FinalRequestOptions(method="get", url="/foo"))
+        request = test_client._build_request(FinalRequestOptions(method="get", url="/foo"))
         assert request.headers.get("x-foo") == "bar"
         assert request.headers.get("x-stainless-lang") == "python"
 
-        client2 = AsyncOpenAI(
+        test_client2 = AsyncOpenAI(
             base_url=base_url,
             api_key=api_key,
             _strict_response_validation=True,
@@ -1184,13 +1303,17 @@ def test_default_headers_option(self) -> None:
                 "X-Stainless-Lang": "my-overriding-header",
             },
         )
-        request = client2._build_request(FinalRequestOptions(method="get", url="/foo"))
+        request = test_client2._build_request(FinalRequestOptions(method="get", url="/foo"))
         assert request.headers.get("x-foo") == "stainless"
         assert request.headers.get("x-stainless-lang") == "my-overriding-header"
 
-    def test_validate_headers(self) -> None:
+        await test_client.close()
+        await test_client2.close()
+
+    async def test_validate_headers(self) -> None:
         client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-        request = client._build_request(FinalRequestOptions(method="get", url="/foo"))
+        options = await client._prepare_options(FinalRequestOptions(method="get", url="/foo"))
+        request = client._build_request(options)
         assert request.headers.get("Authorization") == f"Bearer {api_key}"
 
         with pytest.raises(OpenAIError):
@@ -1198,7 +1321,7 @@ def test_validate_headers(self) -> None:
                 client2 = AsyncOpenAI(base_url=base_url, api_key=None, _strict_response_validation=True)
             _ = client2
 
-    def test_default_query_option(self) -> None:
+    async def test_default_query_option(self) -> None:
         client = AsyncOpenAI(
             base_url=base_url, api_key=api_key, _strict_response_validation=True, default_query={"query_param": "bar"}
         )
@@ -1216,8 +1339,10 @@ def test_default_query_option(self) -> None:
         url = httpx.URL(request.url)
         assert dict(url.params) == {"foo": "baz", "query_param": "overridden"}
 
-    def test_request_extra_json(self) -> None:
-        request = self.client._build_request(
+        await client.close()
+
+    def test_request_extra_json(self, client: OpenAI) -> None:
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1228,7 +1353,7 @@ def test_request_extra_json(self) -> None:
         data = json.loads(request.content.decode("utf-8"))
         assert data == {"foo": "bar", "baz": False}
 
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1239,7 +1364,7 @@ def test_request_extra_json(self) -> None:
         assert data == {"baz": False}
 
         # `extra_json` takes priority over `json_data` when keys clash
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1250,8 +1375,8 @@ def test_request_extra_json(self) -> None:
         data = json.loads(request.content.decode("utf-8"))
         assert data == {"foo": "bar", "baz": None}
 
-    def test_request_extra_headers(self) -> None:
-        request = self.client._build_request(
+    def test_request_extra_headers(self, client: OpenAI) -> None:
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1261,7 +1386,7 @@ def test_request_extra_headers(self) -> None:
         assert request.headers.get("X-Foo") == "Foo"
 
         # `extra_headers` takes priority over `default_headers` when keys clash
-        request = self.client.with_options(default_headers={"X-Bar": "true"})._build_request(
+        request = client.with_options(default_headers={"X-Bar": "true"})._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1272,8 +1397,8 @@ def test_request_extra_headers(self) -> None:
         )
         assert request.headers.get("X-Bar") == "false"
 
-    def test_request_extra_query(self) -> None:
-        request = self.client._build_request(
+    def test_request_extra_query(self, client: OpenAI) -> None:
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1286,7 +1411,7 @@ def test_request_extra_query(self) -> None:
         assert params == {"my_query_param": "Foo"}
 
         # if both `query` and `extra_query` are given, they are merged
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1300,7 +1425,7 @@ def test_request_extra_query(self) -> None:
         assert params == {"bar": "1", "foo": "2"}
 
         # `extra_query` takes priority over `query` when keys clash
-        request = self.client._build_request(
+        request = client._build_request(
             FinalRequestOptions(
                 method="post",
                 url="/foo",
@@ -1316,7 +1441,7 @@ def test_request_extra_query(self) -> None:
     def test_multipart_repeating_array(self, async_client: AsyncOpenAI) -> None:
         request = async_client._build_request(
             FinalRequestOptions.construct(
-                method="get",
+                method="post",
                 url="/foo",
                 headers={"Content-Type": "multipart/form-data; boundary=6b7ba517decee4a450543ea6ae821c82"},
                 json_data={"array": ["foo", "bar"]},
@@ -1343,7 +1468,7 @@ def test_multipart_repeating_array(self, async_client: AsyncOpenAI) -> None:
         ]
 
     @pytest.mark.respx(base_url=base_url)
-    async def test_basic_union_response(self, respx_mock: MockRouter) -> None:
+    async def test_basic_union_response(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         class Model1(BaseModel):
             name: str
 
@@ -1352,12 +1477,12 @@ class Model2(BaseModel):
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
+        response = await async_client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
         assert isinstance(response, Model2)
         assert response.foo == "bar"
 
     @pytest.mark.respx(base_url=base_url)
-    async def test_union_response_different_types(self, respx_mock: MockRouter) -> None:
+    async def test_union_response_different_types(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         """Union of objects with the same field name using a different type"""
 
         class Model1(BaseModel):
@@ -1368,18 +1493,20 @@ class Model2(BaseModel):
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
+        response = await async_client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
         assert isinstance(response, Model2)
         assert response.foo == "bar"
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": 1}))
 
-        response = await self.client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
+        response = await async_client.get("/foo", cast_to=cast(Any, Union[Model1, Model2]))
         assert isinstance(response, Model1)
         assert response.foo == 1
 
     @pytest.mark.respx(base_url=base_url)
-    async def test_non_application_json_content_type_for_json_data(self, respx_mock: MockRouter) -> None:
+    async def test_non_application_json_content_type_for_json_data(
+        self, respx_mock: MockRouter, async_client: AsyncOpenAI
+    ) -> None:
         """
         Response that sets Content-Type to something other than application/json but returns json data
         """
@@ -1395,11 +1522,11 @@ class Model(BaseModel):
             )
         )
 
-        response = await self.client.get("/foo", cast_to=Model)
+        response = await async_client.get("/foo", cast_to=Model)
         assert isinstance(response, Model)
         assert response.foo == 2
 
-    def test_base_url_setter(self) -> None:
+    async def test_base_url_setter(self) -> None:
         client = AsyncOpenAI(
             base_url="https://example.com/from_init", api_key=api_key, _strict_response_validation=True
         )
@@ -1409,7 +1536,9 @@ def test_base_url_setter(self) -> None:
 
         assert client.base_url == "https://example.com/from_setter/"
 
-    def test_base_url_env(self) -> None:
+        await client.close()
+
+    async def test_base_url_env(self) -> None:
         with update_env(OPENAI_BASE_URL="http://localhost:5000/from/env"):
             client = AsyncOpenAI(api_key=api_key, _strict_response_validation=True)
             assert client.base_url == "http://localhost:5000/from/env/"
@@ -1429,7 +1558,7 @@ def test_base_url_env(self) -> None:
         ],
         ids=["standard", "custom http client"],
     )
-    def test_base_url_trailing_slash(self, client: AsyncOpenAI) -> None:
+    async def test_base_url_trailing_slash(self, client: AsyncOpenAI) -> None:
         request = client._build_request(
             FinalRequestOptions(
                 method="post",
@@ -1438,6 +1567,7 @@ def test_base_url_trailing_slash(self, client: AsyncOpenAI) -> None:
             ),
         )
         assert request.url == "http://localhost:5000/custom/path/foo"
+        await client.close()
 
     @pytest.mark.parametrize(
         "client",
@@ -1454,7 +1584,7 @@ def test_base_url_trailing_slash(self, client: AsyncOpenAI) -> None:
         ],
         ids=["standard", "custom http client"],
     )
-    def test_base_url_no_trailing_slash(self, client: AsyncOpenAI) -> None:
+    async def test_base_url_no_trailing_slash(self, client: AsyncOpenAI) -> None:
         request = client._build_request(
             FinalRequestOptions(
                 method="post",
@@ -1463,6 +1593,7 @@ def test_base_url_no_trailing_slash(self, client: AsyncOpenAI) -> None:
             ),
         )
         assert request.url == "http://localhost:5000/custom/path/foo"
+        await client.close()
 
     @pytest.mark.parametrize(
         "client",
@@ -1479,7 +1610,7 @@ def test_base_url_no_trailing_slash(self, client: AsyncOpenAI) -> None:
         ],
         ids=["standard", "custom http client"],
     )
-    def test_absolute_request_url(self, client: AsyncOpenAI) -> None:
+    async def test_absolute_request_url(self, client: AsyncOpenAI) -> None:
         request = client._build_request(
             FinalRequestOptions(
                 method="post",
@@ -1488,37 +1619,37 @@ def test_absolute_request_url(self, client: AsyncOpenAI) -> None:
             ),
         )
         assert request.url == "https://myapi.com/foo"
+        await client.close()
 
     async def test_copied_client_does_not_close_http(self) -> None:
-        client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-        assert not client.is_closed()
+        test_client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
+        assert not test_client.is_closed()
 
-        copied = client.copy()
-        assert copied is not client
+        copied = test_client.copy()
+        assert copied is not test_client
 
         del copied
 
         await asyncio.sleep(0.2)
-        assert not client.is_closed()
+        assert not test_client.is_closed()
 
     async def test_client_context_manager(self) -> None:
-        client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-        async with client as c2:
-            assert c2 is client
+        test_client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
+        async with test_client as c2:
+            assert c2 is test_client
             assert not c2.is_closed()
-            assert not client.is_closed()
-        assert client.is_closed()
+            assert not test_client.is_closed()
+        assert test_client.is_closed()
 
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
-    async def test_client_response_validation_error(self, respx_mock: MockRouter) -> None:
+    async def test_client_response_validation_error(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         class Model(BaseModel):
             foo: str
 
         respx_mock.get("/foo").mock(return_value=httpx.Response(200, json={"foo": {"invalid": True}}))
 
         with pytest.raises(APIResponseValidationError) as exc:
-            await self.client.get("/foo", cast_to=Model)
+            await async_client.get("/foo", cast_to=Model)
 
         assert isinstance(exc.value.__cause__, ValidationError)
 
@@ -1529,19 +1660,17 @@ async def test_client_max_retries_validation(self) -> None:
             )
 
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
-    async def test_default_stream_cls(self, respx_mock: MockRouter) -> None:
+    async def test_default_stream_cls(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         class Model(BaseModel):
             name: str
 
         respx_mock.post("/foo").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
 
-        stream = await self.client.post("/foo", cast_to=Model, stream=True, stream_cls=AsyncStream[Model])
+        stream = await async_client.post("/foo", cast_to=Model, stream=True, stream_cls=AsyncStream[Model])
         assert isinstance(stream, AsyncStream)
         await stream.response.aclose()
 
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
     async def test_received_text_for_expected_json(self, respx_mock: MockRouter) -> None:
         class Model(BaseModel):
             name: str
@@ -1553,11 +1682,14 @@ class Model(BaseModel):
         with pytest.raises(APIResponseValidationError):
             await strict_client.get("/foo", cast_to=Model)
 
-        client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=False)
+        non_strict_client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=False)
 
-        response = await client.get("/foo", cast_to=Model)
+        response = await non_strict_client.get("/foo", cast_to=Model)
         assert isinstance(response, str)  # type: ignore[unreachable]
 
+        await strict_client.close()
+        await non_strict_client.close()
+
     @pytest.mark.parametrize(
         "remaining_retries,retry_after,timeout",
         [
@@ -1580,77 +1712,52 @@ class Model(BaseModel):
         ],
     )
     @mock.patch("time.time", mock.MagicMock(return_value=1696004797))
-    @pytest.mark.asyncio
-    async def test_parse_retry_after_header(self, remaining_retries: int, retry_after: str, timeout: float) -> None:
-        client = AsyncOpenAI(base_url=base_url, api_key=api_key, _strict_response_validation=True)
-
+    async def test_parse_retry_after_header(
+        self, remaining_retries: int, retry_after: str, timeout: float, async_client: AsyncOpenAI
+    ) -> None:
         headers = httpx.Headers({"retry-after": retry_after})
         options = FinalRequestOptions(method="get", url="/foo", max_retries=3)
-        calculated = client._calculate_retry_timeout(remaining_retries, options, headers)
+        calculated = async_client._calculate_retry_timeout(remaining_retries, options, headers)
         assert calculated == pytest.approx(timeout, 0.5 * 0.875)  # pyright: ignore[reportUnknownMemberType]
 
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    async def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter) -> None:
+    async def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         respx_mock.post("/chat/completions").mock(side_effect=httpx.TimeoutException("Test timeout error"))
 
         with pytest.raises(APITimeoutError):
-            await self.client.post(
-                "/chat/completions",
-                body=cast(
-                    object,
-                    maybe_transform(
-                        dict(
-                            messages=[
-                                {
-                                    "role": "user",
-                                    "content": "Say this is a test",
-                                }
-                            ],
-                            model="gpt-4o",
-                        ),
-                        CompletionCreateParamsNonStreaming,
-                    ),
-                ),
-                cast_to=httpx.Response,
-                options={"headers": {RAW_RESPONSE_HEADER: "stream"}},
-            )
-
-        assert _get_open_connections(self.client) == 0
+            await async_client.chat.completions.with_streaming_response.create(
+                messages=[
+                    {
+                        "content": "string",
+                        "role": "developer",
+                    }
+                ],
+                model="gpt-4o",
+            ).__aenter__()
+
+        assert _get_open_connections(async_client) == 0
 
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    async def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter) -> None:
+    async def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
         respx_mock.post("/chat/completions").mock(return_value=httpx.Response(500))
 
         with pytest.raises(APIStatusError):
-            await self.client.post(
-                "/chat/completions",
-                body=cast(
-                    object,
-                    maybe_transform(
-                        dict(
-                            messages=[
-                                {
-                                    "role": "user",
-                                    "content": "Say this is a test",
-                                }
-                            ],
-                            model="gpt-4o",
-                        ),
-                        CompletionCreateParamsNonStreaming,
-                    ),
-                ),
-                cast_to=httpx.Response,
-                options={"headers": {RAW_RESPONSE_HEADER: "stream"}},
-            )
-
-        assert _get_open_connections(self.client) == 0
+            await async_client.chat.completions.with_streaming_response.create(
+                messages=[
+                    {
+                        "content": "string",
+                        "role": "developer",
+                    }
+                ],
+                model="gpt-4o",
+            ).__aenter__()
+        assert _get_open_connections(async_client) == 0
 
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
     @pytest.mark.parametrize("failure_mode", ["status", "exception"])
     async def test_retries_taken(
         self,
@@ -1690,7 +1797,6 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
     async def test_omit_retry_count_header(
         self, async_client: AsyncOpenAI, failures_before_success: int, respx_mock: MockRouter
     ) -> None:
@@ -1723,7 +1829,6 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
     async def test_overwrite_retry_count_header(
         self, async_client: AsyncOpenAI, failures_before_success: int, respx_mock: MockRouter
     ) -> None:
@@ -1756,7 +1861,6 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
     @mock.patch("openai._base_client.BaseClient._calculate_retry_timeout", _low_retry_timeout)
     @pytest.mark.respx(base_url=base_url)
-    @pytest.mark.asyncio
     async def test_retries_taken_new_response_class(
         self, async_client: AsyncOpenAI, failures_before_success: int, respx_mock: MockRouter
     ) -> None:
@@ -1785,47 +1889,122 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
             assert response.retries_taken == failures_before_success
             assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success
 
-    def test_get_platform(self) -> None:
-        # A previous implementation of asyncify could leave threads unterminated when
-        # used with nest_asyncio.
-        #
-        # Since nest_asyncio.apply() is global and cannot be un-applied, this
-        # test is run in a separate process to avoid affecting other tests.
-        test_code = dedent("""
-        import asyncio
-        import nest_asyncio
-        import threading
-
-        from openai._utils import asyncify
-        from openai._base_client import get_platform 
-
-        async def test_main() -> None:
-            result = await asyncify(get_platform)()
-            print(result)
-            for thread in threading.enumerate():
-                print(thread.name)
-
-        nest_asyncio.apply()
-        asyncio.run(test_main())
-        """)
-        with subprocess.Popen(
-            [sys.executable, "-c", test_code],
-            text=True,
-        ) as process:
-            timeout = 10  # seconds
-
-            start_time = time.monotonic()
-            while True:
-                return_code = process.poll()
-                if return_code is not None:
-                    if return_code != 0:
-                        raise AssertionError("calling get_platform using asyncify resulted in a non-zero exit code")
-
-                    # success
-                    break
-
-                if time.monotonic() - start_time > timeout:
-                    process.kill()
-                    raise AssertionError("calling get_platform using asyncify resulted in a hung process")
-
-                time.sleep(0.1)
+    async def test_get_platform(self) -> None:
+        platform = await asyncify(get_platform)()
+        assert isinstance(platform, (str, OtherPlatform))
+
+    async def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        # Test that the proxy environment variables are set correctly
+        monkeypatch.setenv("HTTPS_PROXY", "https://example.org")
+
+        client = DefaultAsyncHttpxClient()
+
+        mounts = tuple(client._mounts.items())
+        assert len(mounts) == 1
+        assert mounts[0][0].pattern == "https://"
+
+    @pytest.mark.filterwarnings("ignore:.*deprecated.*:DeprecationWarning")
+    async def test_default_client_creation(self) -> None:
+        # Ensure that the client can be initialized without any exceptions
+        DefaultAsyncHttpxClient(
+            verify=True,
+            cert=None,
+            trust_env=True,
+            http1=True,
+            http2=False,
+            limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
+        )
+
+    @pytest.mark.respx(base_url=base_url)
+    async def test_follow_redirects(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
+        # Test that the default follow_redirects=True allows following redirects
+        respx_mock.post("/redirect").mock(
+            return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"})
+        )
+        respx_mock.get("/redirected").mock(return_value=httpx.Response(200, json={"status": "ok"}))
+
+        response = await async_client.post("/redirect", body={"key": "value"}, cast_to=httpx.Response)
+        assert response.status_code == 200
+        assert response.json() == {"status": "ok"}
+
+    @pytest.mark.respx(base_url=base_url)
+    async def test_follow_redirects_disabled(self, respx_mock: MockRouter, async_client: AsyncOpenAI) -> None:
+        # Test that follow_redirects=False prevents following redirects
+        respx_mock.post("/redirect").mock(
+            return_value=httpx.Response(302, headers={"Location": f"{base_url}/redirected"})
+        )
+
+        with pytest.raises(APIStatusError) as exc_info:
+            await async_client.post(
+                "/redirect", body={"key": "value"}, options={"follow_redirects": False}, cast_to=httpx.Response
+            )
+
+        assert exc_info.value.response.status_code == 302
+        assert exc_info.value.response.headers["Location"] == f"{base_url}/redirected"
+
+    @pytest.mark.asyncio
+    async def test_api_key_before_after_refresh_provider(self) -> None:
+        async def mock_api_key_provider():
+            return "test_bearer_token"
+
+        client = AsyncOpenAI(base_url=base_url, api_key=mock_api_key_provider)
+
+        assert client.api_key == ""
+        assert "Authorization" not in client.auth_headers
+
+        await client._refresh_api_key()
+
+        assert client.api_key == "test_bearer_token"
+        assert client.auth_headers.get("Authorization") == "Bearer test_bearer_token"
+
+    @pytest.mark.asyncio
+    async def test_api_key_before_after_refresh_str(self) -> None:
+        client = AsyncOpenAI(base_url=base_url, api_key="test_api_key")
+
+        assert client.auth_headers.get("Authorization") == "Bearer test_api_key"
+        await client._refresh_api_key()
+
+        assert client.auth_headers.get("Authorization") == "Bearer test_api_key"
+
+    @pytest.mark.asyncio
+    @pytest.mark.respx()
+    async def test_bearer_token_refresh_async(self, respx_mock: MockRouter) -> None:
+        respx_mock.post(base_url + "/chat/completions").mock(
+            side_effect=[
+                httpx.Response(500, json={"error": "server error"}),
+                httpx.Response(200, json={"foo": "bar"}),
+            ]
+        )
+
+        counter = 0
+
+        async def token_provider() -> str:
+            nonlocal counter
+
+            counter += 1
+
+            if counter == 1:
+                return "first"
+
+            return "second"
+
+        client = AsyncOpenAI(base_url=base_url, api_key=token_provider)
+        await client.chat.completions.create(messages=[], model="gpt-4")
+
+        calls = cast("list[MockRequestCall]", respx_mock.calls)
+        assert len(calls) == 2
+
+        assert calls[0].request.headers.get("Authorization") == "Bearer first"
+        assert calls[1].request.headers.get("Authorization") == "Bearer second"
+
+    @pytest.mark.asyncio
+    async def test_copy_auth(self) -> None:
+        async def token_provider_1() -> str:
+            return "test_bearer_token_1"
+
+        async def token_provider_2() -> str:
+            return "test_bearer_token_2"
+
+        client = AsyncOpenAI(base_url=base_url, api_key=token_provider_1).copy(api_key=token_provider_2)
+        await client._refresh_api_key()
+        assert client.auth_headers == {"Authorization": "Bearer test_bearer_token_2"}
diff --git a/tests/test_models.py b/tests/test_models.py
index 30b17e3ac0..588869ee35 100644
--- a/tests/test_models.py
+++ b/tests/test_models.py
@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, List, Union, Optional, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Union, Optional, cast
 from datetime import datetime, timezone
 from typing_extensions import Literal, Annotated, TypeAliasType
 
@@ -8,8 +8,8 @@
 from pydantic import Field
 
 from openai._utils import PropertyInfo
-from openai._compat import PYDANTIC_V2, parse_obj, model_dump, model_json
-from openai._models import BaseModel, construct_type
+from openai._compat import PYDANTIC_V1, parse_obj, model_dump, model_json
+from openai._models import DISCRIMINATOR_CACHE, BaseModel, construct_type
 
 
 class BasicModel(BaseModel):
@@ -294,12 +294,12 @@ class Model(BaseModel):
     assert cast(bool, m.foo) is True
 
     m = Model.construct(foo={"name": 3})
-    if PYDANTIC_V2:
-        assert isinstance(m.foo, Submodel1)
-        assert m.foo.name == 3  # type: ignore
-    else:
+    if PYDANTIC_V1:
         assert isinstance(m.foo, Submodel2)
         assert m.foo.name == "3"
+    else:
+        assert isinstance(m.foo, Submodel1)
+        assert m.foo.name == 3  # type: ignore
 
 
 def test_list_of_unions() -> None:
@@ -426,10 +426,10 @@ class Model(BaseModel):
 
     expected = datetime(2019, 12, 27, 18, 11, 19, 117000, tzinfo=timezone.utc)
 
-    if PYDANTIC_V2:
-        expected_json = '{"created_at":"2019-12-27T18:11:19.117000Z"}'
-    else:
+    if PYDANTIC_V1:
         expected_json = '{"created_at": "2019-12-27T18:11:19.117000+00:00"}'
+    else:
+        expected_json = '{"created_at":"2019-12-27T18:11:19.117000Z"}'
 
     model = Model.construct(created_at="2019-12-27T18:11:19.117Z")
     assert model.created_at == expected
@@ -492,12 +492,15 @@ class Model(BaseModel):
         resource_id: Optional[str] = None
 
     m = Model.construct()
+    assert m.resource_id is None
     assert "resource_id" not in m.model_fields_set
 
     m = Model.construct(resource_id=None)
+    assert m.resource_id is None
     assert "resource_id" in m.model_fields_set
 
     m = Model.construct(resource_id="foo")
+    assert m.resource_id == "foo"
     assert "resource_id" in m.model_fields_set
 
 
@@ -528,7 +531,7 @@ class Model2(BaseModel):
     assert m4.to_dict(mode="python") == {"created_at": datetime.fromisoformat(time_str)}
     assert m4.to_dict(mode="json") == {"created_at": time_str}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"):
             m.to_dict(warnings=False)
 
@@ -553,7 +556,7 @@ class Model(BaseModel):
     assert m3.model_dump() == {"foo": None}
     assert m3.model_dump(exclude_none=True) == {}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"):
             m.model_dump(round_trip=True)
 
@@ -577,10 +580,10 @@ class Model(BaseModel):
     assert json.loads(m.to_json()) == {"FOO": "hello"}
     assert json.loads(m.to_json(use_api_names=False)) == {"foo": "hello"}
 
-    if PYDANTIC_V2:
-        assert m.to_json(indent=None) == '{"FOO":"hello"}'
-    else:
+    if PYDANTIC_V1:
         assert m.to_json(indent=None) == '{"FOO": "hello"}'
+    else:
+        assert m.to_json(indent=None) == '{"FOO":"hello"}'
 
     m2 = Model()
     assert json.loads(m2.to_json()) == {}
@@ -592,7 +595,7 @@ class Model(BaseModel):
     assert json.loads(m3.to_json()) == {"FOO": None}
     assert json.loads(m3.to_json(exclude_none=True)) == {}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"):
             m.to_json(warnings=False)
 
@@ -619,7 +622,7 @@ class Model(BaseModel):
     assert json.loads(m3.model_dump_json()) == {"foo": None}
     assert json.loads(m3.model_dump_json(exclude_none=True)) == {}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"):
             m.model_dump_json(round_trip=True)
 
@@ -676,12 +679,12 @@ class B(BaseModel):
     )
     assert isinstance(m, A)
     assert m.type == "a"
-    if PYDANTIC_V2:
-        assert m.data == 100  # type: ignore[comparison-overlap]
-    else:
+    if PYDANTIC_V1:
         # pydantic v1 automatically converts inputs to strings
         # if the expected type is a str
         assert m.data == "100"
+    else:
+        assert m.data == 100  # type: ignore[comparison-overlap]
 
 
 def test_discriminated_unions_unknown_variant() -> None:
@@ -765,12 +768,12 @@ class B(BaseModel):
     )
     assert isinstance(m, A)
     assert m.foo_type == "a"
-    if PYDANTIC_V2:
-        assert m.data == 100  # type: ignore[comparison-overlap]
-    else:
+    if PYDANTIC_V1:
         # pydantic v1 automatically converts inputs to strings
         # if the expected type is a str
         assert m.data == "100"
+    else:
+        assert m.data == 100  # type: ignore[comparison-overlap]
 
 
 def test_discriminated_unions_overlapping_discriminators_invalid_data() -> None:
@@ -806,7 +809,7 @@ class B(BaseModel):
 
     UnionType = cast(Any, Union[A, B])
 
-    assert not hasattr(UnionType, "__discriminator__")
+    assert not DISCRIMINATOR_CACHE.get(UnionType)
 
     m = construct_type(
         value={"type": "b", "data": "foo"}, type_=cast(Any, Annotated[UnionType, PropertyInfo(discriminator="type")])
@@ -815,7 +818,7 @@ class B(BaseModel):
     assert m.type == "b"
     assert m.data == "foo"  # type: ignore[comparison-overlap]
 
-    discriminator = UnionType.__discriminator__
+    discriminator = DISCRIMINATOR_CACHE.get(UnionType)
     assert discriminator is not None
 
     m = construct_type(
@@ -827,12 +830,12 @@ class B(BaseModel):
 
     # if the discriminator details object stays the same between invocations then
     # we hit the cache
-    assert UnionType.__discriminator__ is discriminator
+    assert DISCRIMINATOR_CACHE.get(UnionType) is discriminator
 
 
-@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1")
+@pytest.mark.skipif(PYDANTIC_V1, reason="TypeAliasType is not supported in Pydantic v1")
 def test_type_alias_type() -> None:
-    Alias = TypeAliasType("Alias", str)
+    Alias = TypeAliasType("Alias", str)  # pyright: ignore
 
     class Model(BaseModel):
         alias: Alias
@@ -846,7 +849,7 @@ class Model(BaseModel):
     assert m.union == "bar"
 
 
-@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1")
+@pytest.mark.skipif(PYDANTIC_V1, reason="TypeAliasType is not supported in Pydantic v1")
 def test_field_named_cls() -> None:
     class Model(BaseModel):
         cls: str
@@ -854,3 +857,107 @@ class Model(BaseModel):
     m = construct_type(value={"cls": "foo"}, type_=Model)
     assert isinstance(m, Model)
     assert isinstance(m.cls, str)
+
+
+def test_discriminated_union_case() -> None:
+    class A(BaseModel):
+        type: Literal["a"]
+
+        data: bool
+
+    class B(BaseModel):
+        type: Literal["b"]
+
+        data: List[Union[A, object]]
+
+    class ModelA(BaseModel):
+        type: Literal["modelA"]
+
+        data: int
+
+    class ModelB(BaseModel):
+        type: Literal["modelB"]
+
+        required: str
+
+        data: Union[A, B]
+
+    # when constructing ModelA | ModelB, value data doesn't match ModelB exactly - missing `required`
+    m = construct_type(
+        value={"type": "modelB", "data": {"type": "a", "data": True}},
+        type_=cast(Any, Annotated[Union[ModelA, ModelB], PropertyInfo(discriminator="type")]),
+    )
+
+    assert isinstance(m, ModelB)
+
+
+def test_nested_discriminated_union() -> None:
+    class InnerType1(BaseModel):
+        type: Literal["type_1"]
+
+    class InnerModel(BaseModel):
+        inner_value: str
+
+    class InnerType2(BaseModel):
+        type: Literal["type_2"]
+        some_inner_model: InnerModel
+
+    class Type1(BaseModel):
+        base_type: Literal["base_type_1"]
+        value: Annotated[
+            Union[
+                InnerType1,
+                InnerType2,
+            ],
+            PropertyInfo(discriminator="type"),
+        ]
+
+    class Type2(BaseModel):
+        base_type: Literal["base_type_2"]
+
+    T = Annotated[
+        Union[
+            Type1,
+            Type2,
+        ],
+        PropertyInfo(discriminator="base_type"),
+    ]
+
+    model = construct_type(
+        type_=T,
+        value={
+            "base_type": "base_type_1",
+            "value": {
+                "type": "type_2",
+            },
+        },
+    )
+    assert isinstance(model, Type1)
+    assert isinstance(model.value, InnerType2)
+
+
+@pytest.mark.skipif(PYDANTIC_V1, reason="this is only supported in pydantic v2 for now")
+def test_extra_properties() -> None:
+    class Item(BaseModel):
+        prop: int
+
+    class Model(BaseModel):
+        __pydantic_extra__: Dict[str, Item] = Field(init=False)  # pyright: ignore[reportIncompatibleVariableOverride]
+
+        other: str
+
+        if TYPE_CHECKING:
+
+            def __getattr__(self, attr: str) -> Item: ...
+
+    model = construct_type(
+        type_=Model,
+        value={
+            "a": {"prop": 1},
+            "other": "foo",
+        },
+    )
+    assert isinstance(model, Model)
+    assert model.a.prop == 1
+    assert isinstance(model.a, Item)
+    assert model.other == "foo"
diff --git a/tests/test_module_client.py b/tests/test_module_client.py
index 6bab33a1d7..9c9a1addab 100644
--- a/tests/test_module_client.py
+++ b/tests/test_module_client.py
@@ -17,6 +17,7 @@ def reset_state() -> None:
     openai.api_key = None or "My API Key"
     openai.organization = None
     openai.project = None
+    openai.webhook_secret = None
     openai.base_url = None
     openai.timeout = DEFAULT_TIMEOUT
     openai.max_retries = DEFAULT_MAX_RETRIES
diff --git a/tests/test_transform.py b/tests/test_transform.py
index 385fbe2b2c..bece75dfc7 100644
--- a/tests/test_transform.py
+++ b/tests/test_transform.py
@@ -8,14 +8,14 @@
 
 import pytest
 
-from openai._types import Base64FileInput
+from openai._types import Base64FileInput, omit, not_given
 from openai._utils import (
     PropertyInfo,
     transform as _transform,
     parse_datetime,
     async_transform as _async_transform,
 )
-from openai._compat import PYDANTIC_V2
+from openai._compat import PYDANTIC_V1
 from openai._models import BaseModel
 
 _T = TypeVar("_T")
@@ -189,7 +189,7 @@ class DateModel(BaseModel):
 @pytest.mark.asyncio
 async def test_iso8601_format(use_async: bool) -> None:
     dt = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00")
-    tz = "Z" if PYDANTIC_V2 else "+00:00"
+    tz = "+00:00" if PYDANTIC_V1 else "Z"
     assert await transform({"foo": dt}, DatetimeDict, use_async) == {"foo": "2023-02-23T14:16:36.337692+00:00"}  # type: ignore[comparison-overlap]
     assert await transform(DatetimeModel(foo=dt), Any, use_async) == {"foo": "2023-02-23T14:16:36.337692" + tz}  # type: ignore[comparison-overlap]
 
@@ -297,11 +297,11 @@ async def test_pydantic_unknown_field(use_async: bool) -> None:
 @pytest.mark.asyncio
 async def test_pydantic_mismatched_types(use_async: bool) -> None:
     model = MyModel.construct(foo=True)
-    if PYDANTIC_V2:
+    if PYDANTIC_V1:
+        params = await transform(model, Any, use_async)
+    else:
         with pytest.warns(UserWarning):
             params = await transform(model, Any, use_async)
-    else:
-        params = await transform(model, Any, use_async)
     assert cast(Any, params) == {"foo": True}
 
 
@@ -309,11 +309,11 @@ async def test_pydantic_mismatched_types(use_async: bool) -> None:
 @pytest.mark.asyncio
 async def test_pydantic_mismatched_object_type(use_async: bool) -> None:
     model = MyModel.construct(foo=MyModel.construct(hello="world"))
-    if PYDANTIC_V2:
+    if PYDANTIC_V1:
+        params = await transform(model, Any, use_async)
+    else:
         with pytest.warns(UserWarning):
             params = await transform(model, Any, use_async)
-    else:
-        params = await transform(model, Any, use_async)
     assert cast(Any, params) == {"foo": {"hello": "world"}}
 
 
@@ -432,3 +432,29 @@ async def test_base64_file_input(use_async: bool) -> None:
     assert await transform({"foo": io.BytesIO(b"Hello, world!")}, TypedDictBase64Input, use_async) == {
         "foo": "SGVsbG8sIHdvcmxkIQ=="
     }  # type: ignore[comparison-overlap]
+
+
+@parametrize
+@pytest.mark.asyncio
+async def test_transform_skipping(use_async: bool) -> None:
+    # lists of ints are left as-is
+    data = [1, 2, 3]
+    assert await transform(data, List[int], use_async) is data
+
+    # iterables of ints are converted to a list
+    data = iter([1, 2, 3])
+    assert await transform(data, Iterable[int], use_async) == [1, 2, 3]
+
+
+@parametrize
+@pytest.mark.asyncio
+async def test_strips_notgiven(use_async: bool) -> None:
+    assert await transform({"foo_bar": "bar"}, Foo1, use_async) == {"fooBar": "bar"}
+    assert await transform({"foo_bar": not_given}, Foo1, use_async) == {}
+
+
+@parametrize
+@pytest.mark.asyncio
+async def test_strips_omit(use_async: bool) -> None:
+    assert await transform({"foo_bar": "bar"}, Foo1, use_async) == {"fooBar": "bar"}
+    assert await transform({"foo_bar": omit}, Foo1, use_async) == {}
diff --git a/tests/test_utils/test_datetime_parse.py b/tests/test_utils/test_datetime_parse.py
new file mode 100644
index 0000000000..44c33a4ccb
--- /dev/null
+++ b/tests/test_utils/test_datetime_parse.py
@@ -0,0 +1,110 @@
+"""
+Copied from https://github.com/pydantic/pydantic/blob/v1.10.22/tests/test_datetime_parse.py
+with modifications so it works without pydantic v1 imports.
+"""
+
+from typing import Type, Union
+from datetime import date, datetime, timezone, timedelta
+
+import pytest
+
+from openai._utils import parse_date, parse_datetime
+
+
+def create_tz(minutes: int) -> timezone:
+    return timezone(timedelta(minutes=minutes))
+
+
+@pytest.mark.parametrize(
+    "value,result",
+    [
+        # Valid inputs
+        ("1494012444.883309", date(2017, 5, 5)),
+        (b"1494012444.883309", date(2017, 5, 5)),
+        (1_494_012_444.883_309, date(2017, 5, 5)),
+        ("1494012444", date(2017, 5, 5)),
+        (1_494_012_444, date(2017, 5, 5)),
+        (0, date(1970, 1, 1)),
+        ("2012-04-23", date(2012, 4, 23)),
+        (b"2012-04-23", date(2012, 4, 23)),
+        ("2012-4-9", date(2012, 4, 9)),
+        (date(2012, 4, 9), date(2012, 4, 9)),
+        (datetime(2012, 4, 9, 12, 15), date(2012, 4, 9)),
+        # Invalid inputs
+        ("x20120423", ValueError),
+        ("2012-04-56", ValueError),
+        (19_999_999_999, date(2603, 10, 11)),  # just before watershed
+        (20_000_000_001, date(1970, 8, 20)),  # just after watershed
+        (1_549_316_052, date(2019, 2, 4)),  # nowish in s
+        (1_549_316_052_104, date(2019, 2, 4)),  # nowish in ms
+        (1_549_316_052_104_324, date(2019, 2, 4)),  # nowish in μs
+        (1_549_316_052_104_324_096, date(2019, 2, 4)),  # nowish in ns
+        ("infinity", date(9999, 12, 31)),
+        ("inf", date(9999, 12, 31)),
+        (float("inf"), date(9999, 12, 31)),
+        ("infinity ", date(9999, 12, 31)),
+        (int("1" + "0" * 100), date(9999, 12, 31)),
+        (1e1000, date(9999, 12, 31)),
+        ("-infinity", date(1, 1, 1)),
+        ("-inf", date(1, 1, 1)),
+        ("nan", ValueError),
+    ],
+)
+def test_date_parsing(value: Union[str, bytes, int, float], result: Union[date, Type[Exception]]) -> None:
+    if type(result) == type and issubclass(result, Exception):  # pyright: ignore[reportUnnecessaryIsInstance]
+        with pytest.raises(result):
+            parse_date(value)
+    else:
+        assert parse_date(value) == result
+
+
+@pytest.mark.parametrize(
+    "value,result",
+    [
+        # Valid inputs
+        # values in seconds
+        ("1494012444.883309", datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)),
+        (1_494_012_444.883_309, datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)),
+        ("1494012444", datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        (b"1494012444", datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        (1_494_012_444, datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        # values in ms
+        ("1494012444000.883309", datetime(2017, 5, 5, 19, 27, 24, 883, tzinfo=timezone.utc)),
+        ("-1494012444000.883309", datetime(1922, 8, 29, 4, 32, 35, 999117, tzinfo=timezone.utc)),
+        (1_494_012_444_000, datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        ("2012-04-23T09:15:00", datetime(2012, 4, 23, 9, 15)),
+        ("2012-4-9 4:8:16", datetime(2012, 4, 9, 4, 8, 16)),
+        ("2012-04-23T09:15:00Z", datetime(2012, 4, 23, 9, 15, 0, 0, timezone.utc)),
+        ("2012-4-9 4:8:16-0320", datetime(2012, 4, 9, 4, 8, 16, 0, create_tz(-200))),
+        ("2012-04-23T10:20:30.400+02:30", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(150))),
+        ("2012-04-23T10:20:30.400+02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(120))),
+        ("2012-04-23T10:20:30.400-02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))),
+        (b"2012-04-23T10:20:30.400-02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))),
+        (datetime(2017, 5, 5), datetime(2017, 5, 5)),
+        (0, datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc)),
+        # Invalid inputs
+        ("x20120423091500", ValueError),
+        ("2012-04-56T09:15:90", ValueError),
+        ("2012-04-23T11:05:00-25:00", ValueError),
+        (19_999_999_999, datetime(2603, 10, 11, 11, 33, 19, tzinfo=timezone.utc)),  # just before watershed
+        (20_000_000_001, datetime(1970, 8, 20, 11, 33, 20, 1000, tzinfo=timezone.utc)),  # just after watershed
+        (1_549_316_052, datetime(2019, 2, 4, 21, 34, 12, 0, tzinfo=timezone.utc)),  # nowish in s
+        (1_549_316_052_104, datetime(2019, 2, 4, 21, 34, 12, 104_000, tzinfo=timezone.utc)),  # nowish in ms
+        (1_549_316_052_104_324, datetime(2019, 2, 4, 21, 34, 12, 104_324, tzinfo=timezone.utc)),  # nowish in μs
+        (1_549_316_052_104_324_096, datetime(2019, 2, 4, 21, 34, 12, 104_324, tzinfo=timezone.utc)),  # nowish in ns
+        ("infinity", datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        ("inf", datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        ("inf ", datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        (1e50, datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        (float("inf"), datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        ("-infinity", datetime(1, 1, 1, 0, 0)),
+        ("-inf", datetime(1, 1, 1, 0, 0)),
+        ("nan", ValueError),
+    ],
+)
+def test_datetime_parsing(value: Union[str, bytes, int, float], result: Union[datetime, Type[Exception]]) -> None:
+    if type(result) == type and issubclass(result, Exception):  # pyright: ignore[reportUnnecessaryIsInstance]
+        with pytest.raises(result):
+            parse_datetime(value)
+    else:
+        assert parse_datetime(value) == result
diff --git a/tests/test_utils/test_proxy.py b/tests/test_utils/test_proxy.py
index aedd3731ee..2b5ff19dab 100644
--- a/tests/test_utils/test_proxy.py
+++ b/tests/test_utils/test_proxy.py
@@ -3,6 +3,7 @@
 from typing_extensions import override
 
 from openai._utils import LazyProxy
+from openai._extras._common import MissingDependencyError
 
 
 class RecursiveLazyProxy(LazyProxy[Any]):
@@ -21,3 +22,14 @@ def test_recursive_proxy() -> None:
     assert dir(proxy) == []
     assert type(proxy).__name__ == "RecursiveLazyProxy"
     assert type(operator.attrgetter("name.foo.bar.baz")(proxy)).__name__ == "RecursiveLazyProxy"
+
+
+def test_isinstance_does_not_error() -> None:
+    class MissingDepsProxy(LazyProxy[Any]):
+        @override
+        def __load__(self) -> Any:
+            raise MissingDependencyError("Mocking missing dependency")
+
+    proxy = MissingDepsProxy()
+    assert not isinstance(proxy, dict)
+    assert isinstance(proxy, LazyProxy)
diff --git a/tests/utils.py b/tests/utils.py
index 4cf5ce171b..e03ed1a039 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -5,7 +5,7 @@
 import inspect
 import traceback
 import contextlib
-from typing import Any, TypeVar, Iterator, ForwardRef, cast
+from typing import Any, TypeVar, Iterator, Sequence, ForwardRef, cast
 from datetime import date, datetime
 from typing_extensions import Literal, get_args, get_origin, assert_type
 
@@ -18,10 +18,11 @@
     is_list_type,
     is_union_type,
     extract_type_arg,
+    is_sequence_type,
     is_annotated_type,
     is_type_alias_type,
 )
-from openai._compat import PYDANTIC_V2, field_outer_type, get_model_fields
+from openai._compat import PYDANTIC_V1, field_outer_type, get_model_fields
 from openai._models import BaseModel
 
 BaseModelT = TypeVar("BaseModelT", bound=BaseModel)
@@ -34,12 +35,12 @@ def evaluate_forwardref(forwardref: ForwardRef, globalns: dict[str, Any]) -> typ
 def assert_matches_model(model: type[BaseModelT], value: BaseModelT, *, path: list[str]) -> bool:
     for name, field in get_model_fields(model).items():
         field_value = getattr(value, name)
-        if PYDANTIC_V2:
-            allow_none = False
-        else:
+        if PYDANTIC_V1:
             # in v1 nullability was structured differently
             # https://docs.pydantic.dev/2.0/migration/#required-optional-and-nullable-fields
             allow_none = getattr(field, "allow_none", False)
+        else:
+            allow_none = False
 
         assert_matches_type(
             field_outer_type(field),
@@ -78,6 +79,13 @@ def assert_matches_type(
     if is_list_type(type_):
         return _assert_list_type(type_, value)
 
+    if is_sequence_type(type_):
+        assert isinstance(value, Sequence)
+        inner_type = get_args(type_)[0]
+        for entry in value:  # type: ignore
+            assert_type(inner_type, entry)  # type: ignore
+        return
+
     if origin == str:
         assert isinstance(value, str)
     elif origin == int: