codex-python-sdk 0.1.0__py3-none-any.whl

codex_python_sdk/sync_client.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Any, Iterator
+
+from .async_client import AsyncCodexAgenticClient
+from .errors import CodexAgenticError
+from .types import AgentResponse, ResponseEvent
+
+
+class CodexAgenticClient:
+    """Synchronous facade over :class:`AsyncCodexAgenticClient`.
+
+    This wrapper owns an internal event loop and exposes blocking APIs for
+    scripts and notebooks that prefer non-async usage.
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        self._loop = asyncio.new_event_loop()
+        self._client = AsyncCodexAgenticClient(**kwargs)
+        self._loop_started = threading.Event()
+        self._loop_thread = threading.Thread(target=self._loop_thread_main, name="codex-agentic-client-loop", daemon=True)
+        self._loop_thread.start()
+        self._loop_started.wait()
+        self._closed = False
+
+    def _loop_thread_main(self) -> None:
+        asyncio.set_event_loop(self._loop)
+        self._loop_started.set()
+        self._loop.run_forever()
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        try:
+            self._run(self._client.close())
+        finally:
+            try:
+                if not self._loop.is_closed():
+                    self._loop.call_soon_threadsafe(self._loop.stop)
+            finally:
+                self._loop_thread.join(timeout=2.0)
+                # If the loop thread didn't exit, we cannot safely close the loop here.
+                if (not self._loop_thread.is_alive()) and (not self._loop.is_running()) and (not self._loop.is_closed()):
+                    self._loop.close()
+                self._closed = True
+
+    def __enter__(self) -> "CodexAgenticClient":
+        try:
+            self._run(self._client.connect())
+        except Exception:
+            try:
+                self.close()
+            except Exception:
+                # Preserve the original connection failure.
+                pass
+            raise
+        return self
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        self.close()
+
+    def _run(self, coro: Any) -> Any:
+        if self._closed:
+            raise CodexAgenticError("Client is closed.")
+        if threading.current_thread() is self._loop_thread:
+            raise CodexAgenticError("Cannot block on sync client from its own loop thread.")
+        fut = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return fut.result()
+
+    def thread_start(
+        self,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Create a new thread."""
+
+        return self._run(self._client.thread_start(params=params))
+
+    def thread_read(self, thread_id: str, *, include_turns: bool = False) -> dict[str, Any]:
+        """Read one thread by id."""
+
+        return self._run(self._client.thread_read(thread_id, include_turns=include_turns))
+
+    def thread_list(self, limit: int = 50, *, sort_key: str = "updated_at") -> list[dict[str, Any]]:
+        """List available threads."""
+
+        return self._run(self._client.thread_list(limit=limit, sort_key=sort_key))
+
+    def thread_archive(self, thread_id: str) -> dict[str, Any]:
+        """Archive one thread."""
+
+        return self._run(self._client.thread_archive(thread_id))
+
+    def thread_fork(
+        self,
+        thread_id: str,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return self._run(self._client.thread_fork(thread_id, params=params))
+
+    def thread_name_set(self, thread_id: str, name: str) -> dict[str, Any]:
+        return self._run(self._client.thread_name_set(thread_id, name))
+
+    def thread_unarchive(self, thread_id: str) -> dict[str, Any]:
+        return self._run(self._client.thread_unarchive(thread_id))
+
+    def thread_compact_start(self, thread_id: str) -> dict[str, Any]:
+        return self._run(self._client.thread_compact_start(thread_id))
+
+    def thread_rollback(self, thread_id: str, num_turns: int) -> dict[str, Any]:
+        return self._run(self._client.thread_rollback(thread_id, num_turns))
+
+    def thread_loaded_list(self, *, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        return self._run(self._client.thread_loaded_list(limit=limit, cursor=cursor))
+
+    def skills_list(
+        self,
+        *,
+        cwds: list[str] | None = None,
+        force_reload: bool | None = None,
+    ) -> dict[str, Any]:
+        return self._run(self._client.skills_list(cwds=cwds, force_reload=force_reload))
+
+    def skills_remote_read(self) -> dict[str, Any]:
+        return self._run(self._client.skills_remote_read())
+
+    def skills_remote_write(self, hazelnut_id: str, is_preload: bool) -> dict[str, Any]:
+        return self._run(self._client.skills_remote_write(hazelnut_id, is_preload))
+
+    def app_list(self, *, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        return self._run(self._client.app_list(limit=limit, cursor=cursor))
+
+    def skills_config_write(self, path: str, enabled: bool) -> dict[str, Any]:
+        return self._run(self._client.skills_config_write(path, enabled))
+
+    def turn_interrupt(self, thread_id: str, turn_id: str) -> dict[str, Any]:
+        return self._run(self._client.turn_interrupt(thread_id, turn_id))
+
+    def turn_steer(self, thread_id: str, turn_id: str, prompt: str) -> dict[str, Any]:
+        return self._run(self._client.turn_steer(thread_id, turn_id, prompt))
+
+    def review_start(
+        self,
+        thread_id: str,
+        target: dict[str, Any],
+        *,
+        delivery: str | None = None,
+    ) -> dict[str, Any]:
+        return self._run(self._client.review_start(thread_id, target, delivery=delivery))
+
+    def model_list(self, *, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        return self._run(self._client.model_list(limit=limit, cursor=cursor))
+
+    def account_rate_limits_read(self) -> dict[str, Any]:
+        return self._run(self._client.account_rate_limits_read())
+
+    def account_read(self, *, refresh_token: bool | None = None) -> dict[str, Any]:
+        return self._run(self._client.account_read(refresh_token=refresh_token))
+
+    def command_exec(
+        self,
+        command: list[str],
+        *,
+        cwd: str | None = None,
+        timeout_ms: int | None = None,
+        sandbox_policy: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return self._run(
+            self._client.command_exec(
+                command,
+                cwd=cwd,
+                timeout_ms=timeout_ms,
+                sandbox_policy=sandbox_policy,
+            )
+        )
+
+    def config_read(self, *, cwd: str | None = None, include_layers: bool = False) -> dict[str, Any]:
+        return self._run(self._client.config_read(cwd=cwd, include_layers=include_layers))
+
+    def config_value_write(
+        self,
+        key_path: str,
+        value: Any,
+        *,
+        merge_strategy: str = "upsert",
+        file_path: str | None = None,
+        expected_version: str | None = None,
+    ) -> dict[str, Any]:
+        return self._run(
+            self._client.config_value_write(
+                key_path,
+                value,
+                merge_strategy=merge_strategy,
+                file_path=file_path,
+                expected_version=expected_version,
+            )
+        )
+
+    def config_batch_write(
+        self,
+        edits: list[dict[str, Any]],
+        *,
+        file_path: str | None = None,
+        expected_version: str | None = None,
+    ) -> dict[str, Any]:
+        return self._run(
+            self._client.config_batch_write(
+                edits,
+                file_path=file_path,
+                expected_version=expected_version,
+            )
+        )
+
+    def config_requirements_read(self) -> dict[str, Any]:
+        return self._run(self._client.config_requirements_read())
+
+    def config_mcp_server_reload(self) -> dict[str, Any]:
+        return self._run(self._client.config_mcp_server_reload())
+
+    def mcp_server_status_list(self, *, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        return self._run(self._client.mcp_server_status_list(limit=limit, cursor=cursor))
+
+    def mcp_server_oauth_login(
+        self,
+        name: str,
+        *,
+        scopes: list[str] | None = None,
+        timeout_secs: int | None = None,
+    ) -> dict[str, Any]:
+        return self._run(self._client.mcp_server_oauth_login(name, scopes=scopes, timeout_secs=timeout_secs))
+
+    def fuzzy_file_search(
+        self,
+        query: str,
+        *,
+        roots: list[str] | None = None,
+        cancellation_token: str | None = None,
+    ) -> dict[str, Any]:
+        return self._run(
+            self._client.fuzzy_file_search(
+                query,
+                roots=roots,
+                cancellation_token=cancellation_token,
+            )
+        )
+
+    def responses_events(
+        self,
+        *,
+        prompt: str,
+        session_id: str | None = None,
+        thread_params: dict[str, Any] | None = None,
+        turn_params: dict[str, Any] | None = None,
+    ) -> Iterator[ResponseEvent]:
+        """Run one prompt and yield structured events."""
+
+        async_iter = self._client.responses_events(
+            prompt=prompt,
+            session_id=session_id,
+            thread_params=thread_params,
+            turn_params=turn_params,
+        )
+        try:
+            while True:
+                try:
+                    event = self._run(async_iter.__anext__())
+                except StopAsyncIteration:
+                    break
+                else:
+                    yield event
+        finally:
+            aclose = getattr(async_iter, "aclose", None)
+            if callable(aclose):
+                try:
+                    self._run(aclose())
+                except Exception:
+                    pass
+
+    def responses_stream_text(
+        self,
+        *,
+        prompt: str,
+        session_id: str | None = None,
+        thread_params: dict[str, Any] | None = None,
+        turn_params: dict[str, Any] | None = None,
+    ) -> Iterator[str]:
+        """Run one prompt and yield text deltas only."""
+
+        async_iter = self._client.responses_stream_text(
+            prompt=prompt,
+            session_id=session_id,
+            thread_params=thread_params,
+            turn_params=turn_params,
+        )
+        try:
+            while True:
+                try:
+                    chunk = self._run(async_iter.__anext__())
+                except StopAsyncIteration:
+                    break
+                else:
+                    yield chunk
+        finally:
+            aclose = getattr(async_iter, "aclose", None)
+            if callable(aclose):
+                try:
+                    self._run(aclose())
+                except Exception:
+                    pass
+
+    def responses_create(
+        self,
+        *,
+        prompt: str,
+        session_id: str | None = None,
+        thread_params: dict[str, Any] | None = None,
+        turn_params: dict[str, Any] | None = None,
+        include_events: bool = False,
+    ) -> AgentResponse:
+        """Run one prompt and return final aggregated response."""
+
+        return self._run(
+            self._client.responses_create(
+                prompt=prompt,
+                session_id=session_id,
+                thread_params=thread_params,
+                turn_params=turn_params,
+                include_events=include_events,
+            )
+        )

codex_python_sdk/types.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ._shared import utc_now
+
+
+@dataclass
+class AgentResponse:
+    """Aggregated final response for one prompt execution.
+
+    Attributes:
+        text: Final assistant text (message completion or merged deltas).
+        session_id: Thread id used by app-server.
+        request_id: Optional request id extracted from notifications.
+        tool_name: Backend label, currently always ``"app-server"``.
+        raw: Raw payload from the last observed event.
+        events: Optional full event list when ``include_events=True`` is used.
+    """
+
+    text: str
+    session_id: str
+    request_id: str | None
+    tool_name: str
+    raw: Any
+    events: list["ResponseEvent"] | None = None
+
+
+@dataclass
+class ResponseEvent:
+    """Normalized streaming event produced from app-server notifications."""
+
+    type: str
+    phase: str
+    text_delta: str | None = None
+    message_text: str | None = None
+    request_id: str | None = None
+    session_id: str | None = None
+    turn_id: str | None = None
+    item_id: str | None = None
+    summary_index: int | None = None
+    thread_name: str | None = None
+    token_usage: dict[str, Any] | None = None
+    plan: list[dict[str, Any]] | None = None
+    diff: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+    timestamp: str = field(default_factory=lambda: utc_now())

codex_python_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: codex-python-sdk
+Version: 0.1.0
+Summary: Python wrapper for Codex app-server JSON-RPC interface
+Author: Henry_spdcoding
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/spdcoding/codex-python-sdk
+Project-URL: Repository, https://github.com/spdcoding/codex-python-sdk
+Project-URL: Issues, https://github.com/spdcoding/codex-python-sdk/issues
+Project-URL: Documentation, https://github.com/spdcoding/codex-python-sdk/blob/HEAD/docs/tutorial.md
+Project-URL: Codex-App-Server, https://developers.openai.com/codex/app-server/
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <4.0,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=8.2; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Requires-Dist: rich; extra == "test"
+Provides-Extra: build
+Requires-Dist: setuptools>=61; extra == "build"
+Requires-Dist: wheel; extra == "build"
+Requires-Dist: build; extra == "build"
+Requires-Dist: twine; extra == "build"
+Dynamic: license-file
+
+# codex-python-sdk
+
+[GitHub](https://github.com/spdcoding/codex-python-sdk) | [English](./README.md) | [简体中文](./README.zh-CN.md) | [Docs](./docs)
+
+Production-focused Python SDK for running Codex agents through `codex app-server`.
+
+`codex-python-sdk` gives you a stable Python interface over Codex JSON-RPC so you can automate agent workflows, stream structured runtime events, and enforce runtime policy from your own applications.
+
+## Why This SDK
+
+- Script-first API: built for automation pipelines, not only interactive CLI sessions.
+- Sync + async parity: same mental model and similar method names in both clients.
+- Structured streaming: consume normalized `ResponseEvent` objects for observability and UI.
+- Predictable failures: explicit error types such as `NotAuthenticatedError` and `SessionNotFoundError`.
+- Policy control: approval/file-change/tool-input/tool-call hooks and policy engine integration.
+- Thin protocol wrapper: close to `codex app-server` behavior, easier to reason about and debug.
+
+## 30-Second Quick Start
+
+```python
+from codex_python_sdk import create_client
+
+with create_client() as client:
+    result = client.responses_create(prompt="Reply with exactly: READY")
+    print(result.session_id)
+    print(result.text)
+```
+
+## Core Workflows
+
+### Stream events (for logs/UI)
+
+```python
+from codex_python_sdk import create_client, render_exec_style_events
+
+with create_client() as client:
+    events = client.responses_events(prompt="Summarize this repository")
+    render_exec_style_events(events)
+```
+
+### Async flow
+
+```python
+import asyncio
+from codex_python_sdk import create_async_client
+
+
+async def main() -> None:
+    async with create_async_client() as client:
+        result = await client.responses_create(prompt="Reply with exactly: ASYNC_READY")
+        print(result.text)
+
+
+asyncio.run(main())
+```
+
+### Smoke and demo runner
+
+```bash
+# Quick health check (default mode)
+codex-python-sdk-demo --mode smoke
+
+# Stable API showcase
+codex-python-sdk-demo --mode demo
+
+# Demo + unstable remote/interrupt/compact paths
+codex-python-sdk-demo --mode full
+```
+
+Note: the demo runner uses permissive hooks (`accept` for command/file approvals and empty tool-input answers) so it can run unattended.
+Use stricter hooks or policy engines in production.
+
+## Mental Model: How It Works
+
+`codex app-server` is Codex CLI's local JSON-RPC runtime over stdio.
+
+One `responses_create(prompt=...)` call is essentially:
+
+1. `create_client()` creates a sync facade (`CodexAgenticClient`).
+2. Sync call forwards to `AsyncCodexAgenticClient` via a dedicated event-loop thread.
+3. `connect()` starts `codex app-server` and performs `initialize/initialized`.
+4. `_request(method, params)` handles all JSON-RPC request/response plumbing.
+5. `responses_events()` streams notifications; `responses_create()` aggregates them into final text.
+
+For a deeper walkthrough, see `docs/core_mechanism.md`.
+
+## Safety Defaults (Important)
+
+Default behavior without hooks/policy:
+- Command approval: `accept`
+- File change approval: `accept`
+- Tool user input: empty answers
+- Tool call: failure response with explanatory text
+
+This is convenient for unattended demos, but not production-safe.
+
+Recommended safer setup: enable LLM-judge policy with strict fallback decisions.
+
+```python
+from codex_python_sdk import PolicyJudgeConfig, create_client
+
+rubric = {
+    "system_rubric": "Allow read-only operations. Decline unknown write operations.",
+    "use_llm_judge": True,
+}
+
+judge_cfg = PolicyJudgeConfig(
+    timeout_seconds=8.0,
+    model="gpt-5",
+    effort="low",
+    fallback_command_decision="decline",
+    fallback_file_change_decision="decline",
+)
+
+with create_client(
+    policy_rubric=rubric,
+    policy_judge_config=judge_cfg,
+) as client:
+    result = client.responses_create(prompt="Show git status.")
+    print(result.text)
+```
+
+Note: LLM-judge requires a real Codex runtime/account; for deterministic local tests, use `RuleBasedPolicyEngine`.
+
+## Install
+
+### Prerequisites
+
+- Python `3.9+` (recommended: `3.12`)
+- `uv` (recommended for development workflows)
+- `codex` CLI installed and runnable
+- Authentication completed via `codex login`
+
+### Install from PyPI
+
+```bash
+uv add codex-python-sdk
+uv run codex-python-sdk-demo --help
+```
+
+or
+
+```bash
+pip install codex-python-sdk
+codex-python-sdk-demo --help
+```
+
+### Developer setup (for contributors)
+
+```bash
+./uv-sync.sh
+```
+
+This bootstraps a local `.venv` and installs project/test/build dependencies.
+
+## API Snapshot
+
+Factory:
+- `create_client(**kwargs) -> CodexAgenticClient`
+- `create_async_client(**kwargs) -> AsyncCodexAgenticClient`
+
+High-frequency response APIs:
+- `responses_create(...) -> AgentResponse`
+- `responses_events(...) -> Iterator[ResponseEvent] / AsyncIterator[ResponseEvent]`
+- `responses_stream_text(...) -> Iterator[str] / AsyncIterator[str]`
+
+Thread basics:
+- `thread_start`, `thread_read`, `thread_list`, `thread_archive`
+
+Account basics:
+- `account_read`, `account_rate_limits_read`
+
+## Documentation Map
+
+English:
+- `docs/tutorial.md`: practical workflows and end-to-end usage
+- `docs/core_mechanism.md`: architecture-level core control flow
+- `docs/config.md`: server/thread/turn configuration model
+- `docs/api.md`: full API reference (sync + async)
+- `docs/policy.md`: hooks and policy engine integration
+- `docs/app_server.md`: app-server concepts and protocol mapping
+
+简体中文:
+- `docs/zh/tutorial.md`
+- `docs/zh/core_mechanism.md`
+- `docs/zh/config.md`
+- `docs/zh/api.md`
+- `docs/zh/policy.md`
+- `docs/zh/app_server.md`
+
+## Notes
+
+- After `AppServerConnectionError`, recreate the client instead of relying on implicit reconnect behavior.
+- Internal app-server `stderr` buffering keeps only the latest 500 lines in SDK-captured diagnostics.
+- When using low-level server request handlers, method names must be exactly `item`, `tool`, or `requestUserInput`.
+- Policy LLM-judge parsing is strict JSON-only: judge output must be a pure JSON object; embedded JSON snippets in free text are rejected.
+- Invalid command/file policy decision values (allowed: `accept`, `acceptForSession`, `decline`, `cancel`) raise `CodexAgenticError`.
+
+## Development
+
+```bash
+./uv-sync.sh
+uv run python3 -m pytest -q -m "not real"
+```
+
+## Release
+
+```bash
+# Default: test + build + twine check (no upload)
+./build.sh
+
+# Build only
+./build.sh build
+
+# Release to pypi (upload enabled explicitly)
+TWINE_UPLOAD=1 ./build.sh release --repo pypi
+
+# Release to testpypi
+TWINE_UPLOAD=1 ./build.sh release --repo testpypi
+
+# Upload existing artifacts only
+./build.sh upload --repo pypi
+
+# Help
+./build.sh help
+```
+
+Recommended upload auth: `~/.pypirc` with API token.
+
+## Project Layout
+
+- `codex_python_sdk/`: SDK source code
+- `codex_python_sdk/examples/`: runnable demo code
+- `tests/`: unit and real-runtime integration tests
+- `uv-sync.sh`: dev environment bootstrap
+- `build.sh`: build/release script
+
+## Error Types
+
+- `CodexAgenticError`: base SDK error
+- `AppServerConnectionError`: app-server transport/setup failure
+- `SessionNotFoundError`: unknown thread/session id
+- `NotAuthenticatedError`: auth unavailable or invalid

codex_python_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+codex_python_sdk/__init__.py,sha256=aD7oFvTq-ZFk5RWlF_nd0ycXr0JXltz-LmeXReC7YmQ,1410
+codex_python_sdk/_shared.py,sha256=0YwwZ1KeM9AvUJ8v_o3mjeFeUbtKk9j3WJZvUbGks_g,3028
+codex_python_sdk/async_client.py,sha256=Wmc39b8jpHJi8mARVFRSAANriXaX6n0bjtFqj2hsFA0,54972
+codex_python_sdk/errors.py,sha256=ndPfykdV4xFRZDppxyKlFCjHzXlP-SVifIlAExIEnJI,493
+codex_python_sdk/factory.py,sha256=BenAH6fWAgI1HVvGpWDV_2dCYyz2K_XxLf9dLI2ipQo,597
+codex_python_sdk/policy.py,sha256=63ssVhPQ-AGGbDY5-xMpBlRVFkPv7QlyDjpiktEzaVM,23115
+codex_python_sdk/renderer.py,sha256=doE_adm-WpJ_C1ETbHoVhMfxIi19IYH_xuES7TMcY-s,23654
+codex_python_sdk/sync_client.py,sha256=8kiym7uEveHBhl0savtDkAFo_oHARTTzJtKYcps8CKI,11508
+codex_python_sdk/types.py,sha256=Kahi-p3WSOEeXG5ep0gCji8oG6__1GJ4wYcmE92Lmnc,1435
+codex_python_sdk/examples/__init__.py,sha256=PHh4jqD7i0aL8W8hXThczKcT4xsNZiXanBxOH5IOW5I,36
+codex_python_sdk/examples/demo_smoke.py,sha256=BHWVSbTSvbMKnVdnJNOPivzMS-SfHwf7SN2HkevEFoA,13569
+codex_python_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=ww_lp8EcdsoJ9-K-8xXnJ_n8SX6FNiv7tKE8jk2Gzh0,1072
+codex_python_sdk-0.1.0.dist-info/METADATA,sha256=dJRAGTgKZxaOgNoSZiskqMEbh2FzTVSZNXZk_zSD97E,8441
+codex_python_sdk-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+codex_python_sdk-0.1.0.dist-info/entry_points.txt,sha256=YiQUxrLaU3Mwjp8X4kMNpCkhY1HXMN2TJIuYyQWt-l8,84
+codex_python_sdk-0.1.0.dist-info/top_level.txt,sha256=Et4uySZ0xrY_Fog06H-5_jyj1ZOoTwKIfVvyYOeZQVI,17
+codex_python_sdk-0.1.0.dist-info/RECORD,,

codex_python_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codex_python_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codex-python-sdk-demo = codex_python_sdk.examples.demo_smoke:main