python-codex 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

python_codex-0.1.2.dist-info/METADATA

@@ -0,0 +1,355 @@
+Metadata-Version: 2.4
+Name: python-codex
+Version: 0.1.2
+Summary: A minimal Python extraction of Codex's main agent loop
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=3.4
+Requires-Dist: fastapi>=0.115
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: requests>=2.31
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: uvicorn>=0.32
+Description-Content-Type: text/markdown
+
+# pycodex
+
+English README. Chinese version: `README_ZH.md`
+
+PyPI distribution name: `python-codex`  
+Import path and CLI command remain `pycodex`.
+
+This repository extracts the core Codex agent loop from upstream Codex
+(`https://github.com/openai/codex`) into a deliberately small Python version,
+while preserving the two most important layers:
+
+- `submission_loop`: sequentially consumes submitted operations.
+- `run_turn`: keeps executing `model sample -> tool call -> feed tool result
+  back into the model` inside a single turn until a final answer is reached.
+
+Relevant Rust reference points:
+
+- `codex-rs/core/src/codex.rs` -> `submission_loop`
+- `codex-rs/core/src/codex.rs` -> `run_turn`
+- `codex-rs/core/src/codex.rs` -> `run_sampling_request`
+- `codex-rs/core/src/tools/router.rs` -> `ToolRouter`
+- `codex-rs/core/src/stream_events_utils.rs` -> `handle_output_item_done`
+
+## Quick Start
+
+Install dependencies first:
+
+```bash
+uv sync
+```
+
+Try the real entry points:
+
+```bash
+uv run pycodex "Reply with exactly OK."
+uv run pycodex
+```
+
+## Design Tradeoffs
+
+This is not a 1:1 port of the Rust implementation. The current goal is a
+minimal reusable kernel that converges on the upstream behavior over time:
+
+1. Use a thin `ModelClient` protocol to abstract the model side.
+2. Use `ToolRegistry` to manage tool specs and executors.
+3. Use `AgentLoop` to implement the core closed loop.
+4. Use `AgentRuntime` to preserve the outer submission queue so it can keep
+   converging toward Rust's `submission_loop` later.
+
+Intentionally not included yet:
+
+- TUI / streaming incremental rendering
+- MCP / connectors / sandbox / approvals
+- memory / compact / hooks / review mode
+- a full production OpenAI adapter surface
+
+All of those can be layered on later. For now, the project is focused on
+nailing the core tool-augmented reasoning loop first.
+
+## Layout
+
+- `pycodex/protocol.py`: minimal conversation item / prompt / event protocol
+- `pycodex/model.py`: model client protocol and Responses API adapter
+- `pycodex/cli.py`: single-turn and interactive `pycodex` CLI entry points
+- `pycodex/tools/base_tool.py`: `BaseTool`, `ToolRegistry`, `ToolContext`
+- `pycodex/tools/`: concrete tool implementations
+- `pycodex/agent.py`: inner turn loop
+- `pycodex/runtime.py`: outer submission queue
+- `tests/test_agent.py`: core behavior tests
+
+## Current Alignment Status
+
+Current progress is easiest to read in layers:
+
+- prompt/context alignment:
+  - on the non-interactive `exec` path, `instructions` and `input` already
+    match upstream Codex;
+  - this layer is now mainly handled by `pycodex/context.py` plus vendored
+    prompt data.
+- turn-loop semantic alignment:
+  - `AgentLoop` no longer uses a fixed 12-iteration cap by default;
+  - like upstream, it now converges naturally based on whether there is still
+    follow-up work or tool handoff to do;
+  - the local iteration-limit parameter is gone.
+- request-level alignment:
+  - the non-interactive `exec` request body is mostly aligned;
+  - the default CLI non-exec first request now also follows the upstream
+    `codex-tui` + `<collaboration_mode>` path;
+  - the default CLI two-turn main-thread request/header behavior has also been
+    captured and aligned, including omitting `workspaces` on later turns;
+  - the remaining work is now more about outer behavior branches than this
+    already-compared request/header path.
+- tool round-trip alignment:
+  - the Default-mode unavailable path for `request_user_input` is aligned to
+    real upstream captures;
+  - the Plan-mode happy path is also aligned at the tool/protocol layer based
+    on upstream source: it forces `isOther=true`, requires non-empty `options`,
+    and returns structured answers as a JSON string plus `success=true`;
+  - there is now a deterministic round-trip comparison helper,
+    `tests/compare_request_user_input_roundtrip.py`, built on the proxy mode in
+    `tests/fake_responses_server.py`; against the locally installed
+    `codex-cli 0.115.0`, the only remaining Plan-mode live-capture schema
+    difference is that `pycodex` includes `success=true` in
+    `function_call_output`.
+
+See `docs/ALIGNMENT.md` for more detailed notes.
+
+## Live Model Integration
+
+If this machine already has a Codex CLI configuration, `pycodex` can reuse the
+`model`, `model_provider`, `base_url`, and `env_key` from
+`~/.codex/config.toml` directly:
+
+```python
+from pycodex import ResponsesModelClient
+
+client = ResponsesModelClient.from_codex_config()
+```
+
+The current implementation uses the streaming OpenAI-compatible `/responses`
+endpoint. This path has already been validated against the local
+`~/.codex/config.toml` setup.
+
+When launched through the CLI, `pycodex` also loads `.env` from the same
+configuration directory before reading config (typically `~/.codex/.env`), so
+provider keys and similar environment variables can live there. To match
+upstream Codex, variables starting with `CODEX_` are not imported from `.env`.
+
+## pycodex CLI
+
+`pycodex` now defaults to a minimal interactive entry point. Internally it uses
+`AgentRuntime` to drive the turn submission loop and reuses
+`~/.codex/config.toml` by default:
+
+```bash
+pycodex
+pycodex "Summarize this repo in one sentence."
+printf 'Reply with exactly OK.' | pycodex
+pycodex --json "Reply with exactly OK."
+pycodex --profile model_proxy "Reply with exactly OK."
+pycodex --vllm-endpoint http://127.0.0.1:18000 "Reply with exactly OK."
+pycodex --put @127.0.0.1:5577
+pycodex --put /data/.codex/@127.0.0.1:5577
+pycodex --call SECRET-CALLID@127.0.0.1:5577 "Reply with exactly OK."
+pycodex doctor
+```
+
+Current behavior:
+
+- with no argv prompt and a TTY stdin, enter interactive mode
+- with an argv prompt or piped stdin, run a single turn
+- interactive mode supports `/exit` and `/quit`
+- interactive mode shows a compact event stream for user-visible phases such as
+  tool execution and model follow-up after tool results
+- assistant text is printed from streaming deltas directly
+- interactive mode supports `/history`, `/title`, and `/model`
+- `/model <name>` switches the model used by later turns in the current
+  interactive session; `/model` shows the current model and available choices
+- steer is enabled by default in interactive mode: normal input goes into the
+  runtime steer path, the current request stops at the next safe boundary, and
+  later steer text is appended to the next model request's `input` in order;
+  for explicit queueing, use `/queue <message>`, which prints
+  `[steer] queued: ...` and later `[steer] inserted: ...`
+- the default built-in tool subset currently exposed as local tools is:
+  `shell`, `shell_command`, `exec_command`, `write_stdin`, `exec`, `wait`,
+  `web_search`, `update_plan`, `request_user_input`, `request_permissions`,
+  `spawn_agent`, `send_input`, `resume_agent`, `wait_agent`, `close_agent`,
+  `apply_patch`, `grep_files`, `read_file`, `list_dir`, `view_image`
+- `--vllm-endpoint http://host:port` automatically launches a local
+  `responses_server` compatibility layer; when the URL path is empty it is
+  normalized to `/v1`, and `/responses` requests are still forwarded to the
+  downstream `/v1/chat/completions` endpoint. For `model_provider = "vllm"`,
+  reasoning is now preserved across this path: chat chunks with `reasoning` or
+  `reasoning_content` are translated back into Responses `reasoning` items, and
+  historical `reasoning` items are replayed into downstream assistant messages
+  via the `reasoning` field. Streaming token usage is also requested from vLLM
+  and forwarded to the final `response.completed.response.usage`
+- `pycodex doctor` checks config, `.env`, API keys, DNS, TCP/TLS, and an
+  optional live Responses API request
+
+Current primary uses:
+
+- verify provider / model / auth configuration
+- debug `ResponsesModelClient`
+- run minimal single-turn and multi-turn smoke tests
+
+`doctor` examples:
+
+```bash
+pycodex doctor
+pycodex doctor --skip-live
+pycodex doctor --json
+```
+
+## Portable Mode
+
+`Portable Mode` is the quickest way to bring your usual `pycodex` setup into a
+fresh machine, container, or debug image.
+
+Use it like this:
+
+```bash
+pycodex --put @127.0.0.1:5577
+pycodex --put /data/.codex/@127.0.0.1:5577
+```
+
+- `--put` prints a reusable `SECRET-CALLID@host:port` plus a final one-line
+  `pycodex --call ...` command
+- on the new environment or image, run that printed `--call` command directly
+- quickly restoring your usual `config.toml`, `.env`, `AGENTS.md`, and
+  `skills/` into a clean debug environment
+- keeping a new image focused on the bug you are debugging instead of spending
+  time rebuilding local Codex setup by hand
+- bootstrapping `pycodex` even when the target environment does not already
+  have a populated `~/.codex`
+- bare `--put` uses the current user's `~/.codex`
+- `--put /path/.codex/@host:port` lets you publish a different Codex home
+
+## Example
+
+```python
+import asyncio
+
+from pycodex import (
+    AgentLoop,
+    BaseTool,
+    ContextManager,
+    ResponsesModelClient,
+    ToolRegistry,
+)
+
+
+class EchoTool(BaseTool):
+    name = "echo"
+    description = "Echo the provided text."
+    input_schema = {
+        "type": "object",
+        "properties": {"text": {"type": "string"}},
+        "required": ["text"],
+    }
+
+    async def run(self, context, args):
+        del context
+        return args["text"]
+
+
+async def main() -> None:
+    model = ResponsesModelClient.from_codex_config()
+    context_manager = ContextManager.from_codex_config()
+
+    tools = ToolRegistry()
+    tools.register(EchoTool())
+
+    agent = AgentLoop(model, tools, context_manager)
+    result = await agent.run_turn(
+        ["Call the echo tool with text=hello, then tell me what it returned."]
+    )
+    print(result.output_text)
+
+
+asyncio.run(main())
+```
+
+## Alignment Checklist
+
+See `docs/ALIGNMENT.md` for more detail. This section keeps a high-level
+checklist for quick status scanning.
+
+### Tool Alignment
+
+Official upstream tools:
+
+- [x] `shell` - run shell commands in argv form.
+- [x] `shell_command` - run shell scripts in string form.
+- [x] `exec_command` - start long-running commands with a session.
+- [x] `write_stdin` - write stdin to an existing execution session or poll
+  output.
+- [x] `web_search` - expose provider-native web search capability.
+- [x] `update_plan` - update the task plan and maintain step status.
+- [x] `request_user_input` - ask the user structured questions and wait for an
+  answer.
+- [x] `request_permissions` - request extra permissions before continuing.
+- [x] `spawn_agent` - create and start a sub-agent.
+- [x] `send_input` - continue feeding input to an existing sub-agent.
+- [x] `resume_agent` - reopen a closed sub-agent.
+- [x] `wait_agent` - wait for a sub-agent to reach a terminal state.
+- [x] `close_agent` - close a sub-agent that is no longer needed.
+- [x] `apply_patch` - edit files precisely with a freeform patch.
+- [x] `grep_files` - search file contents by pattern.
+- [x] `read_file` - read file slices while preserving line-number semantics.
+- [x] `list_dir` - list directory tree slices.
+- [x] `view_image` - turn a local image into model-visible input.
+
+Upstream low-frequency / special-mode tools not yet modeled separately:
+
+- [ ] `wait_infinite` - long blocking wait for external events or later input.
+- [ ] `spawn_agents_on_csv` - create sub-agent jobs in bulk from CSV.
+- [ ] `report_agent_job_result` - report batch agent job results.
+- [ ] `js_repl` - JavaScript REPL / code-mode primary entry point.
+- [ ] `js_repl_reset` - reset `js_repl` state.
+- [ ] `artifacts` - generate or manage structured artifact outputs.
+- [ ] `list_mcp_resources` - list MCP resources.
+- [ ] `list_mcp_resource_templates` - list MCP resource templates.
+- [ ] `read_mcp_resource` - read MCP resource contents.
+- [ ] `multi_tool_use.parallel` - parallel wrapper around multiple developer
+  tool calls.
+
+Repository-specific compatibility / transition tools:
+
+- [x] `exec` - current local approximation of code mode.
+- [x] `wait` - current local approximation of code-mode waiting behavior.
+
+### Behavior Alignment
+
+- [x] `AgentLoop` / `AgentRuntime` main loop skeleton - turn loop and submission
+  queue are in place.
+- [x] non-interactive `exec` `instructions` alignment - base instructions match
+  upstream.
+- [x] non-interactive `exec` `input` alignment - prompt input matches upstream.
+- [x] developer/contextual-user message shape alignment - message/content shape
+  matches upstream.
+- [x] `AGENTS.md` + `<environment_context>` injection alignment - context
+  assembly order matches upstream.
+- [x] non-interactive `exec` tool subset alignment - the model-visible tool set
+  has converged.
+- [x] `include = ["reasoning.encrypted_content"]` - reasoning include field is
+  aligned.
+- [x] `prompt_cache_key` - request-level prompt cache key is implemented.
+- [x] `x-client-request-id` - request id header is implemented.
+- [x] `x-codex-turn-metadata` - turn id / sandbox header is implemented.
+- [x] `originator` - mode-aware originator header is implemented.
+- [x] exact `user-agent` string alignment - aligned on the non-interactive
+  `exec` path.
+- [x] field-by-field exec-mode tool schema alignment - currently reuses the
+  upstream snapshot directly through the tool layer.
+- [ ] full interactive-mode and non-`exec` behavior alignment - the non-exec
+  first-turn context is now on the `codex-tui` path, but continuous REPL
+  multi-turn behavior is not fully verified yet.
+- [ ] sandbox / approvals / compact / memory and other outer behavior alignment
+  - these systems are still in later scope.

