temporalio-openai-codex 0.0.1__tar.gz

temporalio_openai_codex-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 temporal.io
+
+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.

temporalio_openai_codex-0.0.1/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: temporalio-openai-codex
+Version: 0.0.1
+Summary: Durable OpenAI Codex sessions on Temporal
+Author: Temporal Technologies Inc
+Author-email: Temporal Technologies Inc <sdk@temporal.io>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Dist: temporalio>=1.34.0,<2
+Requires-Dist: openai-codex>=0.161.0,<0.164.0
+Requires-Dist: pydantic>=2.12,<3
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/temporalio/ai-integrations/tree/main/python/openai_codex
+Project-URL: Repository, https://github.com/temporalio/ai-integrations
+Project-URL: Documentation, https://docs.temporal.io/develop/python/integrations/openai-codex
+Description-Content-Type: text/markdown
+
+# Temporal OpenAI Codex integration
+
+**Pre-release.** Run the [Python Codex SDK](https://github.com/openai/codex/tree/main/sdk/python)
+in Temporal Workflows. Install with
+`uv add temporalio-openai-codex`. Import the integration as
+`temporalio.openai_codex` and the upstream SDK as `openai_codex`.
+
+Each SDK keeps its exact `openai-codex-cli-bin` dependency. The
+default connector uses that bundled runtime and its companion PATH entries,
+including when another Codex executable is installed on the Worker.
+
+## Use AsyncCodex
+
+Register the plugin on the Worker (or its Client):
+
+```python
+from temporalio.openai_codex import OpenAICodexPlugin
+from temporalio.worker import Worker
+
+worker = Worker(
+    client,
+    task_queue="codex",
+    workflows=[CodingWorkflow],
+    plugins=[OpenAICodexPlugin()],
+)
+```
+
+Use the upstream async API in the Workflow:
+
+```python
+from openai_codex import AsyncCodex, Sandbox
+from temporalio import workflow
+from temporalio.openai_codex import TemporalCodexConfig
+
+
+@workflow.defn
+class CodingWorkflow:
+    @workflow.run
+    async def run(self, prompt: str) -> str:
+        async with AsyncCodex(TemporalCodexConfig(cwd="/workspace")) as codex:
+            thread = await codex.thread_start(sandbox=Sandbox.read_only)
+            result = await thread.run(prompt)
+            return result.final_response or ""
+```
+
+The plugin configures passthrough imports for `openai_codex` and
+`temporalio.openai_codex`, so Workflow code can import both directly.
+
+The plugin adapts construction and asynchronous turn streams inside Workflows,
+including replay. Threads, turn handles, login handles, notifications, and
+`TurnResult` are the upstream types. Ordinary SDK calls outside Workflows keep
+using upstream implementations. Synchronous `Codex` is for Activity or application
+code, not Workflow code.
+
+In Workflows, collected failed turns raise `CodexError` with the upstream error
+message, so an uncaught provider failure fails the Workflow. Streaming still yields
+the upstream turn-completion notification, including its failure status and error.
+
+## Approvals and Activity options
+
+Pass `TemporalCodexConfig`, a subclass of the upstream `CodexConfig`, to
+`AsyncCodex` for Workflow-specific options:
+
+```python
+from datetime import timedelta
+from openai_codex import AsyncCodex
+from temporalio.openai_codex import CodexActivityOptions, TemporalCodexConfig
+from temporalio.workflow import ActivityConfig
+
+async def approve(method, params):
+    # Runs in Workflow code. It can wait for a Signal or Update, or call an Activity.
+    return {"decision": "accept"}
+
+async with AsyncCodex(TemporalCodexConfig(
+    cwd="/workspace",
+    approval_handler=approve,
+    activity_options=CodexActivityOptions(
+        connect=ActivityConfig(start_to_close_timeout=timedelta(minutes=2)),
+    ),
+)) as codex:
+    thread = await codex.thread_start()
+    result = await thread.run("Describe the project.")
+```
+
+Synchronous and asynchronous approval handlers receive `(method, params)` as in
+upstream `CodexClient`. Keep callbacks deterministic; put I/O in Activities. Without
+a handler, command and file-change approval requests receive `{"decision": "accept"}`
+and other server requests receive `{}`, matching the SDK default. Set Codex's
+approval and sandbox policies deliberately for your application. These additional
+options apply inside Workflows; ordinary SDK calls use upstream behavior.
+
+Only the base `CodexConfig` fields are passed to the connect Activity. Approval
+callbacks, Activity options, and stream topic handles stay in Workflow code.
+
+## Token-by-Token Output
+
+Use the optional `stream` topic to expose generated output to callers outside the
+Workflow. [Workflow Streams](https://docs.temporal.io/develop/python/workflows/workflow-streams)
+is currently in Public Preview. Create the stream in `@workflow.init`, then pass
+its topic in `TemporalCodexConfig`:
+
+```python
+from openai_codex import AsyncCodex
+from temporalio import workflow
+from temporalio.contrib.workflow_streams import WorkflowStream
+from temporalio.openai_codex import TemporalCodexConfig
+
+
+@workflow.defn
+class StreamingWorkflow:
+    @workflow.init
+    def __init__(self, prompt: str) -> None:
+        self.events = WorkflowStream().topic("codex")
+
+    @workflow.run
+    async def run(self, prompt: str) -> str:
+        async with AsyncCodex(TemporalCodexConfig(stream=self.events)) as codex:
+            thread = await codex.thread_start()
+            result = await thread.run(prompt)
+            return result.final_response or ""
+```
+
+An external caller subscribes using the Workflow ID:
+
+```python
+from temporalio.contrib.workflow_streams import WorkflowStreamClient
+
+stream = WorkflowStreamClient.create(client, workflow_id)
+async for item in stream.subscribe(["codex"], result_type=dict):
+    notification = item.data
+    print(notification["method"], notification["params"])
+```
+
+Each item is a JSON-RPC delta notification with `method` and `params`, including
+thread, turn, and item IDs when provided by Codex. Notifications whose method ends
+in `delta` (case insensitive) are published once by the connection's reader,
+including agent text, reasoning, and command output. They remain available through
+upstream `turn.stream()` as well. Activity retries and multiple turn subscribers
+do not duplicate these publications. Explicitly repeating a turn can generate
+new output; consumers should use the IDs to associate it with the correct turn.
+Streaming adds Workflow memory use; apply the Workflow Streams retention guidance
+for long conversations.
+
+## Connectors and launch configuration
+
+`OpenAICodexPlugin(connector=...)` accepts a `Connector` implementing
+`async connect(ConnectActivityInput) -> CodexProcess`. The input contains the upstream
+`CodexConfig`. `CodexProcess` provides `write(message)`, `read() -> list[dict]`, and
+`close()`. A read returns an ordered batch or an empty list at EOF. Close must be
+idempotent, tolerate overlap, support retries after cancellation, and unblock
+pending reads and writes. A transient
+write failure must guarantee that the message was not committed; report ambiguous
+or permanent failures with `CodexError` so they are not blindly retried.
+
+The default `SubprocessConnector` honors `codex_bin`, `launch_args_override`,
+`config_overrides`, `cwd`, and `env`. It merges `env` into the Worker's environment.
+Launch paths and runtime discovery are resolved on the Activity Worker. Custom
+connectors can reach a remote process; the returned connection object still lives
+on the Worker that created it. The connector owns cleanup of remote resources
+that outlive the Worker. No Nexus service or tool-registration API is needed.
+
+`CodexActivityOptions` overrides `connect`, `write`, `read`, and `close`, each using
+the Temporal SDK's `workflow.ActivityConfig`. Only
+`connect.task_queue` selects the queue where Codex starts. The other Activities use
+the private queue polled by the Worker holding the connection. Activities default
+to five-minute start-to-close timeouts and ten-second heartbeat timeouts. Operations
+on an established connection also have a thirty-second schedule-to-start timeout
+for detecting a lost Worker.
+
+## Recovery and operational limits
+
+Completed writes stay cached for the life of the connection, so Activity retries
+and lost completion results do not resend prompts, approvals, or notifications.
+Read batches stay buffered until a later read acknowledges them. Heartbeats let
+Temporal cancel blocked operations; context exit closes the process, and orderly
+Worker shutdown closes its connections.
+If a connect result is lost, its idle connection remains with the owning Worker
+until shutdown. Cleanup failures do not replace a Workflow's result or original error.
+
+A process connection is not durable storage. Losing its Worker produces
+`TransportClosedError`; the plugin does not automatically start a replacement
+session. Keep persisted thread IDs in Workflow state. Handle the error by creating
+a new client and explicitly calling `thread_resume` with the saved ID, using a
+Worker with access to the same Codex home and workspace. Ephemeral threads and
+in-flight process state cannot be recovered this way. Retrying a Workflow or
+resetting its history can create new sessions and repeat application side effects.
+
+Configure credentials on Workers, such as an authenticated `CODEX_HOME` or an
+appropriate model provider. Avoid passing secrets through Workflow inputs,
+`TemporalCodexConfig.env`, or login API-key calls: Activity inputs/results and
+notification content are recorded in Temporal history. Use an appropriate payload
+codec if sensitive content must pass through history. Tests require no real credentials.
+
+Each protocol write and output batch adds Activity events to Workflow history.
+Long streams and long-lived sessions grow history; bound conversations and close
+connections before continuing as new. Worker memory also holds unacknowledged
+output and write-deduplication records until close. Reads batch near Temporal's
+payload warning threshold; a single oversized message is not split and can exceed
+the server's payload limit. Use upstream options to limit output and an external
+storage/payload strategy where needed. The subprocess reader accepts lines up to
+16 MiB; the Temporal payload limit is usually smaller. Exceeding that line limit
+or another terminal stdout read failure raises `TransportClosedError` without
+retrying the failed reader.

temporalio_openai_codex-0.0.1/README.md

@@ -0,0 +1,203 @@
+# Temporal OpenAI Codex integration
+
+**Pre-release.** Run the [Python Codex SDK](https://github.com/openai/codex/tree/main/sdk/python)
+in Temporal Workflows. Install with
+`uv add temporalio-openai-codex`. Import the integration as
+`temporalio.openai_codex` and the upstream SDK as `openai_codex`.
+
+Each SDK keeps its exact `openai-codex-cli-bin` dependency. The
+default connector uses that bundled runtime and its companion PATH entries,
+including when another Codex executable is installed on the Worker.
+
+## Use AsyncCodex
+
+Register the plugin on the Worker (or its Client):
+
+```python
+from temporalio.openai_codex import OpenAICodexPlugin
+from temporalio.worker import Worker
+
+worker = Worker(
+    client,
+    task_queue="codex",
+    workflows=[CodingWorkflow],
+    plugins=[OpenAICodexPlugin()],
+)
+```
+
+Use the upstream async API in the Workflow:
+
+```python
+from openai_codex import AsyncCodex, Sandbox
+from temporalio import workflow
+from temporalio.openai_codex import TemporalCodexConfig
+
+
+@workflow.defn
+class CodingWorkflow:
+    @workflow.run
+    async def run(self, prompt: str) -> str:
+        async with AsyncCodex(TemporalCodexConfig(cwd="/workspace")) as codex:
+            thread = await codex.thread_start(sandbox=Sandbox.read_only)
+            result = await thread.run(prompt)
+            return result.final_response or ""
+```
+
+The plugin configures passthrough imports for `openai_codex` and
+`temporalio.openai_codex`, so Workflow code can import both directly.
+
+The plugin adapts construction and asynchronous turn streams inside Workflows,
+including replay. Threads, turn handles, login handles, notifications, and
+`TurnResult` are the upstream types. Ordinary SDK calls outside Workflows keep
+using upstream implementations. Synchronous `Codex` is for Activity or application
+code, not Workflow code.
+
+In Workflows, collected failed turns raise `CodexError` with the upstream error
+message, so an uncaught provider failure fails the Workflow. Streaming still yields
+the upstream turn-completion notification, including its failure status and error.
+
+## Approvals and Activity options
+
+Pass `TemporalCodexConfig`, a subclass of the upstream `CodexConfig`, to
+`AsyncCodex` for Workflow-specific options:
+
+```python
+from datetime import timedelta
+from openai_codex import AsyncCodex
+from temporalio.openai_codex import CodexActivityOptions, TemporalCodexConfig
+from temporalio.workflow import ActivityConfig
+
+async def approve(method, params):
+    # Runs in Workflow code. It can wait for a Signal or Update, or call an Activity.
+    return {"decision": "accept"}
+
+async with AsyncCodex(TemporalCodexConfig(
+    cwd="/workspace",
+    approval_handler=approve,
+    activity_options=CodexActivityOptions(
+        connect=ActivityConfig(start_to_close_timeout=timedelta(minutes=2)),
+    ),
+)) as codex:
+    thread = await codex.thread_start()
+    result = await thread.run("Describe the project.")
+```
+
+Synchronous and asynchronous approval handlers receive `(method, params)` as in
+upstream `CodexClient`. Keep callbacks deterministic; put I/O in Activities. Without
+a handler, command and file-change approval requests receive `{"decision": "accept"}`
+and other server requests receive `{}`, matching the SDK default. Set Codex's
+approval and sandbox policies deliberately for your application. These additional
+options apply inside Workflows; ordinary SDK calls use upstream behavior.
+
+Only the base `CodexConfig` fields are passed to the connect Activity. Approval
+callbacks, Activity options, and stream topic handles stay in Workflow code.
+
+## Token-by-Token Output
+
+Use the optional `stream` topic to expose generated output to callers outside the
+Workflow. [Workflow Streams](https://docs.temporal.io/develop/python/workflows/workflow-streams)
+is currently in Public Preview. Create the stream in `@workflow.init`, then pass
+its topic in `TemporalCodexConfig`:
+
+```python
+from openai_codex import AsyncCodex
+from temporalio import workflow
+from temporalio.contrib.workflow_streams import WorkflowStream
+from temporalio.openai_codex import TemporalCodexConfig
+
+
+@workflow.defn
+class StreamingWorkflow:
+    @workflow.init
+    def __init__(self, prompt: str) -> None:
+        self.events = WorkflowStream().topic("codex")
+
+    @workflow.run
+    async def run(self, prompt: str) -> str:
+        async with AsyncCodex(TemporalCodexConfig(stream=self.events)) as codex:
+            thread = await codex.thread_start()
+            result = await thread.run(prompt)
+            return result.final_response or ""
+```
+
+An external caller subscribes using the Workflow ID:
+
+```python
+from temporalio.contrib.workflow_streams import WorkflowStreamClient
+
+stream = WorkflowStreamClient.create(client, workflow_id)
+async for item in stream.subscribe(["codex"], result_type=dict):
+    notification = item.data
+    print(notification["method"], notification["params"])
+```
+
+Each item is a JSON-RPC delta notification with `method` and `params`, including
+thread, turn, and item IDs when provided by Codex. Notifications whose method ends
+in `delta` (case insensitive) are published once by the connection's reader,
+including agent text, reasoning, and command output. They remain available through
+upstream `turn.stream()` as well. Activity retries and multiple turn subscribers
+do not duplicate these publications. Explicitly repeating a turn can generate
+new output; consumers should use the IDs to associate it with the correct turn.
+Streaming adds Workflow memory use; apply the Workflow Streams retention guidance
+for long conversations.
+
+## Connectors and launch configuration
+
+`OpenAICodexPlugin(connector=...)` accepts a `Connector` implementing
+`async connect(ConnectActivityInput) -> CodexProcess`. The input contains the upstream
+`CodexConfig`. `CodexProcess` provides `write(message)`, `read() -> list[dict]`, and
+`close()`. A read returns an ordered batch or an empty list at EOF. Close must be
+idempotent, tolerate overlap, support retries after cancellation, and unblock
+pending reads and writes. A transient
+write failure must guarantee that the message was not committed; report ambiguous
+or permanent failures with `CodexError` so they are not blindly retried.
+
+The default `SubprocessConnector` honors `codex_bin`, `launch_args_override`,
+`config_overrides`, `cwd`, and `env`. It merges `env` into the Worker's environment.
+Launch paths and runtime discovery are resolved on the Activity Worker. Custom
+connectors can reach a remote process; the returned connection object still lives
+on the Worker that created it. The connector owns cleanup of remote resources
+that outlive the Worker. No Nexus service or tool-registration API is needed.
+
+`CodexActivityOptions` overrides `connect`, `write`, `read`, and `close`, each using
+the Temporal SDK's `workflow.ActivityConfig`. Only
+`connect.task_queue` selects the queue where Codex starts. The other Activities use
+the private queue polled by the Worker holding the connection. Activities default
+to five-minute start-to-close timeouts and ten-second heartbeat timeouts. Operations
+on an established connection also have a thirty-second schedule-to-start timeout
+for detecting a lost Worker.
+
+## Recovery and operational limits
+
+Completed writes stay cached for the life of the connection, so Activity retries
+and lost completion results do not resend prompts, approvals, or notifications.
+Read batches stay buffered until a later read acknowledges them. Heartbeats let
+Temporal cancel blocked operations; context exit closes the process, and orderly
+Worker shutdown closes its connections.
+If a connect result is lost, its idle connection remains with the owning Worker
+until shutdown. Cleanup failures do not replace a Workflow's result or original error.
+
+A process connection is not durable storage. Losing its Worker produces
+`TransportClosedError`; the plugin does not automatically start a replacement
+session. Keep persisted thread IDs in Workflow state. Handle the error by creating
+a new client and explicitly calling `thread_resume` with the saved ID, using a
+Worker with access to the same Codex home and workspace. Ephemeral threads and
+in-flight process state cannot be recovered this way. Retrying a Workflow or
+resetting its history can create new sessions and repeat application side effects.
+
+Configure credentials on Workers, such as an authenticated `CODEX_HOME` or an
+appropriate model provider. Avoid passing secrets through Workflow inputs,
+`TemporalCodexConfig.env`, or login API-key calls: Activity inputs/results and
+notification content are recorded in Temporal history. Use an appropriate payload
+codec if sensitive content must pass through history. Tests require no real credentials.
+
+Each protocol write and output batch adds Activity events to Workflow history.
+Long streams and long-lived sessions grow history; bound conversations and close
+connections before continuing as new. Worker memory also holds unacknowledged
+output and write-deduplication records until close. Reads batch near Temporal's
+payload warning threshold; a single oversized message is not split and can exceed
+the server's payload limit. Use upstream options to limit output and an external
+storage/payload strategy where needed. The subprocess reader accepts lines up to
+16 MiB; the Temporal payload limit is usually smaller. Exceeding that line limit
+or another terminal stdout read failure raises `TransportClosedError` without
+retrying the failed reader.

temporalio_openai_codex-0.0.1/pyproject.toml

@@ -0,0 +1,124 @@
+[project]
+name = "temporalio-openai-codex"
+version = "0.0.1"
+description = "Durable OpenAI Codex sessions on Temporal"
+requires-python = ">=3.10"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+dependencies = [
+    "temporalio>=1.34.0,<2",
+    "openai-codex>=0.161.0,<0.164.0",
+    "pydantic>=2.12,<3",
+]
+
+[[project.authors]]
+name = "Temporal Technologies Inc"
+email = "sdk@temporal.io"
+
+[project.optional-dependencies]
+
+[project.urls]
+Homepage = "https://github.com/temporalio/ai-integrations/tree/main/python/openai_codex"
+Repository = "https://github.com/temporalio/ai-integrations"
+Documentation = "https://docs.temporal.io/develop/python/integrations/openai-codex"
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13"]
+build-backend = "uv_build"
+
+[tool.uv]
+default-groups = ["dev"]
+required-version = ">=0.12.5,<0.13"
+exclude-newer = "2 weeks"
+link-mode = "copy"
+
+[tool.uv.build-backend]
+module-name = "temporalio.openai_codex"
+
+[tool.uv.exclude-newer-package]
+temporalio = false
+
+[[tool.uv.cache-keys]]
+file = "pyproject.toml"
+
+[[tool.uv.cache-keys]]
+file = "README.md"
+
+[[tool.uv.cache-keys]]
+file = "src/**/*"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+log_level = "DEBUG"
+log_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
+testpaths = ["tests"]
+timeout = 60
+timeout_func_only = true
+filterwarnings = [
+    "error::temporalio.workflow.UnfinishedUpdateHandlersWarning",
+    "error::temporalio.workflow.UnfinishedSignalHandlersWarning",
+    "ignore::pytest.PytestDeprecationWarning",
+    "ignore::DeprecationWarning",
+]
+
+[tool.mypy]
+files = [
+    "src",
+    "tests",
+]
+mypy_path = "src"
+namespace_packages = true
+explicit_package_bases = true
+check_untyped_defs = true
+ignore_missing_imports = true
+
+[tool.pyright]
+extends = "../_shared/pyrightconfig.json"
+include = [
+    "src",
+    "tests",
+]
+
+[[tool.pyright.executionEnvironments]]
+root = "."
+extraPaths = ["src"]
+
+[tool.pydocstyle]
+convention = "google"
+add_ignore = [
+    "D205",
+    "D415",
+]
+
+[tool.ruff]
+extend = "../_shared/ruff.toml"
+src = [
+    ".",
+    "src",
+]
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1.414,<2",
+    "basedpyright>=1.40.2,<2",
+    "mypy>=1.20.2,<2",
+    "ruff>=0.15.12,<0.16",
+    "pydocstyle>=6.3,<7",
+    "pytest~=9.0",
+    "pytest-asyncio>=0.21.2,<0.22",
+    "pytest-timeout~=2.2",
+    "pytest-xdist>=3.6,<4",
+    "pytest-pretty>=1.3",
+    "pytest-rerunfailures>=16.1",
+    "tomli>=2.0; python_version < '3.11'",
+]

temporalio_openai_codex-0.0.1/pyproject.toml.orig

@@ -0,0 +1,108 @@
+[project]
+name = "temporalio-openai-codex"
+version = "0.0.1"  # Development placeholder; protected release tags inject the published version in CI.
+description = "Durable OpenAI Codex sessions on Temporal"
+authors = [{ name = "Temporal Technologies Inc", email = "sdk@temporal.io" }]
+requires-python = ">=3.10"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]   # committed copy of the repository's root LICENSE
+classifiers = [
+  "Development Status :: 3 - Alpha",   # maturity; must agree with plugin.toml (see AGENTS.md for the mapping)
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed",
+]
+dependencies = [
+  "temporalio>=1.34.0,<2",
+  "openai-codex>=0.161.0,<0.164.0",
+  "pydantic>=2.12,<3",
+]
+
+[project.optional-dependencies]
+
+[project.urls]
+Homepage = "https://github.com/temporalio/ai-integrations/tree/main/python/openai_codex"
+Repository = "https://github.com/temporalio/ai-integrations"
+Documentation = "https://docs.temporal.io/develop/python/integrations/openai-codex"
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+# src/temporalio and src/temporalio/contrib must NOT contain __init__.py: the SDK wheel owns them.
+module-name = "temporalio.openai_codex"
+
+[dependency-groups]
+dev = [
+  "pyright>=1.1.414,<2",
+  "basedpyright>=1.40.2,<2",
+  "mypy>=1.20.2,<2",
+  "ruff>=0.15.12,<0.16",
+  "pydocstyle>=6.3,<7",
+  "pytest~=9.0",
+  "pytest-asyncio>=0.21.2,<0.22",
+  "pytest-timeout~=2.2",
+  "pytest-xdist>=3.6,<4",
+  "pytest-pretty>=1.3",
+  "pytest-rerunfailures>=16.1",
+  "tomli>=2.0; python_version < '3.11'",
+]
+
+[tool.uv]
+default-groups = ["dev"]
+required-version = ">=0.12.5,<0.13"              # same value in scripts/pyproject.toml; CI reads it via setup-uv version-file
+exclude-newer = "2 weeks"                        # org supply-chain cooldown for third-party packages
+exclude-newer-package = { temporalio = false }   # the SDK is exempt: releases must be adoptable on day one
+link-mode = "copy"
+cache-keys = [{ file = "pyproject.toml" }, { file = "README.md" }, { file = "src/**/*" }]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+# Do not use log_cli since this shows logging for all tests, not just the ones
+# that failed. Instead, show all logs for failed tests at the end.
+log_level = "DEBUG"
+log_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
+testpaths = ["tests"]
+timeout = 60
+timeout_func_only = true
+filterwarnings = [
+  "error::temporalio.workflow.UnfinishedUpdateHandlersWarning",
+  "error::temporalio.workflow.UnfinishedSignalHandlersWarning",
+  "ignore::pytest.PytestDeprecationWarning",
+  "ignore::DeprecationWarning",
+]
+
+[tool.mypy]
+files = ["src", "tests"]
+mypy_path = "src"
+namespace_packages = true
+explicit_package_bases = true
+check_untyped_defs = true
+ignore_missing_imports = true
+
+[tool.pyright]
+extends = "../_shared/pyrightconfig.json"
+include = ["src", "tests"]
+
+# Resolve the plugin's own modules from source rather than from site-packages.
+[[tool.pyright.executionEnvironments]]
+root = "."
+extraPaths = ["src"]
+
+[tool.pydocstyle]
+convention = "google"
+add_ignore = [
+  # We like to wrap at a certain number of chars, even long summary sentences.
+  # https://github.com/PyCQA/pydocstyle/issues/184
+  "D205",
+  "D415",
+]
+
+[tool.ruff]
+extend = "../_shared/ruff.toml"
+src = [".", "src"]