- Renamed task_tool.rs to agent_tool.rs
- Updated all structs: Task → Agent, TaskManager → AgentManager
- Updated all types: TaskStatus → AgentStatus
- Renamed all functions: run_task → run_agent, check_task_status → check_agent_status, etc.
- Updated parameter structs: RunTaskParams → RunAgentParams, etc.
- Updated slash command prompts (/plan, /solve, /code) to use agent terminology
- Added UI status indicators showing running agents count
- Enhanced list_agents with status count summary
- Fixed tokio imports (kept as task::, not agent::)
- Maintained backward compatibility with event system
This provides clearer semantics when working with multiple external LLMs in parallel.
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <[email protected]>
Add a new "agent" tool that allows the LLM to call external command-line LLMs
(claude, gemini, codex) and aggregate their responses. This enables the system
to query multiple LLMs and compare or combine their outputs.
- Create agent_tool.rs module with tool definition and execution logic
- Register the agent tool in the OpenAI tools list
- Add handler for agent tool calls in codex.rs
- Support calling multiple agents with the same prompt in parallel
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <[email protected]>
- Check npm registry for latest published version before bumping
- Only create git tags if they don't already exist
- Handle case where local version is behind published version
- Properly bump from the latest published version to avoid conflicts
- Delete release-simple.yml (no longer needed)
- Re-enable complex release.yml as main workflow (it works now!)
- Fix GitHub Release creation by using GH_PAT token
- Complex workflow now successfully builds all 7 platforms
- Use dtolnay/[email protected] instead of @stable for consistency
- Use ARM runners (ubuntu-24.04-arm) for ARM targets to avoid cross-compilation
- Add pkg-config to musl installations
- Include both musl and gnu targets for Linux
- Use macos-14 (ARM) for all macOS builds
- Consolidate musl tools installation into single step
- Change release.yml to workflow_dispatch (manual trigger only)
- Keep release-simple.yml as the main automated release workflow
- This prevents both workflows from running on every push
- Simple workflow is sufficient for Linux-only npm releases
- Add 'if: github.repository == openai/codex' to all upstream workflows
- Prevents rust-ci, ci, codespell, codex, and rust-release from running on forks
- Keeps our fork clean and only runs our custom release workflows
- Add fork-specific README with installation instructions
- Update package.json to @just-every/code v0.1.1
- Prepare for next release with proper versioning
- Clean, focused documentation for the enhanced fork
- Clear installation instructions with npm package name
- Highlight key features and enhancements
- Add comprehensive usage examples
- Include troubleshooting and development sections
- Add comparison table with original Codex
- Remove outdated content and simplify structure
- Add clear branding as enhanced fork of OpenAI Codex
- Highlight new features (image support, /reasoning command)
- Provide npm installation instructions for @just-every/code
- Explain configuration directory behavior
- Rename binaries from codex to code across all Cargo.toml files
- Create @just-every/code npm package with generic build scripts
- Add CODE_HOME environment variable support (falls back to CODEX_HOME)
- Create GitHub Actions workflow for automated npm releases
- Update JavaScript wrapper from codex.js to code.js
- Add FORK_SETUP.md documentation
- Configure dual-branch strategy for fork management
The codebase was using unstable let-chains syntax which prevented
compilation on stable Rust. This commit replaces all instances with
equivalent nested conditional checks.
Changes:
- client.rs: Fix auth header conditional chain
- error.rs: Fix usage limit error message conditional chain
- protocol.rs: Fix TMPDIR environment variable conditional chain
This allows the codebase to compile on stable Rust without requiring
nightly features.
- Add /reasoning command with parameter support (high/medium/low/none)
- Create interactive UI for reasoning level selection when no parameter given
- Show current level with arrow key navigation and descriptions
- Properly format output with bold text instead of markdown asterisks
- Prevent duplicate welcome message when updating session configuration
- Track welcome_shown state to avoid re-displaying intro
Fixes#2106🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <[email protected]>
This improves the release process by introducing
`scripts/publish_to_npm.py` to automate publishing to npm (modulo the
human 2fac step).
As part of this, it updates `.github/workflows/rust-release.yml` to
create the artifact for npm using `npm pack`.
And finally, while it is long overdue, this memorializes the release
process in `docs/release_management.md`.
## Summary
- allow Esc to interrupt the current session when a task is running
- document Esc as an interrupt key in status indicator
## Testing
- `just fmt`
- `just fix` *(fails: E0658 `let` expressions in this position are
unstable)*
- `cargo test --all-features` *(fails: E0658 `let` expressions in this
position are unstable)*
------
https://chatgpt.com/codex/tasks/task_i_689698cf605883208f57b0317ff6a303
## Summary
Allow tui conversations to resume after the client fails out of retries.
I tested this with exec / mocked api failures as well, and it appears to
be fine. But happy to add an exec integration test as well!
## Testing
- [x] Added integration test
- [x] Tested locally
## Summary
From codex-cli 😁
`-s/--sandbox` now correctly affects sandbox mode.
What changed
- In `codex-rs/exec/src/cli.rs`:
- Added `value_enum` to the `--sandbox` flag so Clap parses enum values
into `
SandboxModeCliArg`.
- This ensures values like `-s read-only`, `-s workspace-write`, and `-s
dange
r-full-access` are recognized and propagated.
Why this fixes it
- The enum already derives `ValueEnum`, but without `#[arg(value_enum)]`
Clap ma
y not map the string into the enum, leaving the option ineffective at
runtime. W
ith `value_enum`, `sandbox_mode` is parsed and then converted to
`SandboxMode` i
n `run_main`, which feeds into `ConfigOverrides` and ultimately into the
effecti
ve `sandbox_policy`.
This deletes the bulk of the `codex-cli` folder and eliminates the logic
that builds the TypeScript code and bundles it into the release.
Since this PR modifies `.github/workflows/rust-release.yml`, to test
changes to the release process, I locally commented out all of the "is
this commit on upstream `main`" checks in
`scripts/create_github_release.sh` and ran:
```
./codex-rs/scripts/create_github_release.sh 0.20.0-alpha.4
```
Which kicked off:
https://github.com/openai/codex/actions/runs/16842085113
And the release artifacts appear legit!
https://github.com/openai/codex/releases/tag/rust-v0.20.0-alpha.4
Historically, the release process for the npm module has been:
- I run `codex-rs/scripts/create_github_release.sh` to kick off a
release for the native artifacts.
- I wait until it is done.
- I run `codex-cli/scripts/stage_rust_release.py` to build the npm
release locally
- I run `npm publish` from my laptop
It has been a longstanding issue to move the npm build to CI. I may
still have to do the `npm publish` manually because it requires 2fac
with `npm`, though I assume we can work that out later.
Note I asked Codex to make these updates, and while they look pretty
good to me, I'm not 100% certain, but let's just merge this and I'll
kick off another alpha build and we'll see what happens?
To date, the build scripts in `codex-cli` still supported building the
old TypeScript version of the Codex CLI to give Windows users something
they can run, but we are just going to have them use the Rust version
like everyone else, so:
- updates `codex-cli/bin/codex.js` so that we run the native binary or
throw if the target platform/arch is not supported (no more conditional
usage based on `CODEX_RUST`, `use-native` file, etc.)
- drops the `--native` flag from `codex-cli/scripts/stage_release.sh`
and updates all the code paths to behave as if `--native` were passed
(i.e., it is the only way to run it now)
Tested this by running:
```
./codex-cli/scripts/stage_rust_release.py --release-version 0.20.0-alpha.2
```
Release builds are taking awhile and part of the reason that we are
building binaries that we are not really using. Adding Windows binaries
into releases (https://github.com/openai/codex/pull/2035) slows things
down, so we need to get some time back.
- `codex-exec` is basically a standalone `codex exec` that we were
offering because it's a bit smaller as it does not include all the bits
to power the TUI. We were using it in our experimental GitHub Action, so
this PR updates the Action to use `codex exec` instead.
- `codex-linux-sandbox` was a helper binary for the TypeScript version
of the CLI, but I am about to axe that, so we don't need this either.
If we decide to bring `codex-exec` back at some point, we should use a
separate instances so we can build it in parallel with `codex`. (I think
if we had beefier build machines, this wouldn't be so bad, but that's
not the case with the default runners from GitHub.)
We should stop shipping the old TypeScript CLI to Windows users. I did
some light testing of the Rust CLI on Windows in `cmd.exe` and it works
better than I expected!
This pull request implements a fix from #2000, as well as fixed an
additional problem with path lengths on windows that prevents the login
from displaying.
---------
Co-authored-by: Michael Bolin <[email protected]>
Co-authored-by: Michael Bolin <[email protected]>
## 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
We wait until we have an entire newline, then format it with markdown and stream in to the UI. This reduces time to first token but is the right thing to do with our current rendering model IMO. Also lets us add word wrapping!
Uses this rough strategy for authentication:
```
if auth.json
if auth.json.API_KEY is NULL # new auth
CHAT
else # old auth
if plus or pro or team
CHAT
else
API_KEY
else OPENAI_API_KEY
```
---
[//]: # (BEGIN SAPLING FOOTER)
Stack created with [Sapling](https://sapling-scm.com). Best reviewed
with [ReviewStack](https://reviewstack.dev/openai/codex/pull/1970).
* __->__ #1971
* #1970
* #1966
* #1965
* #1962
There are two valid ways to create an instance of `CodexAuth`:
`from_api_key()` and `from_codex_home()`. Now both are static methods of
`CodexAuth` and are listed first in the implementation.
---
[//]: # (BEGIN SAPLING FOOTER)
Stack created with [Sapling](https://sapling-scm.com). Best reviewed
with [ReviewStack](https://reviewstack.dev/openai/codex/pull/1966).
* #1971
* #1970
* __->__ #1966
* #1965
* #1962
`CodexAuth::new()` was the first method listed in `CodexAuth`, but it is
only meant to be used by tests. Rename it to
`create_dummy_chatgpt_auth_for_testing()` and move it to the end of the
implementation.
---
[//]: # (BEGIN SAPLING FOOTER)
Stack created with [Sapling](https://sapling-scm.com). Best reviewed
with [ReviewStack](https://reviewstack.dev/openai/codex/pull/1962).
* #1971
* #1970
* #1966
* #1965
* __->__ #1962
