45 Commits

• [app-server] update doc with codex error info (#6941)

  Document new codex error info. Also fixed the name from
  `codex_error_code` to `codex_error_info`.

  Celia Chen · 2025-11-21 01:02:37 +00:00
  7e2165f394
• [app-server & core] introduce new codex error code and v2 app-server error events (#6938)

  This PR does two things:
  1. populate a new `codex_error_code` protocol in error events sent from
  core to client;
  2. old v1 core events `codex/event/stream_error` and `codex/event/error`
  will now both become `error`. We also show codex error code for
  turncompleted -> error status.
  
  new events in app server test:
  ```
  < {
  <   "method": "codex/event/stream_error",
  <   "params": {
  <     "conversationId": "019aa34c-0c14-70e0-9706-98520a760d67",
  <     "id": "0",
  <     "msg": {
  <       "codex_error_code": {
  <         "response_stream_disconnected": {
  <           "http_status_code": 401
  <         }
  <       },
  <       "message": "Reconnecting... 2/5",
  <       "type": "stream_error"
  <     }
  <   }
  < }
  
   {
  <   "method": "error",
  <   "params": {
  <     "error": {
  <       "codexErrorCode": {
  <         "responseStreamDisconnected": {
  <           "httpStatusCode": 401
  <         }
  <       },
  <       "message": "Reconnecting... 2/5"
  <     }
  <   }
  < }
  
  < {
  <   "method": "turn/completed",
  <   "params": {
  <     "turn": {
  <       "error": {
  <         "codexErrorCode": {
  <           "responseTooManyFailedAttempts": {
  <             "httpStatusCode": 401
  <           }
  <         },
  <         "message": "exceeded retry limit, last status: 401 Unauthorized, request id: 9a1b495a1a97ed3e-SJC"
  <       },
  <       "id": "0",
  <       "items": [],
  <       "status": "failed"
  <     }
  <   }
  < }
  ```

  Celia Chen · 2025-11-20 23:06:55 +00:00
  9bce050385
• Revert "[core] add optional status_code to error events (#6865)" (#6955)

  This reverts commit c2ec477d93.
  
  # External (non-OpenAI) Pull Request Requirements
  
  Before opening this Pull Request, please read the dedicated
  "Contributing" markdown file or your PR may be closed:
  https://github.com/openai/codex/blob/main/docs/contributing.md
  
  If your PR conforms to our contribution guidelines, replace this text
  with a detailed and high quality description of your changes.
  
  Include a link to a bug report or enhancement request.

  Celia Chen · 2025-11-20 01:26:14 +00:00
  72a1453ac5
• [core] add optional status_code to error events (#6865)

  We want to better uncover error status code for clients. Add an optional
  status_code to error events (thread error, error, stream error) so app
  server could uncover the status code from the client side later.
  
  in event log:
  ```
  < {
  <   "method": "codex/event/stream_error",
  <   "params": {
  <     "conversationId": "019a9a32-f576-7292-9711-8e57e8063536",
  <     "id": "0",
  <     "msg": {
  <       "message": "Reconnecting... 5/5",
  <       "status_code": 401,
  <       "type": "stream_error"
  <     }
  <   }
  < }
  < {
  <   "method": "codex/event/error",
  <   "params": {
  <     "conversationId": "019a9a32-f576-7292-9711-8e57e8063536",
  <     "id": "0",
  <     "msg": {
  <       "message": "exceeded retry limit, last status: 401 Unauthorized, request id: 9a0cb03a485067f7-SJC",
  <       "status_code": 401,
  <       "type": "error"
  <     }
  <   }
  < }
  ```

  Celia Chen · 2025-11-19 19:51:21 +00:00
  c2ec477d93
• storing credits (#6858)

  Expand the rate-limit cache/TUI: store credit snapshots alongside
  primary and secondary windows, render “Credits” when the backend reports
  they exist (unlimited vs rounded integer balances)

  zhao-oai · 2025-11-19 10:49:35 -08:00
  72af589398
• Add the utility to truncate by tokens (#6746)

  - This PR is to make it on path for truncating by tokens. This path will
  be initially used by unified exec and context manager (responsible for
  MCP calls mainly).
  - We are exposing new config `calls_output_max_tokens`
  - Use `tokens` as the main budget unit but truncate based on the model
  family by Introducing `TruncationPolicy`.
  - Introduce `truncate_text` as a router for truncation based on the
  mode.
  
  In next PRs:
  - remove truncate_with_line_bytes_budget
  - Add the ability to the model to override the token budget.

  Ahmed Ibrahim · 2025-11-18 11:36:23 -08:00
  3de8790714
• core: replace Cloudflare 403 HTML with friendly message (#6252)

  ### Motivation
  
  When Codex is launched from a region where Cloudflare blocks access (for
  example, Russia), the CLI currently dumps Cloudflare’s entire HTML error
  page. This isn’t actionable and makes it hard for users to understand
  what happened. We want to detect the Cloudflare block and show a
  concise, user-friendly explanation instead.
  
  ### What Changed
  
  - Added CLOUDFLARE_BLOCKED_MESSAGE and a friendly_message() helper to
  UnexpectedResponseError. Whenever we see a 403 whose body contains the
  Cloudflare block notice, we now emit a single-line message (Access
  blocked by Cloudflare…) while preserving the HTTP status and request id.
  All other responses keep the original behaviour.
  - Added two focused unit tests:
  - unexpected_status_cloudflare_html_is_simplified ensures the Cloudflare
  HTML case yields the friendly message.
  - unexpected_status_non_html_is_unchanged confirms plain-text 403s still
  return the raw body.
  
  ### Testing
  
  - cargo build -p codex-cli
  - cargo test -p codex-core
  - just fix -p codex-core
  - cargo test --all-features
  
  ---------
  
  Co-authored-by: Eric Traut <etraut@openai.com>

  Alexander Smirnov · 2025-11-07 15:55:16 -08:00
  183fc8e01a
• Don't retry "insufficient_quota" errors (#6340)

  This PR makes an "insufficient quota" error fatal so we don't attempt to
  retry it multiple times in the agent loop.
  
  We have multiple bug reports from users about intermittent retry
  behaviors, and this could explain some of them. With this change, we'll
  eliminate the retries and surface a clear error message.
  
  The PR is a nearly identical copy of [this
  PR](https://github.com/openai/codex/pull/4837) contributed by
  @abimaelmartell. The original PR has gone stale. Rather than wait for
  the contributor to resolve merge conflicts, I wanted to get this change
  in.

  Eric Traut · 2025-11-06 15:12:01 -08:00
  0c647bc566
• Improved token refresh handling to address "Re-connecting" behavior (#6231)

  Currently, when the access token expires, we attempt to use the refresh
  token to acquire a new access token. This works most of the time.
  However, there are situations where the refresh token is expired,
  exhausted (already used to perform a refresh), or revoked. In those
  cases, the current logic treats the error as transient and attempts to
  retry it repeatedly.
  
  This PR changes the token refresh logic to differentiate between
  permanent and transient errors. It also changes callers to treat the
  permanent errors as fatal rather than retrying them. And it provides
  better error messages to users so they understand how to address the
  problem. These error messages should also help us further understand why
  we're seeing examples of refresh token exhaustion.
  
  Here is the error message in the CLI. The same text appears within the
  extension.
  
  <img width="863" height="38" alt="image"
  src="https://github.com/user-attachments/assets/7ffc0d08-ebf0-4900-b9a9-265064202f4f"
  />
  
  I also correct the spelling of "Re-connecting", which shouldn't have a
  hyphen in it.
  
  Testing: I manually tested these code paths by adding temporary code to
  programmatically cause my refresh token to be exhausted (by calling the
  token refresh endpoint in a tight loop more than 50 times). I then
  simulated an access token expiration, which caused the token refresh
  logic to be invoked. I confirmed that the updated logic properly handled
  the error condition.
  
  Note: We earlier discussed the idea of forcefully logging out the user
  at the point where token refresh failed. I made several attempts to do
  this, and all of them resulted in a bad UX. It's important to surface
  this error to users in a way that explains the problem and tells them
  that they need to log in again. We also previously discussed deleting
  the auth.json file when this condition is detected. That also creates
  problems because it effectively changes the auth status from logged in
  to logged out, and this causes odd failures and inconsistent UX. I think
  it's therefore better not to delete auth.json in this case. If the user
  closes the CLI or VSCE and starts it again, we properly detect that the
  access token is expired and the refresh token is "dead", and we force
  the user to go through the login flow at that time.
  
  This should address aspects of #6191, #5679, and #5505

  Eric Traut · 2025-11-05 10:51:57 -08:00
  c4ebe4b078
• fix: improve usage URLs in status card and snapshots (#6111)

  Hi OpenAI Codex team, currently "Visit chatgpt.com/codex/settings/usage
  for up-to-date information on rate limits and credits" message in status
  card and error messages. For now, without the "https://" prefix, the
  link cannot be clicked directly from most terminals or chat interfaces.
  
  <img width="636" height="127" alt="Screenshot 2025-11-02 at 22 47 06"
  src="https://github.com/user-attachments/assets/5ea11e8b-fb74-451c-85dc-f4d492b2678b"
  />
  
  ---
  
  The fix is intent to improve this issue:
  
  - It makes the link clickable in terminals that support it, hence better
  accessibility
  - It follows standard URL formatting practices
  - It maintains consistency with other links in the application (like the
  existing "https://openai.com/chatgpt/pricing" links)
  
  Thank you!

  Vinh Nguyen · 2025-11-02 21:44:59 -08:00
  a1ee10b438
• rate limit errors now provide absolute time (#6000)
  zhao-oai · 2025-10-30 20:33:25 -04:00
  dcf73970d2
• asdf (#5940)

  .

  zhao-oai · 2025-10-30 01:10:41 +00:00
  b34efde2f3
• Improve feedback (#5661)

  <img width="1099" height="153" alt="image"
  src="https://github.com/user-attachments/assets/2c901884-8baf-4b1b-b2c4-bcb61ff42be8"
  />
  
  <img width="1082" height="125" alt="image"
  src="https://github.com/user-attachments/assets/6336e6c9-9ace-46df-a383-a807ceffa524"
  />
  
  <img width="1102" height="103" alt="image"
  src="https://github.com/user-attachments/assets/78883682-7e44-4fa3-9e04-57f7df4766fd"
  />

  Ahmed Ibrahim · 2025-10-24 22:28:14 -07:00
  71f838389b
• Handle cancelling/aborting while processing a turn (#5543)

  Currently we collect all all turn items in a vector, then we add it to
  the history on success. This result in losing those items on errors
  including aborting `ctrl+c`.
  
  This PR:
  - Adds the ability for the tool call to handle cancellation
  - bubble the turn items up to where we are recording this info
  
  Admittedly, this logic is an ad-hoc logic that doesn't handle a lot of
  error edge cases. The right thing to do is recording to the history on
  the spot as `items`/`tool calls output` come. However, this isn't
  possible because of having different `task_kind` that has different
  `conversation_histories`. The `try_run_turn` has no idea what thread are
  we using. We cannot also pass an `arc` to the `conversation_histories`
  because it's a private element of `state`.
  
  That's said, `abort` is the most common case and we should cover it
  until we remove `task kind`

  Ahmed Ibrahim · 2025-10-23 08:47:10 -07:00
  f59978ed3d
• Use int timestamps for rate limit reset_at (#5383)

  The backend will be returning unix timestamps (seconds since epoch)
  instead of RFC 3339 strings. This will make it more ergonomic for
  developers to integrate against - no string parsing.

  Owen Lin · 2025-10-20 12:26:46 -07:00
  c84fc83222
• fix: switch rate limit reset handling to timestamps (#5304)

  This change ensures that we store the absolute time instead of relative
  offsets of when the primary and secondary rate limits will reset.
  Previously these got recalculated relative to current time, which leads
  to the displayed reset times to change over time, including after doing
  a codex resume.
  
  For previously changed sessions, this will cause the reset times to not
  show due to this being a breaking change:
  <img width="524" height="55" alt="Screenshot 2025-10-17 at 5 14 18 PM"
  src="https://github.com/user-attachments/assets/53ebd43e-da25-4fef-9c47-94a529d40265"
  />
  
  Fixes https://github.com/openai/codex/issues/4761

  Thibault Sottiaux · 2025-10-17 17:39:37 -07:00
  0e08dd6055
• Support graceful agent interruption (#5287)
  pakrym-oai · 2025-10-17 18:52:57 +00:00
  c03e31ecf5
• Improve error decoding response body error (#5263)

  Split Reqwest error into separate error:
  1. One for streaming response
  2. One for initial connection failing
  
  Include request_id where possible.
  
  <img width="1791" height="116" alt="image"
  src="https://github.com/user-attachments/assets/549aa330-acfa-496a-9898-77fa58436316"
  />

  pakrym-oai · 2025-10-16 14:51:42 -07:00
  ed5b0bfeb3
• bug: sandbox denied error logs (#4874)

  Check on STDOUT / STDERR or aggregated output for some logs when sanbox
  is denied

  jif-oai · 2025-10-09 16:01:01 +00:00
  ca6a0358de
• Surface context window error to the client (#4675)

  In the past, we were treating `input exceeded context window` as a
  streaming error and retrying on it. Retrying on it has no point because
  it won't change the behavior. In this PR, we surface the error to the
  client without retry and also send a token count event to indicate that
  the context window is full.
  
  <img width="650" height="125" alt="image"
  src="https://github.com/user-attachments/assets/c26b1213-4c27-4bfc-90f4-51a270a3efd5"
  />

  Ahmed Ibrahim · 2025-10-05 01:40:06 +00:00
  90ef94d3b3
• chore: refactor tool handling (#4510)

  # Tool System Refactor
  
  - Centralizes tool definitions and execution in `core/src/tools/*`:
  specs (`spec.rs`), handlers (`handlers/*`), router (`router.rs`),
  registry/dispatch (`registry.rs`), and shared context (`context.rs`).
  One registry now builds the model-visible tool list and binds handlers.
  - Router converts model responses to tool calls; Registry dispatches
  with consistent telemetry via `codex-rs/otel` and unified error
  handling. Function, Local Shell, MCP, and experimental `unified_exec`
  all flow through this path; legacy shell aliases still work.
  - Rationale: reduce per‑tool boilerplate, keep spec/handler in sync, and
  make adding tools predictable and testable.
  
  Example: `read_file`
  - Spec: `core/src/tools/spec.rs` (see `create_read_file_tool`,
  registered by `build_specs`).
  - Handler: `core/src/tools/handlers/read_file.rs` (absolute `file_path`,
  1‑indexed `offset`, `limit`, `L#: ` prefixes, safe truncation).
  - E2E test: `core/tests/suite/read_file.rs` validates the tool returns
  the requested lines.
  
  ## Next steps:
  - Decompose `handle_container_exec_with_params` 
  - Add parallel tool calls

  jif-oai · 2025-10-03 13:21:06 +01:00
  33d3ecbccc
• Include request ID in the error message (#4572)

  To help with issue debugging
  <img width="1414" height="253" alt="image"
  src="https://github.com/user-attachments/assets/254732df-44ac-4252-997a-6c5e0927355b"
  />

  pakrym-oai · 2025-10-01 15:36:04 -07:00
  e899ae7d8a
• fix: remove mcp-types from app server protocol (#4537)

  We continue the separation between `codex app-server` and `codex
  mcp-server`.
  
  In particular, we introduce a new crate, `codex-app-server-protocol`,
  and migrate `codex-rs/protocol/src/mcp_protocol.rs` into it, renaming it
  `codex-rs/app-server-protocol/src/protocol.rs`.
  
  Because `ConversationId` was defined in `mcp_protocol.rs`, we move it
  into its own file, `codex-rs/protocol/src/conversation_id.rs`, and
  because it is referenced in a ton of places, we have to touch a lot of
  files as part of this PR.
  
  We also decide to get away from proper JSON-RPC 2.0 semantics, so we
  also introduce `codex-rs/app-server-protocol/src/jsonrpc_lite.rs`, which
  is basically the same `JSONRPCMessage` type defined in `mcp-types`
  except with all of the `"jsonrpc": "2.0"` removed.
  
  Getting rid of `"jsonrpc": "2.0"` makes our serialization logic
  considerably simpler, as we can lean heavier on serde to serialize
  directly into the wire format that we use now.

  Michael Bolin · 2025-10-01 02:16:26 +00:00
  5881c0d6d4
• Fix error message (#4204)

  Co-authored-by: Ahmed Ibrahim <aibrahim@openai.com>

  pakrym-oai · 2025-09-25 11:10:40 -07:00
  acc2b63dfb
• Add Reset in for rate limits (#4111)

  - Parse the headers
  - Reorganize the struct because it's getting too long
  - show the resets at in the tui
  
  <img width="324" height="79" alt="image"
  src="https://github.com/user-attachments/assets/ca15cd48-f112-4556-91ab-1e3a9bc4683d"
  />

  Ahmed Ibrahim · 2025-09-24 15:31:08 +00:00
  cb96f4f596
• Send limits when getting rate limited (#4102)

  Users need visibility on rate limits when they are rate limited.

  Ahmed Ibrahim · 2025-09-23 22:56:34 +00:00
  8227a5ba1b
• Add exec output-schema parameter (#4079)

  Adds structured output to `exec` via the `--structured-output`
  parameter.

  pakrym-oai · 2025-09-23 13:59:16 -07:00
  fdb8dadcae
• Include command output when sending timeout to model (#3576)

  Being able to see the output helps the model decide how to handle the
  timeout.

  pakrym-oai · 2025-09-14 14:38:26 -07:00
  863d9c237e
• Use PlanType enum when formatting usage-limit CTA (#3495)

  - Started using Play type struct
  - Added CTA for team/business 
  - Refactored a bit to unify the logic

  Ahmed Ibrahim · 2025-09-11 22:01:25 +00:00
  44587c2443
• Use ConversationId instead of raw Uuids (#3282)

  We're trying to migrate from `session_id: Uuid` to `conversation_id:
  ConversationId`. Not only does this give us more type safety but it
  unifies our terminology across Codex and with the implementation of
  session resuming, a conversation (which can span multiple sessions) is
  more appropriate.
  
  I started this impl on https://github.com/openai/codex/pull/3219 as part
  of getting resume working in the extension but it's big enough that it
  should be broken out.

  Gabriel Peal · 2025-09-07 23:22:25 -04:00
  c8fab51372
• chore: require uninlined_format_args from clippy (#2845)

  - added `uninlined_format_args` to `[workspace.lints.clippy]` in the
  `Cargo.toml` for the workspace
  - ran `cargo clippy --tests --fix`
  - ran `just fmt`

  Michael Bolin · 2025-08-28 11:25:23 -07:00
  74d2741729
• Improved user message for rate-limit errors (#2695)

  This PR improves the error message presented to the user when logged in
  with ChatGPT and a rate-limit error occurs. In particular, it provides
  the user with information about when the rate limit will be reset. It
  removes older code that attempted to do the same but relied on parsing
  of error messages that are not generated by the ChatGPT endpoint. The
  new code uses newly-added error fields.

  Eric Traut · 2025-08-25 21:42:10 -07:00
  ab9250e714
• do not show timeouts as "sandbox error"s (#2587)

  🙅🫸
  ```
  ✗ Failed (exit -1)
    └ 🧪 cargo test --all-features -q
      sandbox error: command timed out
  ```
  
  😌👉
  ```
  ✗ Failed (exit -1)
    └ 🧪 cargo test --all-features -q
      error: command timed out
  ```

  Jeremy Rose · 2025-08-25 17:52:23 -07:00
  17e5077507
• Wait for requested delay in rate limit errors (#2266)

  Fixes: https://github.com/openai/codex/issues/2131
  
  Response doesn't have the delay in a separate field (yet) so parse the
  message.

  pakrym-oai · 2025-08-13 15:43:54 -07:00
  41eb59a07d
• chore: introduce ConversationManager as a clearinghouse for all conversations (#2240)

  This PR does two things because after I got deep into the first one I
  started pulling on the thread to the second:
  
  - Makes `ConversationManager` the place where all in-memory
  conversations are created and stored. Previously, `MessageProcessor` in
  the `codex-mcp-server` crate was doing this via its `session_map`, but
  this is something that should be done in `codex-core`.
  - It unwinds the `ctrl_c: tokio::sync::Notify` that was threaded
  throughout our code. I think this made sense at one time, but now that
  we handle Ctrl-C within the TUI and have a proper `Op::Interrupt` event,
  I don't think this was quite right, so I removed it. For `codex exec`
  and `codex proto`, we now use `tokio::signal::ctrl_c()` directly, but we
  no longer make `Notify` a field of `Codex` or `CodexConversation`.
  
  Changes of note:
  
  - Adds the files `conversation_manager.rs` and `codex_conversation.rs`
  to `codex-core`.
  - `Codex` and `CodexSpawnOk` are no longer exported from `codex-core`:
  other crates must use `CodexConversation` instead (which is created via
  `ConversationManager`).
  - `core/src/codex_wrapper.rs` has been deleted in favor of
  `ConversationManager`.
  - `ConversationManager::new_conversation()` returns `NewConversation`,
  which is in line with the `new_conversation` tool we want to add to the
  MCP server. Note `NewConversation` includes `SessionConfiguredEvent`, so
  we eliminate checks in cases like `codex-rs/core/tests/client.rs` to
  verify `SessionConfiguredEvent` is the first event because that is now
  internal to `ConversationManager`.
  - Quite a bit of code was deleted from
  `codex-rs/mcp-server/src/message_processor.rs` since it no longer has to
  manage multiple conversations itself: it goes through
  `ConversationManager` instead.
  - `core/tests/live_agent.rs` has been deleted because I had to update a
  bunch of tests and all the tests in here were ignored, and I don't think
  anyone ever ran them, so this was just technical debt, at this point.
  - Removed `notify_on_sigint()` from `util.rs` (and in a follow-up, I
  hope to refactor the blandly-named `util.rs` into more descriptive
  files).
  - In general, I started replacing local variables named `codex` as
  `conversation`, where appropriate, though admittedly I didn't do it
  through all the integration tests because that would have added a lot of
  noise to this PR.
  
  
  
  
  ---
  [//]: # (BEGIN SAPLING FOOTER)
  Stack created with [Sapling](https://sapling-scm.com). Best reviewed
  with [ReviewStack](https://reviewstack.dev/openai/codex/pull/2240).
  * #2264
  * #2263
  * __->__ #2240

  Michael Bolin · 2025-08-13 13:38:18 -07:00
  08ed618f72
• Fix usage limit banner grammar (#2018)

  ## Summary
  - fix typo in usage limit banner text
  - update error message tests
  
  ## Testing
  - `just fmt`
  - `RUSTC_BOOTSTRAP=1 just fix` *(fails: `let` expressions in this
  position are unstable)*
  - `RUSTC_BOOTSTRAP=1 cargo test --all-features` *(fails: `let`
  expressions in this position are unstable)*
  
  ------
  https://chatgpt.com/codex/tasks/task_i_689610fc1fe4832081bdd1118779b60b

  pakrym-oai · 2025-08-08 08:50:44 -07:00
  307d9957fa
• Remove part of the error message (#1983)
  pakrym-oai · 2025-08-08 02:01:53 +00:00
  431c9299d4
• Adjust error messages (#1969)

  <img width="1378" height="285" alt="image"
  src="https://github.com/user-attachments/assets/f0283378-f839-4a1f-8331-909694a04b1f"
  />

  pakrym-oai · 2025-08-07 18:24:34 -07:00
  fa0051190b
• Add capacity error (#1947)
  pakrym-oai · 2025-08-07 10:46:43 -07:00
  f23c3066c8
• Better usage errors (#1941)

  <img width="771" height="279" alt="image"
  src="https://github.com/user-attachments/assets/e56f967f-bcd7-49f7-8a94-3d88df68b65a"
  />

  pakrym-oai · 2025-08-07 09:46:13 -07:00
  62ed5907f9
• Ensure exec command end always emitted (#1908)

  ## Summary
  - defer ExecCommandEnd emission until after sandbox resolution
  - make sandbox error handler return final exec output and response
  - align sandbox error stderr with response content and rename to
  `final_output`
  - replace unstable `let` chains in client command header logic
  
  ## Testing
  - `just fmt`
  - `just fix`
  - `cargo test --all-features` *(fails: NotPresent in
  core/tests/client.rs)*
  
  ------
  https://chatgpt.com/codex/tasks/task_i_6893e63b0c408321a8e1ff2a052c4c51

  aibrahim-oai · 2025-08-07 06:25:56 +00:00
  f15e0fe1df
• fix: overhaul how we spawn commands under seccomp/landlock on Linux (#1086)

  Historically, we spawned the Seatbelt and Landlock sandboxes in
  substantially different ways:
  
  For **Seatbelt**, we would run `/usr/bin/sandbox-exec` with our policy
  specified as an arg followed by the original command:
  
  
  https://github.com/openai/codex/blob/d1de7bb383552e8fadd94be79d65d188e00fd562/codex-rs/core/src/exec.rs#L147-L219
  
  For **Landlock/Seccomp**, we would do
  `tokio::runtime::Builder::new_current_thread()`, _invoke
  Landlock/Seccomp APIs to modify the permissions of that new thread_, and
  then spawn the command:
  
  
  https://github.com/openai/codex/blob/d1de7bb383552e8fadd94be79d65d188e00fd562/codex-rs/core/src/exec_linux.rs#L28-L49
  
  While it is neat that Landlock/Seccomp supports applying a policy to
  only one thread without having to apply it to the entire process, it
  requires us to maintain two different codepaths and is a bit harder to
  reason about. The tipping point was
  https://github.com/openai/codex/pull/1061, in which we had to start
  building up the `env` in an unexpected way for the existing
  Landlock/Seccomp approach to continue to work.
  
  This PR overhauls things so that we do similar things for Mac and Linux.
  It turned out that we were already building our own "helper binary"
  comparable to Mac's `sandbox-exec` as part of the `cli` crate:
  
  
  https://github.com/openai/codex/blob/d1de7bb383552e8fadd94be79d65d188e00fd562/codex-rs/cli/Cargo.toml#L10-L12
  
  We originally created this to build a small binary to include with the
  Node.js version of the Codex CLI to provide support for Linux
  sandboxing.
  
  Though the sticky bit is that, at this point, we still want to deploy
  the Rust version of Codex as a single, standalone binary rather than a
  CLI and a supporting sandboxing binary. To satisfy this goal, we use
  "the arg0 trick," in which we:
  
  * use `std::env::current_exe()` to get the path to the CLI that is
  currently running
  * use the CLI as the `program` for the `Command`
  * set `"codex-linux-sandbox"` as arg0 for the `Command`
  
  A CLI that supports sandboxing should check arg0 at the start of the
  program. If it is `"codex-linux-sandbox"`, it must invoke
  `codex_linux_sandbox::run_main()`, which runs the CLI as if it were
  `codex-linux-sandbox`. When acting as `codex-linux-sandbox`, we make the
  appropriate Landlock/Seccomp API calls and then use `execvp(3)` to spawn
  the original command, so do _replace_ the process rather than spawn a
  subprocess. Incidentally, we do this before starting the Tokio runtime,
  so the process should only have one thread when `execvp(3)` is called.
  
  Because the `core` crate that needs to spawn the Linux sandboxing is not
  a CLI in its own right, this means that every CLI that includes `core`
  and relies on this behavior has to (1) implement it and (2) provide the
  path to the sandboxing executable. While the path is almost always
  `std::env::current_exe()`, we needed to make this configurable for
  integration tests, so `Config` now has a `codex_linux_sandbox_exe:
  Option<PathBuf>` property to facilitate threading this through,
  introduced in https://github.com/openai/codex/pull/1089.
  
  This common pattern is now captured in
  `codex_linux_sandbox::run_with_sandbox()` and all of the `main.rs`
  functions that should use it have been updated as part of this PR.
  
  The `codex-linux-sandbox` crate added to the Cargo workspace as part of
  this PR now has the bulk of the Landlock/Seccomp logic, which makes
  `core` a bit simpler. Indeed, `core/src/exec_linux.rs` and
  `core/src/landlock.rs` were removed/ported as part of this PR. I also
  moved the unit tests for this code into an integration test,
  `linux-sandbox/tests/landlock.rs`, in which I use
  `env!("CARGO_BIN_EXE_codex-linux-sandbox")` as the value for
  `codex_linux_sandbox_exe` since `std::env::current_exe()` is not
  appropriate in that case.

  Michael Bolin · 2025-05-23 11:37:07 -07:00
  89ef4efdcf
• feat: support the chat completions API in the Rust CLI (#862)

  This is a substantial PR to add support for the chat completions API,
  which in turn makes it possible to use non-OpenAI model providers (just
  like in the TypeScript CLI):
  
  * It moves a number of structs from `client.rs` to `client_common.rs` so
  they can be shared.
  * It introduces support for the chat completions API in
  `chat_completions.rs`.
  * It updates `ModelProviderInfo` so that `env_key` is `Option<String>`
  instead of `String` (for e.g., ollama) and adds a `wire_api` field
  * It updates `client.rs` to choose between `stream_responses()` and
  `stream_chat_completions()` based on the `wire_api` for the
  `ModelProviderInfo`
  * It updates the `exec` and TUI CLIs to no longer fail if the
  `OPENAI_API_KEY` environment variable is not set
  * It updates the TUI so that `EventMsg::Error` is displayed more
  prominently when it occurs, particularly now that it is important to
  alert users to the `CodexErr::EnvVar` variant.
  * `CodexErr::EnvVar` was updated to include an optional `instructions`
  field so we can preserve the behavior where we direct users to
  https://platform.openai.com if `OPENAI_API_KEY` is not set.
  * Cleaned up the "welcome message" in the TUI to ensure the model
  provider is displayed.
  * Updated the docs in `codex-rs/README.md`.
  
  To exercise the chat completions API from OpenAI models, I added the
  following to my `config.toml`:
  
  ```toml
  model = "gpt-4o"
  model_provider = "openai-chat-completions"
  
  [model_providers.openai-chat-completions]
  name = "OpenAI using Chat Completions"
  base_url = "https://api.openai.com/v1"
  env_key = "OPENAI_API_KEY"
  wire_api = "chat"
  ```
  
  Though to test a non-OpenAI provider, I installed ollama with mistral
  locally on my Mac because ChatGPT said that would be a good match for my
  hardware:
  
  ```shell
  brew install ollama
  ollama serve
  ollama pull mistral
  ```
  
  Then I added the following to my `~/.codex/config.toml`:
  
  ```toml
  model = "mistral"
  model_provider = "ollama"
  ```
  
  Note this code could certainly use more test coverage, but I want to get
  this in so folks can start playing with it.
  
  For reference, I believe https://github.com/openai/codex/pull/247 was
  roughly the comparable PR on the TypeScript side.

  Michael Bolin · 2025-05-08 21:46:06 -07:00
  e924070cee
• [codex-rs] Improve linux sandbox timeouts (#662)

  * Fixes flaking rust unit test
  * Adds explicit sandbox exec timeout handling

  Parker Thompson · 2025-04-25 12:56:20 -07:00
  7d9de34bc7
• feat: initial import of Rust implementation of Codex CLI in codex-rs/ (#629)

  As stated in `codex-rs/README.md`:
  
  Today, Codex CLI is written in TypeScript and requires Node.js 22+ to
  run it. For a number of users, this runtime requirement inhibits
  adoption: they would be better served by a standalone executable. As
  maintainers, we want Codex to run efficiently in a wide range of
  environments with minimal overhead. We also want to take advantage of
  operating system-specific APIs to provide better sandboxing, where
  possible.
  
  To that end, we are moving forward with a Rust implementation of Codex
  CLI contained in this folder, which has the following benefits:
  
  - The CLI compiles to small, standalone, platform-specific binaries.
  - Can make direct, native calls to
  [seccomp](https://man7.org/linux/man-pages/man2/seccomp.2.html) and
  [landlock](https://man7.org/linux/man-pages/man7/landlock.7.html) in
  order to support sandboxing on Linux.
  - No runtime garbage collection, resulting in lower memory consumption
  and better, more predictable performance.
  
  Currently, the Rust implementation is materially behind the TypeScript
  implementation in functionality, so continue to use the TypeScript
  implmentation for the time being. We will publish native executables via
  GitHub Releases as soon as we feel the Rust version is usable.

  Michael Bolin · 2025-04-24 13:31:40 -07:00
  31d0d7a305