{python_codex-0.1.0.dist-info → python_codex-0.1.2.dist-info}/RECORD

@@ -1,13 +1,15 @@
-pycodex/__init__.py,sha256=Cjeqgi3mmkmxE_xcTcPl4heS5k4UGBCG3qFGbwNm7PQ,2986
+pycodex/__init__.py,sha256=T11JU1QHEk81TchhrTAOqVkvUUiQGlesk9PNaivjPrU,3052
 pycodex/agent.py,sha256=ApIneWSqDxryf9hdmTRFL65AH4e-sn0MWuuR80951Ec,10069
-pycodex/cli.py,sha256=d3ug7fR9GeMDDe_BR37RBeUW6w5QnaFRTkGiNgvAkqA,21748
+pycodex/cli.py,sha256=ju4aF_kwbraqZ-NfoymzB6CjvvMX22afeXDvse2ykf8,24676
 pycodex/collaboration.py,sha256=XAM2enljzHMjzZVlLxbOQF0JhWgKW4qaaDfVcUdE47g,632
 pycodex/context.py,sha256=8-Eg1TE4-GVbEfW0fNZjDWhjLypK3jBlKZY1haYYVPY,23143
 pycodex/doctor.py,sha256=VN-qetM2qJCNRNTZXBMe44VSrEOu8kUXE01luLMF050,10357
 pycodex/model.py,sha256=ZqXSucpzBm0kn2XfhBdKebdwvJQH1Jc9xMqBfPwOKGM,19672
