Enum Op 

#[non_exhaustive]
pub enum Op {
    Interrupt,
    UserInput {
        items: Vec<UserInput>,
    },
    UserTurn {
        items: Vec<UserInput>,
        cwd: PathBuf,
        approval_policy: AskForApproval,
        sandbox_policy: SandboxPolicy,
        model: String,
        effort: Option<ReasoningEffort>,
        summary: ReasoningSummary,
        final_output_json_schema: Option<Value>,
    },
    OverrideTurnContext {
        cwd: Option<PathBuf>,
        approval_policy: Option<AskForApproval>,
        sandbox_policy: Option<SandboxPolicy>,
        model: Option<String>,
        effort: Option<Option<ReasoningEffort>>,
        summary: Option<ReasoningSummary>,
    },
    ExecApproval {
        id: String,
        decision: ReviewDecision,
    },
    PatchApproval {
        id: String,
        decision: ReviewDecision,
    },
    AddToHistory {
        text: String,
    },
    GetHistoryEntryRequest {
        offset: usize,
        log_id: u64,
    },
    ListMcpTools,
    ListCustomPrompts,
    Compact,
    Undo,
    Review {
        review_request: ReviewRequest,
    },
    Shutdown,
    RunUserShellCommand {
        command: String,
    },
}

Submission operation

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Interrupt

Abort current task. This server sends EventMsg::TurnAborted in response.

UserInput

Input from the user

Fields

items: Vec<UserInput>

User input items, see InputItem

UserTurn

Similar to Op::UserInput, but contains additional context required for a turn of a [crate::codex_conversation::CodexConversation].

Fields

items: Vec<UserInput>

User input items, see InputItem

cwd: PathBuf

cwd to use with the SandboxPolicy and potentially tool calls such as local_shell.

approval_policy: AskForApproval

Policy to use for command approval.

sandbox_policy: SandboxPolicy

Policy to use for tool calls such as local_shell.

model: String

Must be a valid model slug for the [crate::client::ModelClient] associated with this conversation.

effort: Option<ReasoningEffort>

Will only be honored if the model is configured to use reasoning.

summary: ReasoningSummary

Will only be honored if the model is configured to use reasoning.

final_output_json_schema: Option<Value>

OverrideTurnContext

Override parts of the persistent turn context for subsequent turns.

All fields are optional; when omitted, the existing value is preserved. This does not enqueue any input – it only updates defaults used for future UserInput turns.

Fields

cwd: Option<PathBuf>

Updated cwd for sandbox/tool calls.

approval_policy: Option<AskForApproval>

Updated command approval policy.

sandbox_policy: Option<SandboxPolicy>

Updated sandbox policy for tool calls.

model: Option<String>

Updated model slug. When set, the model family is derived automatically.

effort: Option<Option<ReasoningEffort>>

Updated reasoning effort (honored only for reasoning-capable models).

Use Some(Some(_)) to set a specific effort, Some(None) to clear the effort, or None to leave the existing value unchanged.

summary: Option<ReasoningSummary>

Updated reasoning summary preference (honored only for reasoning-capable models).

ExecApproval

Approve a command execution

Fields

id: String

The id of the submission we are approving

decision: ReviewDecision

The user’s decision in response to the request.

PatchApproval

Approve a code patch

Fields

id: String

The id of the submission we are approving

decision: ReviewDecision

The user’s decision in response to the request.

AddToHistory

Append an entry to the persistent cross-session message history.

Note the entry is not guaranteed to be logged if the user has history disabled, it matches the list of “sensitive” patterns, etc.

Fields

text: String

The message text to be stored.

GetHistoryEntryRequest

Request a single history entry identified by log_id + offset.

Fields

offset: usize

log_id: u64

ListMcpTools

Request the list of MCP tools available across all configured servers. Reply is delivered via EventMsg::McpListToolsResponse.

ListCustomPrompts

Request the list of available custom prompts.

Compact

Request the agent to summarize the current conversation context. The agent will use its existing context (either conversation history or previous response id) to generate a summary which will be returned as an AgentMessage event.

Undo

Request Codex to undo a turn (turn are stacked so it is the same effect as CMD + Z).

Review

Request a code review from the agent.

Fields

review_request: ReviewRequest

Shutdown

Request to shut down codex instance.

RunUserShellCommand

Execute a user-initiated one-off shell command (triggered by “!cmd”).

The command string is executed using the user’s default shell and may include shell syntax (pipes, redirects, etc.). Output is streamed via ExecCommand* events and the UI regains control upon TaskComplete.

Fields

command: String

The raw command string after ‘!’

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Op

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Op

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Op

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Op

fn eq(&self, other: &Op) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Op

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Op