Enum Op 

#[non_exhaustive]
pub enum Op {
    Interrupt,
    UserInput {
        items: Vec<InputItem>,
        final_output_json_schema: Option<Value>,
    },
    QueueUserInput {
        items: Vec<InputItem>,
    },
    UserTurn {
        items: Vec<InputItem>,
        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,
    },
    RegisterApprovedCommand {
        command: Vec<String>,
        match_kind: ApprovedCommandMatchKind,
        semantic_prefix: Option<Vec<String>>,
    },
    PatchApproval {
        id: String,
        decision: ReviewDecision,
    },
    AddToHistory {
        text: String,
    },
    PersistHistorySnapshot {
        snapshot: Value,
    },
    GetHistoryEntryRequest {
        offset: usize,
        log_id: u64,
    },
    GetPath,
    ListMcpTools,
    ListCustomPrompts,
    ListSkills,
    Compact,
    Review {
        review_request: ReviewRequest,
    },
    Shutdown,
}

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<InputItem>

User input items, see InputItem

final_output_json_schema: Option<Value>

Optional JSON Schema used to constrain the final assistant message for this turn.

QueueUserInput

Queue user input to be appended to the next model request without interrupting the current turn.

Fields

items: Vec<InputItem>

User input items, see InputItem

UserTurn

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

Fields

items: Vec<InputItem>

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.

RegisterApprovedCommand

Register a command pattern as approved for the remainder of the session.

Fields

command: Vec<String>

match_kind: ApprovedCommandMatchKind

semantic_prefix: Option<Vec<String>>

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.

PersistHistorySnapshot

Persist the full chat history snapshot for the current session.

Fields

snapshot: Value

GetHistoryEntryRequest

Request a single history entry identified by log_id + offset.

Fields

offset: usize

log_id: u64

GetPath

Request the full in-memory conversation transcript for the current session. Reply is delivered via EventMsg::ConversationHistory.

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.

ListSkills

Request the list of available skills. Reply is delivered via EventMsg::ListSkillsResponse.

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.

Review

Request a code review from the agent.

Fields

review_request: ReviewRequest

Shutdown

Request to shut down codex instance.

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 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