+pycodex/portable.py,sha256=Y2pY08pDiWITY0QYgH3F9YKpOe2EYtxE0qqSmrCkp_g,15260
+pycodex/portable_server.py,sha256=xhEwySCJ41WnsowXM-Db6kkmCOVM02Lmd4pbN6hZzh0,7232
 pycodex/protocol.py,sha256=8mQ7I-y9bxYueSr7d_yGj2Tw69t47OCgwvmxhwihdFw,10807
-pycodex/runtime.py,sha256=Symum2pt6QibV_a3oWm9KWku50u22tLrmXQu76hJSH0,7560
-pycodex/runtime_services.py,sha256=Ir2gM7Qf-uSy9JPc8ahL85ifkY5JPdX09y-iHS_qYo8,12374
+pycodex/runtime.py,sha256=tfEuyZmnTP625BQ0NMm-AGhjfQpXcv2EaZLtCJTnEmM,7757
+pycodex/runtime_services.py,sha256=hmdwFiOZ1DPEJ5T8vfDSLfujgGQBPrzPQkn6uX_9vZ8,12503
 pycodex/prompts/collaboration_default.md,sha256=MBTmPuMubeWfZgIeFVj49wwnwD4n_o3fVYAbgWKwu6Q,955
 pycodex/prompts/collaboration_plan.md,sha256=IzjQAA5oHJz-3FmJdOjsJ4LHq6LW1tlEYMoy09n0HKk,8777
 pycodex/prompts/default_base_instructions.md,sha256=D65mcj6bo4CDvVom-D9cbJRJVNquo0NghKt164_fRsg,20923
