openai-fast-transform 0.1.0__tar.gz

openai_fast_transform-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.venv*/
+.ruff_cache/
+.pytest_cache/
+dist/
+build/
+*.egg-info/

openai_fast_transform-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rasmus Faber-Espensen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openai_fast_transform-0.1.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.5
+Name: openai-fast-transform
+Version: 0.1.0
+Summary: An exact, compiled replacement for the openai SDK's request transform.
+Project-URL: Repository, https://github.com/rasmusfaber/openai-fast-transform
+Project-URL: Issues, https://github.com/rasmusfaber/openai-fast-transform/issues
+Author: Rasmus Faber-Espensen
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: openai>=1.108.1
+Requires-Dist: typing-extensions>=4.11
+Description-Content-Type: text/markdown
+
+# openai-fast-transform
+
+An exact, compiled replacement for the [openai](https://github.com/openai/openai-python)
+SDK's request transform.
+
+Before sending a request, openai-python passes the body through
+`openai._utils._transform`, which walks it node by node and re-derives the parameter
+type's structure with typing introspection for every value on every call. That costs about
+0.25 ms per Responses input item, so an agent with a long transcript spends hundreds of
+milliseconds of event-loop time on every model call before any I/O happens.
+`openai_fast_transform.install()` swaps in a version that compiles each parameter type once
+and gives the same result as stock: hundreds of times faster on Responses requests and over
+100 times faster on Chat Completions requests (see the benchmarks below).
+
+## Usage
+
+```python
+import openai_fast_transform
+
+openai_fast_transform.install()  # once, before the first request
+```
+
+`install()` returns `True` when the compiled transform is in place. It does nothing until
+you call it (no import-time side effects, no environment variables) and never raises. If the
+installed openai is not a verified release, or anything goes wrong, it logs a WARNING on the
+`openai_fast_transform` logger, keeps the stock transform and returns `False`. On success it
+logs the openai version and profile at INFO. Only the first call checks openai and logs;
+later calls return its result.
+
+## Guarantees
+
+For every value and every annotation the SDK passes, the patched functions return a value
+strictly equal to stock's (same container classes, dict key order, key objects and leaf
+objects), raise the same exception at the same point, and have the same side effects
+(generator consumption, file reads and whether they are sync or async, `model_dump` calls
+and arguments, `__api_exclude__` reads). They may copy more than stock, but never return a
+caller-owned container where stock returns a fresh one. Carve-outs:
+
+1. Union arm order that depends on the history of openai's equality-keyed `lru_cache`s
+   (`Union[A, B] == Union[B, A]`). A test asserts that no order-sensitive pair is reachable
+   from openai's own param types.
+2. The depth at which `RecursionError` or `MemoryError` occurs.
+3. Third parties re-patching openai helpers or mutating `PropertyInfo` objects after
+   `install()`.
+4. User dunders run by type checks (`__class__`, `__instancecheck__`, ABC hooks) may run a
+   different number of times.
+
+The test suite checks this differentially against stock, sync and async: quirk cases,
+synthetic fuzzing over aliases, formats, unions, recursive and unresolvable types, and
+fuzzing over every TypedDict in `openai.types`. The full argument is in the header comment
+of [`_transform.py`](https://github.com/rasmusfaber/openai-fast-transform/blob/main/src/openai_fast_transform/_transform.py).
+
+## Supported openai releases
+
+`install()` only patches an openai whose normalised `_utils/_transform.py` (docstrings,
+annotations and `cast` calls dropped) and the `is_given` and `is_base64_file_input` helpers
+have known fingerprints, and whose loaded functions are the ones compiled from that source.
+Anything else keeps the stock transform, so the dependency has no upper bound.
+
+| openai releases  | profile |
+| ---------------- | ------- |
+| 1.108.1 – 3.11.0 | A       |
+| 3.12.0 – 3.18.0  | B       |
+| 3.19.0 – 3.43.0  | C       |
+
+The ranges come from fingerprinting every release from 1.0.0 to 3.43.0; the fingerprints
+are identical on Python 3.12, 3.13 and 3.14. Releases before 1.108.1 are refused. CI tests
+both ends of every range, and a weekly job tests the newest openai on PyPI.
+
+`python -m openai_fast_transform` prints what the gate sees (it exits 1 if the release is
+refused):
+
+```
+openai 3.43.0
+_transform.py 972f4e003507b0ccfced9a9a08e4fafb55b55f6a28c5e14b8b14f75f75014412
+is_given a5e2169fcf23b5b0e42ee616ee372dddb848f1f14db2a4706bed313e94caa62b
+is_base64_file_input 7a7155747eff3c1445c585d97f6dbe7e83a72ac99ba3bfa870f72f3ab13c7be6
+profile C
+```
+
+## Benchmarks
+
+`openai._utils._transform.transform` / `async_transform` on two synthetic request bodies:
+
+- Responses (`ResponseCreateParamsNonStreaming`): a developer and a user message, then
+  repeated reasoning (6,000-character `encrypted_content`), `function_call` and
+  `function_call_output` items up to the given number of input items, two function tools
+  and the usual omitted fields.
+- Chat Completions (`CompletionCreateParamsNonStreaming`), 1 MB of JSON: a system and a
+  user message (2,000 characters each), then 311 assistant messages (300 characters of
+  text and one function tool call) each followed by a tool message with a 2,700-character
+  result, 624 messages in all, two function tools and the usual omitted fields.
+
+These are medians of 21 runs on Python 3.13.12, openai 3.43.0 and an AMD Ryzen 7 9800X3D.
+
+| request                | mode  | stock (ms) | patched (ms) | speed-up |
+| ---------------------- | ----- | ---------: | -----------: | -------: |
+| Responses, 50 items    | sync  |       13.9 |         0.02 |     601x |
+| Responses, 50 items    | async |       14.2 |         0.03 |     444x |
+| Responses, 300 items   | sync  |       84.8 |         0.13 |     666x |
+| Responses, 300 items   | async |       84.1 |         0.16 |     536x |
+| Responses, 1000 items  | sync  |      284.6 |         0.43 |     662x |
+| Responses, 1000 items  | async |      299.3 |         0.45 |     661x |
+| Chat Completions, 1 MB | sync  |       50.2 |         0.36 |     138x |
+| Chat Completions, 1 MB | async |       54.6 |         0.37 |     147x |
+
+`install()` takes about 10 ms. The first call for a parameter type compiles its plans, once
+per process for sync and once for async: 14 ms and 8 ms for the Responses create params.
+
+## Limitations
+
+- Plans are compiled only for openai's own types. Anything else, such as a user-defined
+  TypedDict or `Annotated` metadata that is not openai's `PropertyInfo`, runs the stock
+  transform for that part of the request.
+- openai only. anthropic 1.8 and later already replaced this transform upstream.
+- After 20,000 compiled nodes (all of `openai.types` takes about 4,800), new annotations
+  use the stock transform, so callers that build a new annotation per call cannot grow
+  memory without bound.
+
+## Maintenance
+
+When a new openai release changes the transform, `install()` refuses it and the weekly
+**Newest openai** workflow fails. GitHub disables scheduled workflows in a public repository
+after 60 days without activity; if **Newest openai** is disabled, re-enable it under
+Actions. To support the release:
+
+1. Install it and run `python -m openai_fast_transform` to get its fingerprints.
+2. Diff `src/openai/_utils/_transform.py`, `is_given` and `is_base64_file_input` against the
+   last verified release in openai-python's git history. Decide whether the change only
+   reaches helpers the plans call live (the same profile) or changes a branch the compiler
+   mirrors (a new profile, with a matching change in `_Compiler` and `_Node.apply`).
+3. Add the fingerprint and its release range to `_PROFILES` (or `_HELPERS`) in
+   [`_transform.py`](https://github.com/rasmusfaber/openai-fast-transform/blob/main/src/openai_fast_transform/_transform.py).
+   For a new profile, also add its first release to `_FIRST_RELEASES` in
+   `tests/test_transform.py`.
+4. Run the tests against the new release and add it to the `test-openai` matrix in
+   `.github/workflows/pr-and-main.yaml`. Update the table above.
+
+## Development
+
+```bash
+uv sync --all-groups
+uv run pytest -n auto
+uv run ruff check && uv run ruff format --check && uv run basedpyright
+
+# Against another openai release (uv sync restores the locked one):
+uv pip install openai==3.12.0 && uv run --no-sync pytest -n auto
+
+# On another Python:
+UV_PROJECT_ENVIRONMENT=.venv-3.12 uv run --python 3.12 --all-groups pytest -n auto
+```
+
+To release, publish a GitHub release tagged `vX.Y.Z`. The **Release** workflow builds the
+sdist and wheel and uploads them with PyPI Trusted Publishing (the PyPI project trusts
+`release.yaml` in the `pypi` environment).
+
+## License
+
+MIT. See [LICENSE](https://github.com/rasmusfaber/openai-fast-transform/blob/main/LICENSE).

openai_fast_transform-0.1.0/README.md

@@ -0,0 +1,159 @@
+# openai-fast-transform
+
+An exact, compiled replacement for the [openai](https://github.com/openai/openai-python)
+SDK's request transform.
+
+Before sending a request, openai-python passes the body through
+`openai._utils._transform`, which walks it node by node and re-derives the parameter
+type's structure with typing introspection for every value on every call. That costs about
+0.25 ms per Responses input item, so an agent with a long transcript spends hundreds of
+milliseconds of event-loop time on every model call before any I/O happens.
+`openai_fast_transform.install()` swaps in a version that compiles each parameter type once
+and gives the same result as stock: hundreds of times faster on Responses requests and over
+100 times faster on Chat Completions requests (see the benchmarks below).
+
+## Usage
+
+```python
+import openai_fast_transform
+
+openai_fast_transform.install()  # once, before the first request
+```
+
+`install()` returns `True` when the compiled transform is in place. It does nothing until
+you call it (no import-time side effects, no environment variables) and never raises. If the
+installed openai is not a verified release, or anything goes wrong, it logs a WARNING on the
+`openai_fast_transform` logger, keeps the stock transform and returns `False`. On success it
+logs the openai version and profile at INFO. Only the first call checks openai and logs;
+later calls return its result.
+
+## Guarantees
+
+For every value and every annotation the SDK passes, the patched functions return a value
+strictly equal to stock's (same container classes, dict key order, key objects and leaf
+objects), raise the same exception at the same point, and have the same side effects
+(generator consumption, file reads and whether they are sync or async, `model_dump` calls
+and arguments, `__api_exclude__` reads). They may copy more than stock, but never return a
+caller-owned container where stock returns a fresh one. Carve-outs:
+
+1. Union arm order that depends on the history of openai's equality-keyed `lru_cache`s
+   (`Union[A, B] == Union[B, A]`). A test asserts that no order-sensitive pair is reachable
+   from openai's own param types.
+2. The depth at which `RecursionError` or `MemoryError` occurs.
+3. Third parties re-patching openai helpers or mutating `PropertyInfo` objects after
+   `install()`.
+4. User dunders run by type checks (`__class__`, `__instancecheck__`, ABC hooks) may run a
+   different number of times.
+
+The test suite checks this differentially against stock, sync and async: quirk cases,
+synthetic fuzzing over aliases, formats, unions, recursive and unresolvable types, and
+fuzzing over every TypedDict in `openai.types`. The full argument is in the header comment
+of [`_transform.py`](https://github.com/rasmusfaber/openai-fast-transform/blob/main/src/openai_fast_transform/_transform.py).
+
+## Supported openai releases
+
+`install()` only patches an openai whose normalised `_utils/_transform.py` (docstrings,
+annotations and `cast` calls dropped) and the `is_given` and `is_base64_file_input` helpers
+have known fingerprints, and whose loaded functions are the ones compiled from that source.
+Anything else keeps the stock transform, so the dependency has no upper bound.
+
+| openai releases  | profile |
+| ---------------- | ------- |
+| 1.108.1 – 3.11.0 | A       |
+| 3.12.0 – 3.18.0  | B       |
+| 3.19.0 – 3.43.0  | C       |
+
+The ranges come from fingerprinting every release from 1.0.0 to 3.43.0; the fingerprints
+are identical on Python 3.12, 3.13 and 3.14. Releases before 1.108.1 are refused. CI tests
+both ends of every range, and a weekly job tests the newest openai on PyPI.
+
+`python -m openai_fast_transform` prints what the gate sees (it exits 1 if the release is
+refused):
+
+```
+openai 3.43.0
+_transform.py 972f4e003507b0ccfced9a9a08e4fafb55b55f6a28c5e14b8b14f75f75014412
+is_given a5e2169fcf23b5b0e42ee616ee372dddb848f1f14db2a4706bed313e94caa62b
+is_base64_file_input 7a7155747eff3c1445c585d97f6dbe7e83a72ac99ba3bfa870f72f3ab13c7be6
+profile C
+```
+
+## Benchmarks
+
+`openai._utils._transform.transform` / `async_transform` on two synthetic request bodies:
+
+- Responses (`ResponseCreateParamsNonStreaming`): a developer and a user message, then
+  repeated reasoning (6,000-character `encrypted_content`), `function_call` and
+  `function_call_output` items up to the given number of input items, two function tools
+  and the usual omitted fields.
+- Chat Completions (`CompletionCreateParamsNonStreaming`), 1 MB of JSON: a system and a
+  user message (2,000 characters each), then 311 assistant messages (300 characters of
+  text and one function tool call) each followed by a tool message with a 2,700-character
+  result, 624 messages in all, two function tools and the usual omitted fields.
+
+These are medians of 21 runs on Python 3.13.12, openai 3.43.0 and an AMD Ryzen 7 9800X3D.
+
+| request                | mode  | stock (ms) | patched (ms) | speed-up |
+| ---------------------- | ----- | ---------: | -----------: | -------: |
+| Responses, 50 items    | sync  |       13.9 |         0.02 |     601x |
+| Responses, 50 items    | async |       14.2 |         0.03 |     444x |
+| Responses, 300 items   | sync  |       84.8 |         0.13 |     666x |
+| Responses, 300 items   | async |       84.1 |         0.16 |     536x |
+| Responses, 1000 items  | sync  |      284.6 |         0.43 |     662x |
+| Responses, 1000 items  | async |      299.3 |         0.45 |     661x |
+| Chat Completions, 1 MB | sync  |       50.2 |         0.36 |     138x |
+| Chat Completions, 1 MB | async |       54.6 |         0.37 |     147x |
+
+`install()` takes about 10 ms. The first call for a parameter type compiles its plans, once
+per process for sync and once for async: 14 ms and 8 ms for the Responses create params.
+
+## Limitations
+
+- Plans are compiled only for openai's own types. Anything else, such as a user-defined
+  TypedDict or `Annotated` metadata that is not openai's `PropertyInfo`, runs the stock
+  transform for that part of the request.
+- openai only. anthropic 1.8 and later already replaced this transform upstream.
+- After 20,000 compiled nodes (all of `openai.types` takes about 4,800), new annotations
+  use the stock transform, so callers that build a new annotation per call cannot grow
+  memory without bound.
+
+## Maintenance
+
+When a new openai release changes the transform, `install()` refuses it and the weekly
+**Newest openai** workflow fails. GitHub disables scheduled workflows in a public repository
+after 60 days without activity; if **Newest openai** is disabled, re-enable it under
+Actions. To support the release:
+
+1. Install it and run `python -m openai_fast_transform` to get its fingerprints.
+2. Diff `src/openai/_utils/_transform.py`, `is_given` and `is_base64_file_input` against the
+   last verified release in openai-python's git history. Decide whether the change only
+   reaches helpers the plans call live (the same profile) or changes a branch the compiler
+   mirrors (a new profile, with a matching change in `_Compiler` and `_Node.apply`).
+3. Add the fingerprint and its release range to `_PROFILES` (or `_HELPERS`) in
+   [`_transform.py`](https://github.com/rasmusfaber/openai-fast-transform/blob/main/src/openai_fast_transform/_transform.py).
+   For a new profile, also add its first release to `_FIRST_RELEASES` in
+   `tests/test_transform.py`.
+4. Run the tests against the new release and add it to the `test-openai` matrix in
+   `.github/workflows/pr-and-main.yaml`. Update the table above.
+
+## Development
+
+```bash
+uv sync --all-groups
+uv run pytest -n auto
+uv run ruff check && uv run ruff format --check && uv run basedpyright
+
+# Against another openai release (uv sync restores the locked one):
+uv pip install openai==3.12.0 && uv run --no-sync pytest -n auto
+
+# On another Python:
+UV_PROJECT_ENVIRONMENT=.venv-3.12 uv run --python 3.12 --all-groups pytest -n auto
+```
+
+To release, publish a GitHub release tagged `vX.Y.Z`. The **Release** workflow builds the
+sdist and wheel and uploads them with PyPI Trusted Publishing (the PyPI project trusts
+`release.yaml` in the `pypi` environment).
+
+## License
+
+MIT. See [LICENSE](https://github.com/rasmusfaber/openai-fast-transform/blob/main/LICENSE).

openai_fast_transform-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "openai-fast-transform"
+dynamic = ["version"]
+description = "An exact, compiled replacement for the openai SDK's request transform."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Rasmus Faber-Espensen" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+# No upper bound: install() refuses (and keeps stock) on any openai it does not recognise.
+dependencies = [
+    "openai>=1.108.1",
+    "typing-extensions>=4.11",
+]
+
+[project.urls]
+Repository = "https://github.com/rasmusfaber/openai-fast-transform"
+Issues = "https://github.com/rasmusfaber/openai-fast-transform/issues"
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/openai_fast_transform"]
+
+[tool.hatch.build.targets.sdist]
+only-include = [
+    "src/openai_fast_transform",
+    "LICENSE",
+    "README.md",
+    "pyproject.toml",
+]
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.37",
+    "pytest>=8.0",
+    "pytest-xdist>=3.6",
+    "ruff>=0.11",
+]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+# Pinned: newer ruff defaults add pyupgrade fixes that would rewrite the probe's deliberate
+# typing.List/Dict/Union/Optional annotations (the spelling openai's own types use).
+select = ["E4", "E7", "E9", "F"]
+extend-select = ["B006", "E701", "E702", "FA102", "I"]
+
+[tool.basedpyright]
+pythonVersion = "3.12"
+typeCheckingMode = "standard"
+include = [
+    "src",
+    "tests",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

openai_fast_transform-0.1.0/src/openai_fast_transform/__init__.py

@@ -0,0 +1,8 @@
+"""An exact, compiled replacement for the openai SDK's request transform.
+
+Call :func:`install` once, before the first request.
+"""
+
+from openai_fast_transform._transform import install
+
+__all__ = ["install"]

openai_fast_transform-0.1.0/src/openai_fast_transform/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from openai_fast_transform._transform import main
+
+sys.exit(main())

openai_fast_transform-0.1.0/src/openai_fast_transform/_transform.py

@@ -0,0 +1,790 @@
+"""Exact, faster replacement for the openai SDK's request transform.
+
+openai-python passes every request body through ``openai._utils._transform``'s
+``_transform_recursive`` (or its async twin), which re-derives the parameter type's
+structure for every value on every call: about 0.25 ms per Responses input item, so a
+long agent transcript spends hundreds of milliseconds of event-loop time per model call
+in it. :func:`install` replaces both functions with versions that compile each
+parameter type once and return results strictly equal to stock's.
+
+Nothing happens until :func:`install` is called. It only patches an openai whose transform
+source matches a release it was verified against; any other version, or any failure while
+installing, logs a WARNING and leaves the stock transform in place.
+``python -m openai_fast_transform`` prints the installed openai's fingerprints and the
+profile it would use.
+"""
+
+# Contract. For every value and every annotation the SDK passes, the patched functions
+# return a value strictly equal to stock's (same container classes, dict key order, key
+# objects and leaf objects), raise the same exception at the same point, and have the same
+# side effects (generator consumption, file reads and whether they are sync or async,
+# model_dump calls and arguments, __api_exclude__ reads). They may copy more than stock but
+# never return a caller-owned container where stock returns a fresh one. Carve-outs:
+#   1. Union arm order that depends on the history of openai's equality-keyed lru_caches:
+#      Union[A, B] == Union[B, A], so stock's strip_annotated_type can return either order
+#      for either. A test asserts no order-sensitive pair is reachable from openai's params.
+#   2. The depth at which RecursionError or MemoryError occurs.
+#   3. Third parties re-patching openai helpers or mutating PropertyInfo objects after the
+#      compiled transform is installed.
+#   4. User dunders run by type checks (__class__, __instancecheck__, ABC hooks) may run a
+#      different number of times.
+#
+# Scope. Plans are compiled only for SDK-defined types (see _in_scope). Anything else may
+# run user code from __eq__/__hash__/forward references, so its node calls the original
+# function, which re-enters the patched one for its children.
+#
+# Plans. Each (annotation, inner_type) pair compiles, through the same helper bindings the
+# fingerprinted source uses (vars(openai._utils._transform)), to a _Node that records the
+# branch stock would take and its children. A node whose compilation raises calls the
+# original function instead, so stock raises (or not) exactly where the data leads it.
+# _Node.apply mirrors stock branch by branch (the "faithful" path).
+#
+# Copiers. A node is eligible when nothing reachable from it delegates, renames a key or
+# has a format that is not a str. Every stock branch of an eligible node is the identity
+# on the value of plain data (exact str/int/float/bool/None/dict/list): TypedDict and dict
+# branches rebuild the dict with the same keys in the same order, dropping only
+# Omit/NotGiven; list branches rebuild the list; union arms run in sequence, each identity
+# by value; and a str format leaves plain values unchanged (none is a date or a file
+# input; is_given and is_base64_file_input are fingerprinted). Stock's result is then the
+# data with a fresh container exactly where at least one of the nodes applied at that
+# position copies, which a copier computes from the node structure alone. A copier for a
+# set of nodes (a union's arms are applied at once) answers _NOT_PLAIN instead whenever a
+# node could do anything but copy: a BaseModel, a Mapping that is not a dict, an iterable
+# a list branch would materialise, a non-str dict key, or a value a format might change.
+# The caller then takes the faithful path. Copiers recurse only as deep as the types do,
+# so opaque values (object, Dict[str, object] values, unknown keys) are returned by
+# reference without being walked, as stock does.
+#
+from __future__ import annotations
+
+import ast
+import functools
+import hashlib
+import inspect
+import logging
+import sys
+import threading
+import types
+import typing
+from collections.abc import Callable, Coroutine, Iterable, Mapping
+from typing import Any, Final, cast, override
+
+import typing_extensions
+
+logger = logging.getLogger("openai_fast_transform")
+
+# sha256 of the normalised openai/_utils/_transform.py (see _digest) at every release in
+# each range (identical on Python 3.12-3.14). A raises for bare dict/list annotations; A and
+# B dump BaseModels without `exclude` in the async transform. The NotRequired change of
+# v3.22.1 lives in helpers the plans call, so C covers both. A's file fingerprint starts at
+# v1.106.0, but is_given (below) only matches from v1.108.1, so earlier releases are
+# refused.
+_PROFILES: Final = {
+    "f4fac2b3efba380ab112888bcb8dc448579450af0c6050ad48e26d4334c81ddf": "A",  # 1.106.0-3.11.0
+    "80066a82b76a2e009a83692f11237f016aff07d723097ab8a229171035e1ebcc": "B",  # 3.12.0-3.18.0
+    "f57c110db4046086daec67e77596aa034d5bbf4541bd36a0e1c062ecf1c09d08": "C",  # 3.19.0-3.22.0
+    "972f4e003507b0ccfced9a9a08e4fafb55b55f6a28c5e14b8b14f75f75014412": "C",  # 3.22.1-3.43.0
+}
+# Function-level fingerprints of the helpers the copiers' identity argument relies on,
+# unchanged from v1.108.1 through the newest release above.
+_HELPERS: Final = {
+    "is_given": "a5e2169fcf23b5b0e42ee616ee372dddb848f1f14db2a4706bed313e94caa62b",
+    "is_base64_file_input": "7a7155747eff3c1445c585d97f6dbe7e83a72ac99ba3bfa870f72f3ab13c7be6",
+}
+
+_SCOPE_PREFIXES: tuple[str, ...] = ("openai.",)
+_STD_MODULES: Final = frozenset(
+    {
+        "builtins",
+        "collections.abc",
+        "datetime",
+        "io",
+        "os",
+        "pathlib",
+        "pathlib._local",
+        "types",
+        "typing",
+        "typing_extensions",
+    }
+)
+_SCALARS: Final = frozenset({str, int, float, bool, type(None)})
+# What @functools.lru_cache returns; functools keeps the name private.
+_LRU_CACHE_WRAPPER: Final = type(functools.lru_cache(len))
+# At this many nodes, annotations not yet compiled run stock, so callers that build a new
+# annotation per call cannot grow the tables without bound. Compiling every TypedDict in
+# openai.types takes about 4,800 nodes (openai 3.43.0).
+_MAX_NODES: Final = 20_000
+
+# Node kinds: the branch stock's _transform_recursive takes for an annotation.
+_TD = "typeddict"
+_DICT = "dict"
+_LIST = "list"
+_UNION = "union"
+_LEAF = "leaf"
+_DELEGATE = "delegate"
+_NOT_PLAIN: Final = object()
+# _maybe_transform_key(_KEY_PROBE, hint) is _KEY_PROBE unless the field has an alias.
+_KEY_PROBE: Final = object()
+
+_result: bool | None = None  # install()'s outcome, once it has run
+_install_lock = threading.Lock()
+
+
+class _Refused(Exception):
+    """The loaded openai is not a verified release."""
+
+
+class _Normaliser(ast.NodeTransformer):
+    """Drops what cannot change behaviour: docstrings, annotations and ``cast`` calls."""
+
+    @override
+    def generic_visit(self, node: ast.AST) -> ast.AST:
+        if isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+            first = node.body[0] if node.body else None
+            if (
+                isinstance(first, ast.Expr)
+                and isinstance(first.value, ast.Constant)
+                and isinstance(first.value.value, str)
+            ):
+                node.body = node.body[1:] or [ast.Pass()]
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            node.returns = None
+        elif isinstance(node, ast.arg):
+            node.annotation = None
+        elif isinstance(node, ast.AnnAssign):
+            # Keep the statement: a bare `x: T` still makes `x` a local name.
+            node.annotation = ast.Constant(...)
+        node = super().generic_visit(node)
+        if isinstance(node, ast.Call) and len(node.args) == 2 and not node.keywords:
+            func = node.func
+            if (isinstance(func, ast.Name) and func.id == "cast") or (
+                isinstance(func, ast.Attribute)
+                and func.attr == "cast"
+                and isinstance(func.value, ast.Name)
+                and func.value.id == "typing"
+            ):
+                return node.args[1]
+        return node
+
+
+def _digest(node: ast.AST) -> str:
+    """Fingerprint of a parsed module or function; the same on Python 3.12-3.14."""
+    return hashlib.sha256(ast.unparse(_Normaliser().visit(node)).encode()).hexdigest()
+
+
+def _functions(tree: ast.Module) -> dict[str, ast.FunctionDef | ast.AsyncFunctionDef]:
+    return {
+        node.name: node
+        for node in tree.body
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+    }
+
+
+def _source(module: types.ModuleType) -> str:
+    loader = getattr(module, "__loader__", None)
+    source = None if loader is None else loader.get_source(module.__name__)
+    if source is None:
+        raise _Refused(f"no source for {module.__name__}")
+    return source
+
+
+def _check_code(
+    namespace: Mapping[str, Any],
+    source: str,
+    functions: Mapping[str, ast.FunctionDef | ast.AsyncFunctionDef],
+) -> None:
+    """Refuse unless the loaded functions are the ones compiled from ``source``.
+
+    This catches openai being reinstalled after import (the file no longer matches the
+    code that runs) and anything that wrapped these functions before us.
+    """
+    # Code objects compare equal across filenames.
+    compiled = compile(source, "<openai>", "exec", dont_inherit=True)
+    codes = {
+        const.co_name: const for const in compiled.co_consts if isinstance(const, types.CodeType)
+    }
+    for name, function in functions.items():
+        live = namespace[name]
+        # Exact types: a proxy can fake __class__ and forward __code__ and __wrapped__.
+        if function.decorator_list:  # @lru_cache: compare the function it wraps
+            live = live.__wrapped__ if type(live) is _LRU_CACHE_WRAPPER else None
+        if type(live) is not types.FunctionType or live.__code__ != codes.get(name):
+            raise _Refused(f"the loaded {name} does not match its source")
+
+
+def _helper(
+    namespace: Mapping[str, Any], name: str
+) -> tuple[str, ast.FunctionDef | ast.AsyncFunctionDef | None, str]:
+    """The source of the module defining helper ``name``, its function and fingerprint."""
+    if name not in namespace:
+        raise _Refused(f"{name} is missing")
+    source = _source(sys.modules[namespace[name].__module__])
+    function = _functions(ast.parse(source)).get(name)
+    return source, function, "missing" if function is None else _digest(function)
+
+
+def _check(transform_module: types.ModuleType) -> str:
+    """Return the profile for the loaded openai transform, or raise _Refused."""
+    source = _source(transform_module)
+    tree = ast.parse(source)
+    functions = _functions(tree)
+    digest = _digest(tree)
+    profile = _PROFILES.get(digest)
+    if profile is None:
+        raise _Refused(f"unrecognised _transform.py fingerprint {digest}")
+    namespace = vars(transform_module)
+    _check_code(namespace, source, functions)
+    for name, expected in _HELPERS.items():
+        helper_source, function, digest = _helper(namespace, name)
+        if function is None or digest != expected:
+            raise _Refused(f"unrecognised {name} fingerprint {digest}")
+        _check_code(namespace, helper_source, {name: function})
+    return profile
+
+
+class _Node:
+    """One (annotation, inner_type) pair, compiled the way stock's transform reads it."""
+
+    def __init__(self, compiler: _Compiler, annotation: Any, inner_type: Any) -> None:
+        self.compiler: _Compiler = compiler
+        self.annotation: Any = annotation
+        self.inner_type: Any = inner_type
+        self.kind: str = _DELEGATE
+        # TD: key -> (alias or None, child)
+        self.fields: dict[str, tuple[Any, _Node]] = {}
+        self.items: _Node | None = None  # DICT
+        self.list_flags: tuple[bool, bool, bool] = (False, False, False)  # LIST
+        self.elem: _Node | None = None  # LIST, unless _no_transform_needed
+        self.members: list[_Node] = []  # UNION, nested unions flattened
+        self.fmt: Any = None
+        self.fmt_template: Any = None
+        self.eligible: bool = False
+        self.impure: bool = False  # async: the whole call must run the original
+        self.fn: Callable[[object], object] = self.apply
+
+    def children(self) -> list[_Node]:
+        children = [child for _alias, child in self.fields.values()] + self.members
+        return children + [node for node in (self.items, self.elem) if node is not None]
+
+    def apply(self, data: object) -> object:
+        compiler = self.compiler
+        ns = compiler.ns
+        kind = self.kind
+        if kind is _DELEGATE:
+            return compiler.original(data, annotation=self.annotation, inner_type=self.inner_type)
+        if kind is _TD:
+            if type(data) is dict or ns["is_mapping"](data):
+                is_given = ns["is_given"]
+                fields = self.fields
+                result: dict[Any, object] = {}
+                for key, value in cast("Mapping[Any, object]", data).items():
+                    if not is_given(value):
+                        continue
+                    field = fields.get(key)
+                    if field is None:
+                        result[key] = value
+                    else:
+                        alias, child = field
+                        result[key if alias is None else alias] = child.fn(value)
+                return result
+        elif kind is _DICT:
+            if type(data) is dict or ns["is_mapping"](data):
+                items = cast(_Node, self.items).fn
+                return {
+                    key: items(value) for key, value in cast("Mapping[Any, object]", data).items()
+                }
+        elif kind is _LIST:
+            listy, iterably, seqy = self.list_flags
+            if (
+                (listy and ns["is_list"](data))
+                or (iterably and ns["is_iterable"](data) and not isinstance(data, str))
+                or (seqy and ns["is_sequence"](data) and not isinstance(data, str))
+            ):
+                if isinstance(data, dict):
+                    return cast(object, data)
+                if self.elem is None:
+                    return data if ns["is_list"](data) else list(cast(Iterable[Any], data))
+                elem = self.elem.fn
+                return [elem(item) for item in cast(Iterable[Any], data)]
+        elif kind is _UNION:
+            for member in self.members:
+                data = member.fn(data)
+            return data
+        if isinstance(data, ns["pydantic"].BaseModel):
+            model_dump = compiler.compat.model_dump
+            if compiler.exclude:
+                return model_dump(
+                    data,
+                    exclude_unset=True,
+                    mode="json",
+                    exclude=getattr(data, "__api_exclude__", None),
+                )
+            return model_dump(data, exclude_unset=True, mode="json")
+        if self.fmt is not None:
+            return ns["_format_data"](data, self.fmt, self.fmt_template)
+        return data
+
+
+class _Compiler:
+    """Plans for the sync transform, or (with ``sync``) for the async one."""
+
+    def __init__(
+        self,
+        transform_module: types.ModuleType,
+        compat: types.ModuleType,
+        profile: str,
+        sync: _Compiler | None = None,
+    ) -> None:
+        self.ns: dict[str, Any] = vars(transform_module)
+        self.compat: Any = compat
+        self.profile: str = profile
+        self.sync: _Compiler = sync or self
+        self.is_async: bool = sync is not None
+        name = "_async_transform_recursive" if self.is_async else "_transform_recursive"
+        self.original: Callable[..., Any] = self.ns[name]
+        # Async A and B neither pass `exclude` nor read __api_exclude__.
+        self.exclude: bool = not self.is_async or profile == "C"
+        self.nodes: dict[tuple[object, object], _Node] = {}
+        self.copiers: dict[frozenset[_Node], Callable[[object], object]] = {}
+        # Filled only while compiling, so it stops growing once _MAX_NODES is reached.
+        self.scope: dict[int, tuple[object, bool]] = {}
+        self.warned_full: bool = False
+        self.warned_fallback: bool = False
+
+    def plan(self, annotation: object, inner_type: object) -> Callable[[object], object] | None:
+        """The compiled transform for this call, or None to run the original instead."""
+        try:
+            node = self.nodes.get((annotation, inner_type))
+        except TypeError:  # unhashable: stock's lru_caches raise (or not) the same way
+            return None
+        if node is None:
+            # The async compiler also fills the sync table (dict values), so check both.
+            size = max(len(self.nodes), len(self.sync.nodes))
+            if size >= _MAX_NODES:
+                if not self.warned_full:
+                    self.warned_full = True
+                    logger.warning(
+                        "The openai transform holds %d plans; new annotations use the stock transform",
+                        size,
+                    )
+                return None
+            try:
+                node = self._compile(annotation, inner_type)
+            except Exception as error:  # the original is always exact
+                if isinstance(error, MemoryError) or (
+                    isinstance(error, RecursionError) and _deep_stack()
+                ):
+                    return None  # may come from the caller's state, so retry next call
+                logger.warning(
+                    "Could not compile the openai transform for %.200r; using the stock transform",
+                    self._shown(annotation),
+                    exc_info=True,
+                )
+                node = _Node(self, annotation, inner_type)
+                node.impure = True
+                node = self.nodes.setdefault((annotation, inner_type), node)
+        return None if node.impure else node.fn
+
+    def _compile(self, annotation: object, inner_type: object) -> _Node:
+        # Build into a private table and publish finished nodes only, so other threads
+        # never see a half-built plan and a duplicate compile is harmless.
+        building: dict[tuple[object, object], _Node] = {}
+        top = self._node(annotation, inner_type, building)
+        nodes = list(building.values())
+        for node in nodes:
+            if node.kind is _UNION:
+                node.members = _flatten(node.members)
+            plain_fmt = node.fmt is None or type(node.fmt) is str
+            node.eligible = (
+                node.kind is not _DELEGATE
+                and plain_fmt
+                and all(alias is None for alias, _child in node.fields.values())
+            )
+            # Only the async base64 path awaits (an anyio file read).
+            node.impure = self.is_async and (
+                node.kind is _DELEGATE or not plain_fmt or node.fmt == "base64"
+            )
+        changed = True
+        while changed:  # fixpoint over recursive types
+            changed = False
+            for node in nodes:
+                children = node.children()
+                if node.eligible and not all(child.eligible for child in children):
+                    node.eligible = False
+                    changed = True
+                if not node.impure and any(child.impure for child in children):
+                    node.impure = True
+                    changed = True
+        copiers: dict[frozenset[_Node], Callable[[object], object]] = {}
+        for node in nodes:
+            if node.eligible:
+                node.fn = _with_copier(self._copier([node], copiers), node.apply)
+        for nodes_key, copier in copiers.items():
+            self.copiers.setdefault(nodes_key, copier)
+        for key, node in building.items():
+            self.nodes.setdefault(key, node)
+        if not self.warned_fallback and (
+            top.impure or any(node.kind is _DELEGATE for node in nodes)
+        ):
+            self.warned_fallback = True
+            logger.warning(
+                "The openai transform falls back to stock for parts of %.200r; later fallbacks are not logged",
+                self._shown(annotation),
+            )
+        return self.nodes[annotation, inner_type]
+
+    def _node(
+        self,
+        annotation: object,
+        inner_type: object,
+        building: dict[tuple[object, object], _Node],
+    ) -> _Node:
+        key = (annotation, inner_type)
+        node = self.nodes.get(key) or building.get(key)
+        if node is None:
+            node = building[key] = _Node(self, annotation, inner_type)
+            try:
+                self._fill(node, building)
+            except (RecursionError, MemoryError):
+                raise  # may not be a property of the type: plan() decides
+            except Exception:  # noqa: BLE001 - delegate: stock raises when data gets here
+                node.kind = _DELEGATE
+        return node
+
+    def _fill(self, node: _Node, building: dict[tuple[object, object], _Node]) -> None:
+        """Set ``node``'s kind and children; it stays a DELEGATE when out of scope."""
+        ns = self.ns
+        if not (self._in_scope(node.annotation) and self._in_scope(node.inner_type)):
+            return
+        stripped = ns["strip_annotated_type"](node.inner_type)
+        if not self._in_scope(stripped):
+            return
+        origin = ns["get_origin"](stripped) or stripped
+        annotated = ns["_get_annotated_type"](node.annotation)
+        if annotated is not None:
+            for meta in ns["get_args"](annotated)[1:]:
+                if isinstance(meta, ns["PropertyInfo"]) and meta.format is not None:
+                    node.fmt, node.fmt_template = meta.format, meta.format_template
+                    break
+        listy = ns["is_list_type"](stripped)
+        iterably = ns["is_iterable_type"](stripped)
+        seqy = ns["is_sequence_type"](stripped)
+        if ns["is_typeddict"](stripped):
+            hints = ns["get_type_hints"](stripped, include_extras=True)
+            if not all(self._in_scope(hint) for hint in hints.values()):
+                return
+            for name, hint in hints.items():
+                alias = ns["_maybe_transform_key"](_KEY_PROBE, hint)
+                child = self._node(hint, hint, building)
+                node.fields[name] = (None if alias is _KEY_PROBE else alias, child)
+            node.kind = _TD
+        elif origin == dict:  # noqa: E721 - stock's comparison, not `is`
+            args = ns["get_args"](stripped)
+            if self.profile == "A":
+                items = args[1]  # raises for a bare dict, as stock A does at runtime
+            else:
+                items = args[1] if len(args) > 1 else object
+            # The async dict branch calls the sync transform for its values.
+            if self.is_async:  # returns the published node if there is one
+                node.items = self.sync._compile(items, items)
+            else:
+                node.items = self._node(items, items, building)
+            node.kind = _DICT
+        elif listy or iterably or seqy:
+            if self.profile == "A":
+                elem = ns["extract_type_arg"](stripped, 0)  # raises for a bare list
+            else:
+                args = ns["get_args"](stripped)
+                elem = args[0] if args else object
+            if not ns["_no_transform_needed"](elem):
+                node.elem = self._node(node.annotation, elem, building)
+            node.list_flags = (listy, iterably, seqy)
+            node.kind = _LIST
+        elif ns["is_union_type"](stripped):
+            node.members = [
+                self._node(node.annotation, member, building) for member in ns["get_args"](stripped)
+            ]
+            node.kind = _UNION
+        else:
+            node.kind = _LEAF
+
+    def _shown(self, annotation: object) -> object:
+        # repr() of an annotation outside the scope could run its code.
+        hit = self.scope.get(id(annotation))
+        in_scope = hit is not None and hit[0] is annotation and hit[1]
+        return annotation if in_scope else type(annotation)
+
+    def _in_scope(self, tp: object) -> bool:
+        hit = self.scope.get(id(tp))
+        if hit is not None and hit[0] is tp:
+            return hit[1]
+        if issubclass(type(tp), type):
+            module = cast(type, tp).__module__
+            if self.ns["is_typeddict"](tp):
+                ok = module.startswith(_SCOPE_PREFIXES)
+            else:
+                ok = module in _STD_MODULES or module.startswith(_SCOPE_PREFIXES)
+        elif type(tp).__module__ not in _STD_MODULES:
+            ok = False
+        else:
+            origin = typing_extensions.get_origin(tp)
+            args = typing_extensions.get_args(tp)
+            if origin is typing.Literal or origin is typing_extensions.Literal:
+                ok = True
+            elif origin is typing.Annotated or origin is typing_extensions.Annotated:
+                ok = self._in_scope(args[0]) and all(
+                    type(meta) is self.ns["PropertyInfo"] for meta in args[1:]
+                )
+            else:
+                ok = (origin is None or self._in_scope(origin)) and all(
+                    self._in_scope(arg) for arg in args
+                )
+        self.scope[id(tp)] = (tp, ok)
+        return ok
+
+    def _copier(
+        self,
+        nodes: Iterable[_Node],
+        building: dict[frozenset[_Node], Callable[[object], object]],
+    ) -> Callable[[object], object]:
+        flat = frozenset(_flatten(nodes))  # a union stands for its arms
+        copier = self.copiers.get(flat) or building.get(flat)
+        if copier is not None:
+            return copier
+        box: list[Callable[[object], object]] = []
+        # Recursive types reach this set again while it is being built.
+        building[flat] = lambda data: box[0](data)
+        tds = [node for node in flat if node.kind is _TD]
+        items = [cast(_Node, node.items) for node in flat if node.kind is _DICT]
+        per_key: dict[str, list[_Node]] = {}
+        for td in tds:
+            for name, (_alias, child) in td.fields.items():
+                per_key.setdefault(name, list(items)).append(child)
+        elems = [node.elem for node in flat if node.kind is _LIST and node.elem is not None]
+        copier = _make_copier(
+            self.ns,
+            key_copiers={
+                name: self._copier(children, building) for name, children in per_key.items()
+            },
+            default=self._copier(items, building) if items else None,
+            elem_copier=self._copier(elems, building) if elems else None,
+            has_td=bool(tds),
+            has_list=any(node.kind is _LIST for node in flat),
+            has_fmt=any(node.fmt is not None for node in flat),
+        )
+        box.append(copier)
+        building[flat] = copier
+        return copier
+
+
+def _deep_stack() -> bool:
+    """Whether the caller uses over half the recursion limit, so a RecursionError may be its."""
+    depth = 0
+    frame = inspect.currentframe()
+    while frame is not None:
+        depth += 1
+        frame = frame.f_back
+    return depth > sys.getrecursionlimit() // 2
+
+
+def _flatten(nodes: Iterable[_Node]) -> list[_Node]:
+    return [
+        arm
+        for node in nodes
+        for arm in (_flatten(node.members) if node.kind is _UNION else (node,))
+    ]
+
+
+def _with_copier(
+    copier: Callable[[object], object], apply: Callable[[object], object]
+) -> Callable[[object], object]:
+    def transform(data: object) -> object:
+        copied = copier(data)
+        return apply(data) if copied is _NOT_PLAIN else copied
+
+    return transform
+
+
+def _make_copier(
+    ns: dict[str, Any],
+    *,
+    key_copiers: dict[str, Callable[[object], object]],
+    default: Callable[[object], object] | None,
+    elem_copier: Callable[[object], object] | None,
+    has_td: bool,
+    has_list: bool,
+    has_fmt: bool,
+) -> Callable[[object], object]:
+    """The copy stock makes of plain data under a set of eligible nodes, or _NOT_PLAIN.
+
+    ``key_copiers`` and ``default`` apply to a dict's values (TypedDict fields, then
+    dict items; ``default`` is set exactly when a dict node is in the set);
+    ``elem_copier`` to a list's elements.
+    """
+    is_given = ns["is_given"]
+    is_mapping = ns["is_mapping"]
+    is_list = ns["is_list"]
+    is_iterable = ns["is_iterable"]
+    base_model = ns["pydantic"].BaseModel
+    has_dict = default is not None
+    has_map = has_td or has_dict
+    copier_for = key_copiers.get
+    scalars = _SCALARS
+    not_plain = _NOT_PLAIN
+
+    def copy(data: object) -> object:
+        cls = type(data)
+        if cls in scalars:
+            return data
+        if cls is dict:
+            if not has_map:
+                return data
+            result: dict[str, object] = {}
+            for key, value in cast("dict[Any, object]", data).items():
+                # Before hashing it: a non-str key's __hash__/__eq__ may be user code,
+                # which the faithful path would then run again.
+                if type(key) is not str:
+                    return not_plain
+                value_cls = type(value)
+                if value_cls in scalars:
+                    result[key] = value
+                    continue
+                if (
+                    has_td
+                    and value_cls is not dict
+                    and value_cls is not list
+                    and not is_given(value)
+                ):
+                    # A TypedDict drops it; a dict arm may first have seen it.
+                    if has_dict:
+                        return not_plain
+                    continue
+                copier = copier_for(key, default)
+                if copier is None:
+                    result[key] = value
+                    continue
+                copied = copier(value)
+                if copied is not_plain:
+                    return not_plain
+                result[key] = copied
+            return result
+        if cls is list:
+            if elem_copier is None:
+                return data
+            copies: list[object] = []
+            for item in cast("list[object]", data):
+                if type(item) in scalars:
+                    copies.append(item)
+                    continue
+                copied = elem_copier(item)
+                if copied is not_plain:
+                    return not_plain
+                copies.append(copied)
+            return copies
+        # A list branch returns a dict (subclass) as is; is_list honours __class__.
+        if (
+            has_fmt
+            or isinstance(data, base_model)
+            or (has_map and is_mapping(data))
+            or (
+                has_list
+                and not issubclass(cls, dict)
+                and (is_list(data) or (not issubclass(cls, str) and is_iterable(data)))
+            )
+        ):
+            return not_plain
+        return data
+
+    return copy
+
+
+def _entry_points(
+    sync: _Compiler, async_: _Compiler
+) -> tuple[Callable[..., object], Callable[..., Coroutine[Any, Any, object]]]:
+    # Same signatures as stock: callers pass annotation/inner_type by keyword.
+    def _patched_transform_recursive(
+        data: object,
+        *,
+        annotation: type,
+        inner_type: type | None = None,
+    ) -> object:
+        plan = sync.plan(annotation, annotation if inner_type is None else inner_type)
+        if plan is None:
+            return sync.original(data, annotation=annotation, inner_type=inner_type)
+        return plan(data)
+
+    async def _patched_async_transform_recursive(
+        data: object,
+        *,
+        annotation: type,
+        inner_type: type | None = None,
+    ) -> object:
+        plan = async_.plan(annotation, annotation if inner_type is None else inner_type)
+        if plan is None:
+            return await async_.original(data, annotation=annotation, inner_type=inner_type)
+        return plan(data)
+
+    return _patched_transform_recursive, _patched_async_transform_recursive
+
+
+def install() -> bool:
+    """Replace openai's request transform with the compiled one if openai is verified.
+
+    Call it once, before the first request. Returns whether the compiled transform is in
+    place. Only the first call checks openai and logs; later calls return its result. Never
+    raises: an unverified openai or any failure while installing logs a WARNING and keeps
+    the stock transform.
+    """
+    global _result
+
+    with _install_lock:
+        if _result is not None:
+            return _result
+        _result = False
+        try:
+            import openai
+            import openai._compat
+            import openai._utils._transform as transform_module
+
+            version = openai.__version__
+            try:
+                profile = _check(transform_module)
+            except _Refused as refused:
+                logger.warning(
+                    "Fast openai transform not installed: openai %s is not verified (%s); keeping the stock transform",
+                    version,
+                    refused,
+                )
+                return False
+            sync = _Compiler(transform_module, openai._compat, profile)
+            async_ = _Compiler(transform_module, openai._compat, profile, sync=sync)
+            patched, patched_async = _entry_points(sync, async_)
+            transform_module.__dict__.update(
+                _transform_recursive=patched, _async_transform_recursive=patched_async
+            )
+            _result = True
+        except Exception:  # never raise: stock stays in place
+            logger.warning(
+                "Fast openai transform failed to install; keeping the stock transform",
+                exc_info=True,
+            )
+            return False
+    logger.info("Fast openai transform installed (openai %s, profile %s)", version, profile)
+    return True
+
+
+def main() -> int:
+    """``python -m openai_fast_transform``: fingerprints of the installed openai; 1 if refused."""
+    import openai
+    import openai._utils._transform as transform_module
+
+    print(f"openai {openai.__version__}")
+    try:
+        print(f"_transform.py {_digest(ast.parse(_source(transform_module)))}")
+        for name in _HELPERS:
+            print(f"{name} {_helper(vars(transform_module), name)[2]}")
+        print(f"profile {_check(transform_module)}")
+    except _Refused as refused:
+        print(f"not verified: {refused}")
+        return 1
+    return 0