codex-python 1.0.0__tar.gz → 1.0.0b3__tar.gz

{codex_python-1.0.0 → codex_python-1.0.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-python
-Version: 1.0.0
+Version: 1.0.0b3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.13
@@ -106,9 +106,27 @@ thread.run("Continue from previous context")
 
 ## Options
 
-- `CodexOptions`: `codex_path_override`, `base_url`, `api_key`
-- `ThreadOptions`: `model`, `sandbox_mode`, `working_directory`, `skip_git_repo_check`
-- `TurnOptions`: `output_schema`
+- `CodexOptions`: `codex_path_override`, `base_url`, `api_key`, `config`, `env`
+- `ThreadOptions`: `model`, `sandbox_mode`, `working_directory`, `skip_git_repo_check`, `model_reasoning_effort`, `network_access_enabled`, `web_search_mode`, `web_search_enabled`, `approval_policy`, `additional_directories`
+- `TurnOptions`: `output_schema`, `signal`
+
+## Cancellation
+
+```python
+import threading
+
+from codex import Codex, TurnOptions
+
+cancel = threading.Event()
+
+client = Codex()
+thread = client.start_thread()
+stream = thread.run_streamed("Long running task", TurnOptions(signal=cancel))
+
+cancel.set()
+for event in stream.events:
+    print(event)
+```
 
 ## Bundled binary behavior
 

{codex_python-1.0.0 → codex_python-1.0.0b3}/README.md

@@ -88,9 +88,27 @@ thread.run("Continue from previous context")
 
 ## Options
 
-- `CodexOptions`: `codex_path_override`, `base_url`, `api_key`
-- `ThreadOptions`: `model`, `sandbox_mode`, `working_directory`, `skip_git_repo_check`
-- `TurnOptions`: `output_schema`
+- `CodexOptions`: `codex_path_override`, `base_url`, `api_key`, `config`, `env`
+- `ThreadOptions`: `model`, `sandbox_mode`, `working_directory`, `skip_git_repo_check`, `model_reasoning_effort`, `network_access_enabled`, `web_search_mode`, `web_search_enabled`, `approval_policy`, `additional_directories`
+- `TurnOptions`: `output_schema`, `signal`
+
+## Cancellation
+
+```python
+import threading
+
+from codex import Codex, TurnOptions
+
+cancel = threading.Event()
+
+client = Codex()
+thread = client.start_thread()
+stream = thread.run_streamed("Long running task", TurnOptions(signal=cancel))
+
+cancel.set()
+for event in stream.events:
+    print(event)
+```
 
 ## Bundled binary behavior
 

{codex_python-1.0.0 → codex_python-1.0.0b3}/codex/__init__.py

@@ -26,10 +26,21 @@ from codex.items import (
     TodoListItem,
     WebSearchItem,
 )
-from codex.options import ApprovalMode, CodexOptions, SandboxMode, ThreadOptions, TurnOptions
+from codex.options import (
+    ApprovalMode,
+    CancelSignal,
+    CodexConfigObject,
+    CodexConfigValue,
+    CodexOptions,
+    ModelReasoningEffort,
+    SandboxMode,
+    ThreadOptions,
+    TurnOptions,
+    WebSearchMode,
+)
 from codex.thread import Input, RunResult, RunStreamedResult, Thread, UserInput
 
-__version__ = "1.0.0"
+__version__ = "1.0.0-beta.3"
 
 __all__ = [
     "Codex",
@@ -47,6 +58,11 @@ __all__ = [
     "TurnOptions",
     "ApprovalMode",
     "SandboxMode",
+    "ModelReasoningEffort",
+    "WebSearchMode",
+    "CodexConfigValue",
+    "CodexConfigObject",
+    "CancelSignal",
     "ThreadEvent",
     "ThreadStartedEvent",
     "TurnStartedEvent",

{codex_python-1.0.0 → codex_python-1.0.0b3}/codex/codex.py

@@ -10,7 +10,11 @@ class Codex:
 
     def __init__(self, options: CodexOptions | None = None) -> None:
         resolved = options or CodexOptions()
-        self._exec = CodexExec(resolved.codex_path_override)
+        self._exec = CodexExec(
+            resolved.codex_path_override,
+            env_override=resolved.env,
+            config_overrides=resolved.config,
+        )
         self._options = resolved
 
     def start_thread(self, options: ThreadOptions | None = None) -> Thread:

codex_python-1.0.0b3/codex/exec.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import shutil
+import subprocess
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+from codex._binary import bundled_codex_path
+from codex.errors import CodexExecError
+from codex.options import (
+    ApprovalMode,
+    CancelSignal,
+    CodexConfigObject,
+    CodexConfigValue,
+    ModelReasoningEffort,
+    SandboxMode,
+    SupportsAborted,
+    SupportsIsSet,
+    WebSearchMode,
+)
+
+INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"
+PYTHON_SDK_ORIGINATOR = "codex_sdk_py"
+TOML_BARE_KEY = re.compile(r"^[A-Za-z0-9_-]+$")
+
+
+@dataclass(slots=True, frozen=True)
+class CodexExecArgs:
+    input: str
+    base_url: str | None = None
+    api_key: str | None = None
+    thread_id: str | None = None
+    images: list[str] | None = None
+    model: str | None = None
+    sandbox_mode: SandboxMode | None = None
+    working_directory: str | None = None
+    additional_directories: list[str] | None = None
+    skip_git_repo_check: bool = False
+    output_schema_file: str | None = None
+    model_reasoning_effort: ModelReasoningEffort | None = None
+    signal: CancelSignal | None = None
+    network_access_enabled: bool | None = None
+    web_search_mode: WebSearchMode | None = None
+    web_search_enabled: bool | None = None
+    approval_policy: ApprovalMode | None = None
+
+
+class CodexExec:
+    def __init__(
+        self,
+        executable_path: str | None = None,
+        env_override: dict[str, str] | None = None,
+        config_overrides: CodexConfigObject | None = None,
+    ) -> None:
+        if executable_path is not None:
+            path = Path(executable_path)
+        else:
+            try:
+                path = bundled_codex_path()
+            except CodexExecError as bundled_error:
+                system_codex = shutil.which("codex")
+                if system_codex is None:
+                    raise CodexExecError(
+                        f"{bundled_error} Also failed to find `codex` on PATH."
+                    ) from bundled_error
+                path = Path(system_codex)
+        self.executable_path = str(path)
+        self._env_override = env_override
+        self._config_overrides = config_overrides
+
+    def run(self, args: CodexExecArgs) -> Iterator[str]:
+        if is_signal_aborted(args.signal):
+            raise CodexExecError("Codex exec aborted before start")
+
+        command_args: list[str] = ["exec", "--experimental-json"]
+
+        if self._config_overrides is not None:
+            for override in serialize_config_overrides(self._config_overrides):
+                command_args.extend(["--config", override])
+
+        if args.model is not None:
+            command_args.extend(["--model", args.model])
+        if args.sandbox_mode is not None:
+            command_args.extend(["--sandbox", args.sandbox_mode])
+        if args.working_directory is not None:
+            command_args.extend(["--cd", args.working_directory])
+        if args.additional_directories:
+            for directory in args.additional_directories:
+                command_args.extend(["--add-dir", directory])
+        if args.skip_git_repo_check:
+            command_args.append("--skip-git-repo-check")
+        if args.output_schema_file is not None:
+            command_args.extend(["--output-schema", args.output_schema_file])
+        if args.model_reasoning_effort is not None:
+            command_args.extend(
+                [
+                    "--config",
+                    f'model_reasoning_effort="{args.model_reasoning_effort}"',
+                ]
+            )
+        if args.network_access_enabled is not None:
+            command_args.extend(
+                [
+                    "--config",
+                    (
+                        "sandbox_workspace_write.network_access="
+                        f"{format_toml_bool(args.network_access_enabled)}"
+                    ),
+                ]
+            )
+        if args.web_search_mode is not None:
+            command_args.extend(["--config", f'web_search="{args.web_search_mode}"'])
+        elif args.web_search_enabled is True:
+            command_args.extend(["--config", 'web_search="live"'])
+        elif args.web_search_enabled is False:
+            command_args.extend(["--config", 'web_search="disabled"'])
+        if args.approval_policy is not None:
+            command_args.extend(["--config", f'approval_policy="{args.approval_policy}"'])
+        if args.thread_id is not None:
+            command_args.extend(["resume", args.thread_id])
+        if args.images is not None:
+            for image in args.images:
+                command_args.extend(["--image", image])
+
+        env = self.build_env(base_url=args.base_url, api_key=args.api_key)
+
+        try:
+            child = subprocess.Popen(
+                [self.executable_path, *command_args],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding="utf-8",
+                env=env,
+            )
+        except OSError as exc:
+            raise CodexExecError(
+                f"Failed to spawn codex executable at '{self.executable_path}': {exc}"
+            ) from exc
+
+        if child.stdin is None:
+            terminate_child(child)
+            raise CodexExecError("Child process has no stdin")
+        if child.stdout is None:
+            terminate_child(child)
+            raise CodexExecError("Child process has no stdout")
+        if child.stderr is None:
+            terminate_child(child)
+            raise CodexExecError("Child process has no stderr")
+
+        if is_signal_aborted(args.signal):
+            terminate_child(child)
+            _ = child.stderr.read()
+            child.stderr.close()
+            raise CodexExecError("Codex exec aborted before start")
+
+        try:
+            child.stdin.write(args.input)
+            child.stdin.close()
+        except OSError as exc:
+            terminate_child(child)
+            raise CodexExecError(f"Failed to write input to codex process: {exc}") from exc
+
+        if is_signal_aborted(args.signal):
+            terminate_child(child)
+            _ = child.stderr.read()
+            child.stderr.close()
+            raise CodexExecError("Codex exec aborted")
+
+        aborted = False
+        try:
+            for line in child.stdout:
+                if is_signal_aborted(args.signal):
+                    aborted = True
+                    break
+                yield line.rstrip("\r\n")
+        except GeneratorExit:
+            terminate_child(child)
+            child.stderr.close()
+            raise
+        finally:
+            child.stdout.close()
+
+        if aborted:
+            terminate_child(child)
+            stderr = child.stderr.read()
+            child.stderr.close()
+            raise CodexExecError(build_abort_message(stderr))
+
+        exit_code = child.wait()
+        stderr = child.stderr.read()
+        child.stderr.close()
+
+        if exit_code != 0:
+            raise CodexExecError(f"Codex exec exited with code {exit_code}: {stderr}")
+
+    def build_env(self, base_url: str | None, api_key: str | None) -> dict[str, str]:
+        env: dict[str, str]
+        if self._env_override is None:
+            env = os.environ.copy()
+        else:
+            env = dict(self._env_override)
+
+        if INTERNAL_ORIGINATOR_ENV not in env:
+            env[INTERNAL_ORIGINATOR_ENV] = PYTHON_SDK_ORIGINATOR
+        if base_url is not None:
+            env["OPENAI_BASE_URL"] = base_url
+        if api_key is not None:
+            env["CODEX_API_KEY"] = api_key
+        return env
+
+
+def terminate_child(child: subprocess.Popen[str]) -> None:
+    try:
+        child.kill()
+    except Exception:
+        pass
+    try:
+        child.wait()
+    except Exception:
+        pass
+
+
+def build_abort_message(stderr: str) -> str:
+    if stderr == "":
+        return "Codex exec aborted"
+    return f"Codex exec aborted: {stderr}"
+
+
+def is_signal_aborted(signal: CancelSignal | None) -> bool:
+    if signal is None:
+        return False
+    if isinstance(signal, SupportsAborted):
+        return signal.aborted
+    if isinstance(signal, SupportsIsSet):
+        return signal.is_set()
+    raise TypeError("signal must expose `aborted` or `is_set()`")
+
+
+def serialize_config_overrides(config_overrides: CodexConfigObject) -> list[str]:
+    overrides: list[str] = []
+    flatten_config_overrides(config_overrides, "", overrides)
+    return overrides
+
+
+def flatten_config_overrides(
+    value: CodexConfigValue | CodexConfigObject, prefix: str, overrides: list[str]
+) -> None:
+    if not isinstance(value, dict):
+        if prefix == "":
+            raise ValueError("Codex config overrides must be a plain object")
+        overrides.append(f"{prefix}={to_toml_value(value, prefix)}")
+        return
+
+    entries = list(value.items())
+    if prefix == "" and not entries:
+        return
+    if prefix != "" and not entries:
+        overrides.append(f"{prefix}={{}}")
+        return
+
+    for key, child in entries:
+        if not isinstance(key, str) or key == "":
+            raise ValueError("Codex config override keys must be non-empty strings")
+        path = f"{prefix}.{key}" if prefix else key
+        if isinstance(child, dict):
+            flatten_config_overrides(child, path, overrides)
+        else:
+            overrides.append(f"{path}={to_toml_value(child, path)}")
+
+
+def to_toml_value(value: CodexConfigValue, path: str) -> str:
+    if isinstance(value, str):
+        return json.dumps(value)
+    if isinstance(value, bool):
+        return format_toml_bool(value)
+    if isinstance(value, int):
+        return f"{value}"
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise ValueError(f"Codex config override at {path} must be a finite number")
+        return f"{value}"
+    if isinstance(value, list):
+        rendered_items = [
+            to_toml_value(item, f"{path}[{index}]") for index, item in enumerate(value)
+        ]
+        return f"[{', '.join(rendered_items)}]"
+    if isinstance(value, dict):
+        parts: list[str] = []
+        for key, child in value.items():
+            if not isinstance(key, str) or key == "":
+                raise ValueError("Codex config override keys must be non-empty strings")
+            parts.append(f"{format_toml_key(key)} = {to_toml_value(child, f'{path}.{key}')}")
+        return f"{{{', '.join(parts)}}}"
+    if value is None:
+        raise ValueError(f"Codex config override at {path} cannot be null")
+    raise ValueError(f"Unsupported Codex config override value at {path}: {type(value).__name__}")
+
+
+def format_toml_key(key: str) -> str:
+    if TOML_BARE_KEY.match(key):
+        return key
+    return json.dumps(key)
+
+
+def format_toml_bool(value: bool) -> str:
+    return "true" if value else "false"

{codex_python-1.0.0 → codex_python-1.0.0b3}/codex/items.py

@@ -29,11 +29,37 @@ class FileChangeItem(TypedDict):
     status: PatchApplyStatus
 
 
+class McpTextContent(TypedDict):
+    type: Literal["text"]
+    text: str
+
+
+class McpImageContent(TypedDict):
+    type: Literal["image"]
+    data: str
+    mimeType: str
+
+
+McpContentBlock = McpTextContent | McpImageContent | dict[str, object]
+
+
+class McpToolCallResult(TypedDict):
+    content: list[McpContentBlock]
+    structured_content: object
+
+
+class McpToolCallError(TypedDict):
+    message: str
+
+
 class McpToolCallItem(TypedDict):
     id: str
     type: Literal["mcp_tool_call"]
     server: str
     tool: str
+    arguments: NotRequired[object]
+    result: NotRequired[McpToolCallResult]
+    error: NotRequired[McpToolCallError]
     status: McpToolCallStatus
 
 

codex_python-1.0.0b3/codex/options.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal, Protocol, runtime_checkable
+
+ApprovalMode = Literal["never", "on-request", "on-failure", "untrusted"]
+SandboxMode = Literal["read-only", "workspace-write", "danger-full-access"]
+ModelReasoningEffort = Literal["minimal", "low", "medium", "high", "xhigh"]
+WebSearchMode = Literal["disabled", "cached", "live"]
+
+type CodexConfigValue = (
+    str | int | float | bool | list["CodexConfigValue"] | dict[str, "CodexConfigValue"]
+)
+type CodexConfigObject = dict[str, CodexConfigValue]
+
+
+@runtime_checkable
+class SupportsIsSet(Protocol):
+    def is_set(self) -> bool: ...
+
+
+@runtime_checkable
+class SupportsAborted(Protocol):
+    @property
+    def aborted(self) -> bool: ...
+
+
+type CancelSignal = SupportsIsSet | SupportsAborted
+
+
+@dataclass(slots=True, frozen=True)
+class CodexOptions:
+    codex_path_override: str | None = None
+    base_url: str | None = None
+    api_key: str | None = None
+    config: CodexConfigObject | None = None
+    env: dict[str, str] | None = None
+
+
+@dataclass(slots=True, frozen=True)
+class ThreadOptions:
+    model: str | None = None
+    sandbox_mode: SandboxMode | None = None
+    working_directory: str | None = None
+    skip_git_repo_check: bool = False
+    model_reasoning_effort: ModelReasoningEffort | None = None
+    network_access_enabled: bool | None = None
+    web_search_mode: WebSearchMode | None = None
+    web_search_enabled: bool | None = None
+    approval_policy: ApprovalMode | None = None
+    additional_directories: list[str] | None = None
+
+
+@dataclass(slots=True, frozen=True)
+class TurnOptions:
+    output_schema: dict[str, object] | None = None
+    signal: CancelSignal | None = None

{codex_python-1.0.0 → codex_python-1.0.0b3}/codex/thread.py

@@ -3,16 +3,20 @@ from __future__ import annotations
 import json
 from collections.abc import Iterator, Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Literal, TypedDict, cast
+from typing import Any, Literal, Protocol, TypedDict, cast
 
 from codex.errors import CodexParseError, ThreadRunError
 from codex.events import ThreadEvent, Usage
-from codex.exec import CodexExec, CodexExecArgs
+from codex.exec import CodexExecArgs
 from codex.items import ThreadItem
 from codex.options import CodexOptions, ThreadOptions, TurnOptions
 from codex.output_schema_file import create_output_schema_file
 
 
+class ExecRunner(Protocol):
+    def run(self, args: CodexExecArgs) -> Iterator[str]: ...
+
+
 class TextInput(TypedDict):
     type: Literal["text"]
     text: str
@@ -42,7 +46,7 @@ class RunStreamedResult:
 class Thread:
     def __init__(
         self,
-        exec_runner: CodexExec,
+        exec_runner: ExecRunner,
         options: CodexOptions,
         thread_options: ThreadOptions,
         thread_id: str | None = None,
@@ -77,8 +81,15 @@ class Thread:
             model=options.model,
             sandbox_mode=options.sandbox_mode,
             working_directory=options.working_directory,
+            additional_directories=options.additional_directories,
             skip_git_repo_check=options.skip_git_repo_check,
             output_schema_file=schema_file.schema_path,
+            model_reasoning_effort=options.model_reasoning_effort,
+            signal=effective_turn_options.signal,
+            network_access_enabled=options.network_access_enabled,
+            web_search_mode=options.web_search_mode,
+            web_search_enabled=options.web_search_enabled,
+            approval_policy=options.approval_policy,
         )
         try:
             for item in self._exec.run(exec_args):
@@ -95,7 +106,6 @@ class Thread:
         final_response = ""
         usage: Usage | None = None
         turn_failure: str | None = None
-        saw_turn_complete = False
         for event in generator:
             event_dict = cast(dict[str, Any], event)
             event_type = event_dict.get("type")
@@ -111,7 +121,6 @@ class Thread:
                 usage_value = event_dict.get("usage")
                 if isinstance(usage_value, dict):
                     usage = cast(Usage, usage_value)
-                    saw_turn_complete = True
             elif event_type == "turn.failed":
                 error_value = event_dict.get("error")
                 if isinstance(error_value, dict):
@@ -119,17 +128,8 @@ class Thread:
                     if isinstance(message, str):
                         turn_failure = message
                         break
-            elif event_type == "error":
-                message_value = event_dict.get("message")
-                if isinstance(message_value, str):
-                    turn_failure = message_value
-                    break
         if turn_failure is not None:
             raise ThreadRunError(turn_failure)
-        if not saw_turn_complete:
-            raise ThreadRunError(
-                "stream disconnected before completion: missing turn.completed event"
-            )
         return RunResult(items=items, final_response=final_response, usage=usage)
 
 

{codex_python-1.0.0 → codex_python-1.0.0b3}/crates/codex_native/Cargo.lock

@@ -20,7 +20,7 @@ dependencies = [
 
 [[package]]
 name = "codex_native"
-version = "1.0.0"
+version = "1.0.0-beta.3"
 dependencies = [
  "pyo3",
 ]

{codex_python-1.0.0 → codex_python-1.0.0b3}/crates/codex_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "codex_native"
-version = "1.0.0"
+version = "1.0.0-beta.3"
 edition = "2021"
 
 [lib]

{codex_python-1.0.0 → codex_python-1.0.0b3}/pyproject.toml

@@ -65,6 +65,7 @@ ignore_missing_imports = true
 exclude = [
   "^codex-proj/",
   "^\\.generated/",
+  "^crates/codex_native/codex/",
   "^crates/.*/target/",
   "^dist/",
 ]

codex_python-1.0.0/codex/exec.py

@@ -1,118 +0,0 @@
-from __future__ import annotations
-
-import os
-import shutil
-import subprocess
-from collections.abc import Iterator
-from dataclasses import dataclass
-from pathlib import Path
-
-from codex._binary import bundled_codex_path
-from codex.errors import CodexExecError
-from codex.options import SandboxMode
-
-INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"
-PYTHON_SDK_ORIGINATOR = "codex_sdk_py"
-
-
-@dataclass(slots=True, frozen=True)
-class CodexExecArgs:
-    input: str
-    base_url: str | None = None
-    api_key: str | None = None
-    thread_id: str | None = None
-    images: list[str] | None = None
-    model: str | None = None
-    sandbox_mode: SandboxMode | None = None
-    working_directory: str | None = None
-    skip_git_repo_check: bool = False
-    output_schema_file: str | None = None
-
-
-class CodexExec:
-    def __init__(self, executable_path: str | None = None) -> None:
-        if executable_path is not None:
-            path = Path(executable_path)
-        else:
-            try:
-                path = bundled_codex_path()
-            except CodexExecError as bundled_error:
-                system_codex = shutil.which("codex")
-                if system_codex is None:
-                    raise CodexExecError(
-                        f"{bundled_error} Also failed to find `codex` on PATH."
-                    ) from bundled_error
-                path = Path(system_codex)
-        self.executable_path = str(path)
-
-    def run(self, args: CodexExecArgs) -> Iterator[str]:
-        command_args: list[str] = ["exec", "--experimental-json"]
-
-        if args.model is not None:
-            command_args.extend(["--model", args.model])
-        if args.sandbox_mode is not None:
-            command_args.extend(["--sandbox", args.sandbox_mode])
-        if args.working_directory is not None:
-            command_args.extend(["--cd", args.working_directory])
-        if args.skip_git_repo_check:
-            command_args.append("--skip-git-repo-check")
-        if args.output_schema_file is not None:
-            command_args.extend(["--output-schema", args.output_schema_file])
-        if args.images is not None:
-            for image in args.images:
-                command_args.extend(["--image", image])
-        if args.thread_id:
-            command_args.extend(["resume", args.thread_id])
-
-        env = os.environ.copy()
-        if INTERNAL_ORIGINATOR_ENV not in env:
-            env[INTERNAL_ORIGINATOR_ENV] = PYTHON_SDK_ORIGINATOR
-        if args.base_url is not None:
-            env["OPENAI_BASE_URL"] = args.base_url
-        if args.api_key is not None:
-            env["CODEX_API_KEY"] = args.api_key
-
-        try:
-            child = subprocess.Popen(
-                [self.executable_path, *command_args],
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                encoding="utf-8",
-                env=env,
-            )
-        except OSError as exc:
-            raise CodexExecError(
-                f"Failed to spawn codex executable at '{self.executable_path}': {exc}"
-            ) from exc
-
-        if child.stdin is None:
-            child.kill()
-            raise CodexExecError("Child process has no stdin")
-        if child.stdout is None:
-            child.kill()
-            raise CodexExecError("Child process has no stdout")
-        if child.stderr is None:
-            child.kill()
-            raise CodexExecError("Child process has no stderr")
-
-        try:
-            child.stdin.write(args.input)
-            child.stdin.close()
-        except OSError as exc:
-            child.kill()
-            raise CodexExecError(f"Failed to write input to codex process: {exc}") from exc
-
-        try:
-            for line in child.stdout:
-                yield line.rstrip("\r\n")
-        finally:
-            child.stdout.close()
-
-        exit_code = child.wait()
-        stderr = child.stderr.read()
-        child.stderr.close()
-
-        if exit_code != 0:
-            raise CodexExecError(f"Codex exec exited with code {exit_code}: {stderr}")

codex_python-1.0.0/codex/options.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Literal
-
-ApprovalMode = Literal["never", "on-request", "on-failure", "untrusted"]
-SandboxMode = Literal["read-only", "workspace-write", "danger-full-access"]
-
-
-@dataclass(slots=True, frozen=True)
-class CodexOptions:
-    codex_path_override: str | None = None
-    base_url: str | None = None
-    api_key: str | None = None
-
-
-@dataclass(slots=True, frozen=True)
-class ThreadOptions:
-    model: str | None = None
-    sandbox_mode: SandboxMode | None = None
-    working_directory: str | None = None
-    skip_git_repo_check: bool = False
-
-
-@dataclass(slots=True, frozen=True)
-class TurnOptions:
-    output_schema: dict[str, object] | None = None