@@ -30,7 +32,7 @@ pycodex/tools/close_agent_tool.py,sha256=InKhe2gFWOcqE187J3XYrCckecsyAR48VeVmGdY
 pycodex/tools/code_mode_manager.py,sha256=pEczPyCq-3DpJlTtfUEpl4JAGolz8cOpI8mBc7gdrn0,18603
 pycodex/tools/exec_command_tool.py,sha256=_fWfkQLGeINb2-cniY9CWskkAPjC9hE8pfjcBKkWXAg,3459
 pycodex/tools/exec_runtime.js,sha256=ZczdhrzpSZ-qNnJDDJOe8Ap86HpzHb2FZ_vSpHszgLs,3625
-pycodex/tools/exec_tool.py,sha256=b3_HSlyA0qB9rJulSckLBXOcKS3Lw5xvsQXU-wpNpCs,1414
+pycodex/tools/exec_tool.py,sha256=xJfEpcQXpL3OX-ZzKxQ2sI781OuEqpeyPvVkkwhgZ1c,1415
 pycodex/tools/grep_files_tool.py,sha256=twsx1KsvOWh8mi-lbycAtEyh6PeLxtNzl9LzdjwgAf4,4742
 pycodex/tools/list_dir_tool.py,sha256=7S0RsE-NL04G47FmFZtzo-N-O3fPCYQFF0HrjEVuv3U,4749
 pycodex/tools/read_file_tool.py,sha256=GVamhSNEZ1F1IU_og9GgSCzV12TL5t5b1fOUlzTOQBQ,8084
@@ -41,7 +43,7 @@ pycodex/tools/send_input_tool.py,sha256=z9PR5VoFd9SF4A-ol04Op8AXQF_3YLE74C6coiTX
 pycodex/tools/shell_command_tool.py,sha256=Bbah_5HirG1BJOIiqzuMa8kNHNYVPCUvxCFa09eRU6A,3500
 pycodex/tools/shell_tool.py,sha256=BWSaEJZwfQg9Ta-ld2wqeXqavrZC7Y8qgF_vBEOxfYA,3678
 pycodex/tools/spawn_agent_tool.py,sha256=LfJlGI0Ecp9HWNLlTubyybFq-xeRNChILq9ozT7piA8,3556
-pycodex/tools/unified_exec_manager.py,sha256=dyuGfaljXTuV4_Bf5Y6OwFGj5_Kb1LW-sh9ni5mMF1Y,12602
+pycodex/tools/unified_exec_manager.py,sha256=ZEaMXmO83Iu20V4dwxAuUjy4EF5IHqHmwnTvFJh8zGc,13330
 pycodex/tools/update_plan_tool.py,sha256=l_EG39bEw5K9BIUKoSUsXYDb0W7aLn8SviKSb-bs7Os,2887
 pycodex/tools/view_image_tool.py,sha256=yB915Jd3he4RjPANdm-dYdvio24OXKhBkAsp-9WVPBg,3924
 pycodex/tools/wait_agent_tool.py,sha256=1tJ5spBtpZ_MjoMv5xmZz5WWKl7UwMqHIJ3SYKXEPZw,2596
@@ -50,11 +52,22 @@ pycodex/tools/web_search_tool.py,sha256=hq78XF6MRvmNyPFSIp5eI0eYn9ryKdKvvoIOFNU3
 pycodex/tools/write_stdin_tool.py,sha256=DghlwPJnAqDoRBYyh1zeXRsfTXoQUdLJ8JQfrdE4RLs,2542
 pycodex/utils/__init__.py,sha256=Hj_0a7RhkAblWkaHyFhpi0cs2nSjJ1NdavbkBgEHieY,1024
 pycodex/utils/dotenv.py,sha256=sOpu6PA1VrsPZK13ynh3nZg3-u9pdiCXkW648v3pwZQ,1789
-pycodex/utils/get_env.py,sha256=3l_KA8JCWW9mrKE9FiV2mTx10-e5MUbxaU8jbn3JaRs,6265
+pycodex/utils/get_env.py,sha256=Ehh0mVPhkDlPMd1WXhrz1UqjPCePg8YfZH7zrtu1EOQ,6894
 pycodex/utils/random_ids.py,sha256=vOEVgkwKeQXaHoEVU7IfsPPjKUABkGIeQ7lu9MZctU8,413
 pycodex/utils/visualize.py,sha256=fK79pTfOwMmRrQujAosGt0nGyyJjpz0GfpWY8BkK91c,35369
-python_codex-0.1.0.dist-info/METADATA,sha256=27msS6W8ibM1JsRSE7zMXpVBAvMxdFkBIPlehjwjtAc,11720
-python_codex-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_codex-0.1.0.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
-python_codex-0.1.0.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
-python_codex-0.1.0.dist-info/RECORD,,
+responses_server/__init__.py,sha256=3yPv_zeGT7P11tTnmj5kXktISLNsNW-02MUnnbiZcb0,394
+responses_server/__main__.py,sha256=9SRp-Yw7ShGxc6DhSIXcDLKgGEdAVm3oBZ59rBOPjT0,62
+responses_server/app.py,sha256=VJSceVaXxbPLu9KGafLIt5fiGvxrqVTkWeOg81O5-FQ,7016
+responses_server/config.py,sha256=XAJmvvLiCYN5jCUcP_6uZyoW79OzxigMbik8X-ZTdKE,2174
+responses_server/payload_processors.py,sha256=_3Sl7HLG00BgN_TKcvT3_3drCDAq1MAeK1HxbRXNta4,3019
+responses_server/server.py,sha256=Q-gjtHzb7K1Guex10G38PgH9hxqJgdzYnBV7Ycy9L7Y,2049
+responses_server/session_store.py,sha256=oP3aFHsGmEMoXuUcxNh6B4vzp6KwaeRdLzM-3AOwM98,1078
+responses_server/stream_router.py,sha256=uYPjrlBUnNqiuQQ91eKmwDfNF6e5NYDtf5C8BdPRPRc,29536
+responses_server/tools/__init__.py,sha256=ivsBSEy0SBUhY-Uea5v1XMLXShkwHdCVl0id-1FwdZg,150
+responses_server/tools/custom_adapter.py,sha256=ivROeI8D9B1saS7skGLXnwF7fbsjAmEVSbeMceYno4E,8238
+responses_server/tools/web_search.py,sha256=HR9E5uMxWU07khsaIO9zvdg1GCCrWNy73263zfMaxsw,8565
+python_codex-0.1.2.dist-info/METADATA,sha256=wy8bEToZxyf9Cio-upoAS8XmC3MscN8wiKTVXp9MW9g,13969
+python_codex-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_codex-0.1.2.dist-info/entry_points.txt,sha256=sNUVakoVuTrzJH505ZgRTQxmtRRPUHV_EH0i6EbYTyM,45
+python_codex-0.1.2.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
+python_codex-0.1.2.dist-info/RECORD,,

responses_server/__init__.py

@@ -0,0 +1,17 @@
+from .app import (
+    ManagedResponseServer,
+    launch_chat_completion_compat_server,
+    run_server,
+)
+from .config import CompatServerConfig
+from .server import ResponseServer
+from .stream_router import StreamRouter
+
+__all__ = [
+    "CompatServerConfig",
+    "ManagedResponseServer",
+    "ResponseServer",
+    "launch_chat_completion_compat_server",
+    "run_server",
+    "StreamRouter",
+]

responses_server/__main__.py

@@ -0,0 +1,5 @@
+from .app import main
+
+
+if __name__ == "__main__":
+    main()

responses_server/app.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import replace
+import json
+import socket
+import threading
+import time
+from typing import Iterator
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+import uvicorn
+
+from .config import CompatServerConfig
+from .server import ResponseServer
+from .stream_router import OutcommingChatError, UnsupportedIncommingFeature
+
+
+def _format_sse_event(event_name: str, payload: dict[str, object]) -> bytes:
+    data = json.dumps(payload, ensure_ascii=False)
+    return f"event: {event_name}\ndata: {data}\n\n".encode("utf-8")
+
+
+def _stream_events(response_server: ResponseServer, request_body: dict[str, object], request_headers: dict[str, str]) -> Iterator[bytes]:
+    try:
+        event_iter = response_server.start_response_stream(request_body, request_headers)
+        for event_name, payload in event_iter:
+            yield _format_sse_event(event_name, payload)
+    except OutcommingChatError as exc:
+        yield _format_sse_event(
+            "response.failed",
+            {
+                "type": "response.failed",
+                "response": {
+                    "error": {
+                        "message": str(exc),
+                    }
+                },
+            },
+        )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="python -m responses_server",
+        description=(
+            "Standalone localhost `/v1/responses` server that translates the "
+            "Codex/Responses subset onto an outcomming `/v1/chat/completions` backend."
+        ),
+    )
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8001)
+    parser.add_argument("--outcomming-base-url", required=True)
+    parser.add_argument("--outcomming-api-key-env", default=None)
+    parser.add_argument("--model-provider", default=None)
+    parser.add_argument("--timeout-seconds", type=float, default=120.0)
+    return parser
+
+
+def run_server(config: CompatServerConfig) -> None:
+    uvicorn.run(
+        ManagedResponseServer.build_app(config),
+        host=config.host,
+        port=config.port,
+        log_level="info",
+    )
+
+
+def launch_chat_completion_compat_server(
+    base_url: str,
+    api_key_env: str | None = None,
+    model_provider: str | None = None,
+):
+    config = CompatServerConfig.from_base_url(
+        base_url,
+        api_key_env,
+        model_provider=model_provider,
+    )
+    server = ManagedResponseServer(config)
+    server.start()
+    return server
+
+
+class ManagedResponseServer:
+    @staticmethod
+    def build_app(
+        config: CompatServerConfig,
+        session_store=None,
+        stream_router=None,
+    ) -> FastAPI:
+        response_server = ResponseServer(
+            config,
+            session_store=session_store,
+            stream_router=stream_router,
+        )
+        app = FastAPI(title="ResponsesCompat", version="0.1.0")
+        app.state.response_server = response_server
+
+        @app.get("/health")
+        @app.get("/healthz")
+        async def health() -> dict[str, bool]:
+            return {"ok": True}
+
+        @app.get("/models")
+        @app.get("/v1/models")
+        async def list_models():
+            try:
+                return response_server.list_models()
+            except OutcommingChatError as exc:
+                return JSONResponse(
+                    {"error": {"message": str(exc)}},
+                    status_code=502,
+                )
+
+        @app.post("/responses")
+        @app.post("/v1/responses")
+        async def responses(request: Request):
+            try:
+                request_body = await request.json()
+            except Exception as exc:
+                return JSONResponse(
+                    {"error": {"message": f"invalid JSON body: {exc}"}},
+                    status_code=400,
+                )
+            if not isinstance(request_body, dict):
+                return JSONResponse(
+                    {"error": {"message": "request body must be a JSON object"}},
+                    status_code=400,
+                )
+
+            request_headers = {
+                str(key).lower(): str(value)
+                for key, value in request.headers.items()
+            }
+            try:
+                response_server.stream_router.validate_incomming_request(request_body)
+            except UnsupportedIncommingFeature as exc:
+                return JSONResponse(
+                    {"error": {"message": str(exc)}},
+                    status_code=501,
+                )
+
+            return StreamingResponse(
+                _stream_events(response_server, request_body, request_headers),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "close",
+                },
+            )
+
+        return app
+
+    def __init__(self, config: CompatServerConfig) -> None:
+        port = config.port or _reserve_free_port()
+        self._config = replace(config, port=port)
+        self._app = self.build_app(self._config)
+        self._uvicorn_config = uvicorn.Config(
+            self._app,
+            host=self._config.host,
+            port=self._config.port,
+            log_level="error",
+            access_log=False,
+        )
+        self._server = uvicorn.Server(self._uvicorn_config)
+        self._thread = threading.Thread(target=self._server.run, daemon=True)
+
+    @property
+    def base_url(self) -> str:
+        return f"http://{self._config.host}:{self._config.port}/v1"
+
+    def start(self, timeout_seconds: float = 10.0) -> None:
+        self._thread.start()
+        deadline = time.time() + timeout_seconds
+        while not self._server.started:
+            if time.time() >= deadline:
+                raise RuntimeError(
+                    "timed out waiting for managed responses server to start"
+                )
+            time.sleep(0.01)
+
+    def stop(self, timeout_seconds: float = 5.0) -> None:
+        self._server.should_exit = True
+        self._thread.join(timeout=timeout_seconds)
+        if self._thread.is_alive():
+            raise RuntimeError(
+                "timed out waiting for managed responses server to stop"
+            )
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    run_server(
+        CompatServerConfig(
+            host=args.host,
+            port=args.port,
+            outcomming_base_url=args.outcomming_base_url,
+            outcomming_api_key_env=args.outcomming_api_key_env,
+            model_provider=args.model_provider,
+            timeout_seconds=args.timeout_seconds,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
+
+
+def _reserve_free_port() -> int:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        sock.bind(("127.0.0.1", 0))
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        return int(sock.getsockname()[1])
+    finally:
+        sock.close()