Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust
23.3 KB
Raw Blame
use prost::Message;

// ---------------------------------------------------------------------------
// Agent client message (request)
// ---------------------------------------------------------------------------

// Envelope the client writes into the open `Run` request body. Tag numbers from
// the Cursor Agent descriptors (agent.proto, AgentClientMessage): 1 run_request,
// 2 exec_client_message, 5 exec_client_control_message, 7 client_heartbeat. The
// heartbeat used to sit on tag 2, which is the exec reply -- a reply carrying no
// result reads as "ran and produced nothing" and the server waits forever.
#[derive(Clone, PartialEq, Message)]
pub struct AgentClientMessage {
    #[prost(message, optional, tag = "1")]
    pub run_request: Option<RunRequest>,
    #[prost(message, optional, tag = "2")]
    pub exec_client_message: Option<ExecClientMessage>,
    #[prost(message, optional, tag = "3")]
    pub kv_client_message: Option<KvClientMessage>,
    #[prost(message, optional, tag = "5")]
    pub exec_client_control_message: Option<ExecClientControlMessage>,
    #[prost(message, optional, tag = "7")]
    pub client_heartbeat: Option<ClientHeartbeat>,
}

#[derive(Clone, PartialEq, Message)]
pub struct RunRequest {
    #[prost(message, optional, tag = "1")]
    pub conversation_state: Option<ConversationState>,
    #[prost(message, optional, tag = "2")]
    pub action: Option<Action>,
    #[prost(message, optional, tag = "6")]
    pub mcp_tools: Option<McpTools>,
    #[prost(string, tag = "7")]
    pub conversation_id: String,
    #[prost(message, optional, tag = "8")]
    pub requested_model: Option<CursorModel>,
    #[prost(bool, tag = "9")]
    pub exclude_workspace_context: bool,
    #[prost(message, repeated, tag = "10")]
    pub selected_subagent_models: Vec<CursorModelRequest>,
    #[prost(string, tag = "11")]
    pub conversation_group_id: String,
    #[prost(bool, tag = "12")]
    pub client_supports_inline_images: bool,
}

#[derive(Clone, PartialEq, Message)]
pub struct ConversationState {
    #[prost(message, repeated, tag = "1")]
    pub messages: Vec<ConversationMessage>,
}

#[derive(Clone, PartialEq, Message)]
pub struct ConversationMessage {
    #[prost(string, tag = "1")]
    pub role: String,
    #[prost(string, tag = "2")]
    pub text: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct Action {
    #[prost(message, optional, tag = "1")]
    pub user_message_action: Option<UserMessageAction>,
}

#[derive(Clone, PartialEq, Message)]
pub struct UserMessageAction {
    #[prost(message, optional, tag = "1")]
    pub user_message: Option<UserMessage>,
}

#[derive(Clone, PartialEq, Message)]
pub struct UserMessage {
    #[prost(string, tag = "1")]
    pub text: String,
    #[prost(string, tag = "2")]
    pub message_id: String,
    #[prost(message, optional, tag = "3")]
    pub selected_context: Option<SelectedContext>,
    #[prost(string, tag = "4")]
    pub mode: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct SelectedContext {
    #[prost(message, repeated, tag = "1")]
    pub selected_images: Vec<SelectedImage>,
}

#[derive(Clone, PartialEq, Message)]
pub struct McpTools {
    #[prost(message, repeated, tag = "1")]
    pub tools: Vec<McpTool>,
}

#[derive(Clone, PartialEq, Message)]
pub struct McpTool {
    #[prost(string, tag = "1")]
    pub name: String,
    #[prost(string, tag = "2")]
    pub description: String,
    #[prost(string, tag = "3")]
    pub input_schema: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct ClientHeartbeat {}

#[derive(Clone, PartialEq, Message)]
pub struct CursorModel {
    #[prost(string, tag = "1")]
    pub model_id: String,
    #[prost(message, repeated, tag = "2")]
    pub parameters: Vec<ModelParameter>,
}

#[derive(Clone, PartialEq, Message)]
pub struct CursorModelRequest {
    #[prost(string, tag = "1")]
    pub model_id: String,
    #[prost(message, repeated, tag = "2")]
    pub parameters: Vec<ModelParameter>,
}

#[derive(Clone, PartialEq, Message)]
pub struct ModelParameter {
    #[prost(string, tag = "1")]
    pub id: String,
    #[prost(string, tag = "2")]
    pub value: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct SelectedImage {
    #[prost(string, tag = "1")]
    pub data: String,
    #[prost(string, tag = "2")]
    pub uuid: String,
    #[prost(string, tag = "3")]
    pub path: String,
    #[prost(string, tag = "4")]
    pub mime_type: String,
}

// ---------------------------------------------------------------------------
// Agent server message (response)
// ---------------------------------------------------------------------------

#[derive(Clone, PartialEq, Message)]
pub struct AgentServerMessage {
    #[prost(message, optional, tag = "1")]
    pub interaction_update: Option<InteractionUpdate>,
    #[prost(message, optional, tag = "2")]
    pub exec_server_message: Option<ExecServerMessage>,
    #[prost(message, optional, tag = "3")]
    pub conversation_checkpoint_update: Option<ConversationCheckpointUpdate>,
    #[prost(message, optional, tag = "4")]
    pub kv_server_message: Option<KvServerMessage>,
}

/// The server's conversation state, sent whole at each step. Only the token
/// counter is read: `token_details` (tag 5) is the size of the context the
/// model saw on its latest step, which is what Claude Code's context gauge
/// means. `TurnEnded` adds up every internal step of a run instead.
#[derive(Clone, PartialEq, Message)]
pub struct ConversationCheckpointUpdate {
    #[prost(message, optional, tag = "5")]
    pub token_details: Option<ConversationTokenDetails>,
}

#[derive(Clone, PartialEq, Message)]
pub struct ConversationTokenDetails {
    #[prost(uint32, tag = "1")]
    pub used_tokens: u32,
    #[prost(uint32, tag = "2")]
    pub max_tokens: u32,
}

/// The agent store: the server writes its conversation state here and reads it
/// back on resume. Every message expects a `KvClientMessage` on the same id.
#[derive(Clone, PartialEq, Message)]
pub struct KvServerMessage {
    #[prost(uint32, tag = "1")]
    pub id: u32,
    #[prost(oneof = "kv_server_message::Message", tags = "2, 3")]
    pub message: Option<kv_server_message::Message>,
}

pub mod kv_server_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        #[prost(message, tag = "2")]
        GetBlobArgs(super::GetBlobArgs),
        #[prost(message, tag = "3")]
        SetBlobArgs(super::SetBlobArgs),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct GetBlobArgs {
    #[prost(bytes, tag = "1")]
    pub blob_id: Vec<u8>,
}

#[derive(Clone, PartialEq, Message)]
pub struct SetBlobArgs {
    #[prost(bytes, tag = "1")]
    pub blob_id: Vec<u8>,
    #[prost(bytes, tag = "2")]
    pub blob_data: Vec<u8>,
}

#[derive(Clone, PartialEq, Message)]
pub struct KvClientMessage {
    #[prost(uint32, tag = "1")]
    pub id: u32,
    #[prost(oneof = "kv_client_message::Message", tags = "2, 3")]
    pub message: Option<kv_client_message::Message>,
}

pub mod kv_client_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        #[prost(message, tag = "2")]
        GetBlobResult(super::GetBlobResult),
        #[prost(message, tag = "3")]
        SetBlobResult(super::SetBlobResult),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct GetBlobResult {
    #[prost(bytes, optional, tag = "1")]
    pub blob_data: Option<Vec<u8>>,
}

#[derive(Clone, PartialEq, Message)]
pub struct SetBlobResult {}

// Tag numbers verified against the Cursor Agent bundle's protobuf descriptors
// (2026.10.01-e373342, 12/10/2026): 1 text_delta, 2 tool_call_started,
// 3 tool_call_completed, 4 thinking_delta, 14 turn_ended. The previous mapping
// (thinking 1, text 2, turn_ended 3) read tool_call_started as the model's text,
// which is why a Cursor tool call reached Claude Code as the literal string
// "call_...\nfc_..." instead of a tool_use block.
#[derive(Clone, PartialEq, Message)]
pub struct InteractionUpdate {
    #[prost(message, optional, tag = "1")]
    pub text_delta: Option<TextDelta>,
    #[prost(message, optional, tag = "4")]
    pub thinking_delta: Option<ThinkingDelta>,
    #[prost(message, optional, tag = "14")]
    pub turn_ended: Option<TurnEnded>,
}

#[derive(Clone, PartialEq, Message)]
pub struct ThinkingDelta {
    #[prost(string, tag = "1")]
    pub text: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct TextDelta {
    #[prost(string, tag = "1")]
    pub text: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct TurnEnded {
    #[prost(uint64, tag = "1")]
    pub input_tokens: u64,
    #[prost(uint64, tag = "2")]
    pub output_tokens: u64,
    #[prost(uint64, tag = "3")]
    pub cache_read_tokens: u64,
    #[prost(uint64, tag = "4")]
    pub cache_write_tokens: u64,
}

// The frame in which Cursor asks the CLIENT to run a tool. Field numbers from
// the same descriptors: 1 id, 2 shell_args, 3 write_args, 7 read_args,
// 14 shell_stream_args, 15 exec_id. Measured live 12/10/2026: a Read arrives as
// read_args{path, tool_call_id} and a Bash as shell_stream_args with the same
// ShellArgs shape.
#[derive(Clone, PartialEq, Message)]
pub struct ExecServerMessage {
    #[prost(uint32, optional, tag = "1")]
    pub id: Option<u32>,
    #[prost(message, optional, tag = "2")]
    pub shell_args: Option<ShellArgs>,
    #[prost(message, optional, tag = "3")]
    pub write_args: Option<WriteArgs>,
    #[prost(message, optional, tag = "4")]
    pub delete_args: Option<DeleteArgs>,
    #[prost(message, optional, tag = "5")]
    pub grep_args: Option<GrepArgs>,
    #[prost(message, optional, tag = "7")]
    pub read_args: Option<ReadArgs>,
    #[prost(message, optional, tag = "8")]
    pub ls_args: Option<LsArgs>,
    #[prost(message, optional, tag = "10")]
    pub request_context_args: Option<RequestContextArgs>,
    #[prost(message, optional, tag = "14")]
    pub shell_stream_args: Option<ShellArgs>,
    #[prost(string, optional, tag = "15")]
    pub exec_id: Option<String>,
}

#[derive(Clone, PartialEq, Message)]
pub struct ReadArgs {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, optional, tag = "2")]
    pub tool_call_id: Option<String>,
    #[prost(int32, optional, tag = "4")]
    pub offset: Option<i32>,
    #[prost(uint32, optional, tag = "5")]
    pub limit: Option<u32>,
    #[prost(string, optional, tag = "6")]
    pub encoding_hint: Option<String>,
}

#[derive(Clone, PartialEq, Message)]
pub struct WriteArgs {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, tag = "2")]
    pub file_text: String,
    #[prost(string, optional, tag = "3")]
    pub tool_call_id: Option<String>,
    #[prost(bool, tag = "4")]
    pub return_file_content_after_write: bool,
    /// A byte-backed write sets this and leaves `file_text` empty.
    #[prost(bytes, optional, tag = "5")]
    pub file_bytes: Option<Vec<u8>>,
    /// Charset of the payload (`utf8`, `latin1`, ...), not an encoding of it.
    #[prost(string, optional, tag = "6")]
    pub encoding_hint: Option<String>,
}

#[derive(Clone, PartialEq, Message)]
pub struct ShellArgs {
    #[prost(string, tag = "1")]
    pub command: String,
    #[prost(string, optional, tag = "2")]
    pub working_directory: Option<String>,
    /// Milliseconds: the Cursor agent's own default is 30000 and it feeds the
    /// value straight to `setTimeout` (index.js, 2026.10.01 bundle).
    #[prost(int32, optional, tag = "3")]
    pub timeout: Option<i32>,
    #[prost(string, optional, tag = "4")]
    pub tool_call_id: Option<String>,
    #[prost(int32, optional, tag = "14")]
    pub hard_timeout: Option<i32>,
}

#[derive(Clone, PartialEq, Message)]
pub struct DeleteArgs {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, optional, tag = "2")]
    pub tool_call_id: Option<String>,
}

#[derive(Clone, PartialEq, Message)]
pub struct GrepArgs {
    #[prost(string, tag = "1")]
    pub pattern: String,
    #[prost(string, optional, tag = "2")]
    pub path: Option<String>,
    #[prost(string, optional, tag = "14")]
    pub tool_call_id: Option<String>,
}

/// The agent asking for workspace context. Measured live 12/10/2026: it is the
/// first exec of a run, and it carries no id.
#[derive(Clone, PartialEq, Message)]
pub struct RequestContextArgs {
    #[prost(string, optional, tag = "2")]
    pub notes_session_id: Option<String>,
}

#[derive(Clone, PartialEq, Message)]
pub struct LsArgs {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, optional, tag = "3")]
    pub tool_call_id: Option<String>,
}

// ---------------------------------------------------------------------------
// Agent client exec reply (the answer the server waits for)
// ---------------------------------------------------------------------------

/// The reply to one `ExecServerMessage`, written back on the same open `Run`.
/// `id` and `exec_id` are echoed unchanged: the id space is shared with the
/// interactions and a result carrying an unknown id is dropped.
#[derive(Clone, PartialEq, Message)]
pub struct ExecClientMessage {
    #[prost(uint32, tag = "1")]
    pub id: u32,
    #[prost(string, tag = "15")]
    pub exec_id: String,
    #[prost(
        oneof = "exec_client_message::Message",
        tags = "2, 3, 4, 5, 7, 8, 10, 14"
    )]
    pub message: Option<exec_client_message::Message>,
}

pub mod exec_client_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        #[prost(message, tag = "2")]
        ShellResult(super::ShellResult),
        #[prost(message, tag = "3")]
        WriteResult(super::WriteResult),
        #[prost(message, tag = "4")]
        DeleteResult(super::DeleteResult),
        #[prost(message, tag = "5")]
        GrepResult(super::GrepResult),
        #[prost(message, tag = "7")]
        ReadResult(super::ReadResult),
        #[prost(message, tag = "8")]
        LsResult(super::LsResult),
        #[prost(message, tag = "10")]
        RequestContextResult(super::RequestContextResult),
        #[prost(message, tag = "14")]
        ShellStream(super::ShellStream),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct ExecClientControlMessage {
    #[prost(oneof = "exec_client_control_message::Message", tags = "1, 2, 3")]
    pub message: Option<exec_client_control_message::Message>,
}

pub mod exec_client_control_message {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Message {
        #[prost(message, tag = "1")]
        StreamClose(super::ExecClientStreamClose),
        #[prost(message, tag = "2")]
        Throw(super::ExecClientThrow),
        #[prost(message, tag = "3")]
        Heartbeat(super::ExecClientHeartbeat),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct ExecClientStreamClose {
    #[prost(uint32, tag = "1")]
    pub id: u32,
}

#[derive(Clone, PartialEq, Message)]
pub struct ExecClientThrow {
    #[prost(uint32, tag = "1")]
    pub id: u32,
    #[prost(string, tag = "2")]
    pub error: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct ExecClientHeartbeat {
    #[prost(uint32, tag = "1")]
    pub id: u32,
}

#[derive(Clone, PartialEq, Message)]
pub struct ReadResult {
    #[prost(oneof = "read_result::Result", tags = "1, 2, 3")]
    pub result: Option<read_result::Result>,
}

pub mod read_result {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "1")]
        Success(super::ReadSuccess),
        #[prost(message, tag = "2")]
        Error(super::ReadError),
        #[prost(message, tag = "3")]
        Rejected(super::ReadRejected),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct ReadSuccess {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(int32, tag = "3")]
    pub total_lines: i32,
    #[prost(int64, tag = "4")]
    pub file_size: i64,
    #[prost(bool, tag = "6")]
    pub truncated: bool,
    #[prost(oneof = "read_success::Output", tags = "2, 5")]
    pub output: Option<read_success::Output>,
}

pub mod read_success {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Output {
        #[prost(string, tag = "2")]
        Content(String),
        #[prost(bytes, tag = "5")]
        Data(Vec<u8>),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct ReadError {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, tag = "2")]
    pub error: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct ReadRejected {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, tag = "2")]
    pub reason: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct WriteResult {
    #[prost(oneof = "write_result::Result", tags = "1, 5, 6")]
    pub result: Option<write_result::Result>,
}

pub mod write_result {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "1")]
        Success(super::WriteSuccess),
        #[prost(message, tag = "5")]
        Error(super::WriteError),
        #[prost(message, tag = "6")]
        Rejected(super::WriteRejected),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct WriteSuccess {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(int32, tag = "2")]
    pub lines_created: i32,
    #[prost(int32, tag = "3")]
    pub file_size: i32,
}

#[derive(Clone, PartialEq, Message)]
pub struct WriteError {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, tag = "2")]
    pub error: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct WriteRejected {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, tag = "2")]
    pub reason: String,
}

/// `GrepResult` models only the error outcome here: the bridge has no Claude
/// Grep mapping, and a result the bridge never constructs only has to encode.
#[derive(Clone, PartialEq, Message)]
pub struct GrepResult {
    #[prost(oneof = "grep_result::Result", tags = "2")]
    pub result: Option<grep_result::Result>,
}

pub mod grep_result {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "2")]
        Error(super::GrepError),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct GrepError {
    #[prost(string, tag = "1")]
    pub error: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct LsResult {
    #[prost(oneof = "ls_result::Result", tags = "3")]
    pub result: Option<ls_result::Result>,
}

pub mod ls_result {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "3")]
        Rejected(super::LsRejected),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct LsRejected {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, tag = "2")]
    pub reason: String,
}

/// The answer to `request_context_args` (tag 10). The agent asks for workspace
/// context before it plans; this bridge renders its own prompt and has none to
/// add, but the request still needs a reply.
#[derive(Clone, PartialEq, Message)]
pub struct RequestContextResult {
    #[prost(oneof = "request_context_result::Result", tags = "1")]
    pub result: Option<request_context_result::Result>,
}

pub mod request_context_result {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "1")]
        Success(super::RequestContextSuccess),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct RequestContext {
    #[prost(message, optional, tag = "4")]
    pub env: Option<RequestContextEnv>,
}

/// The environment the agent is told it runs in. Measured 12/10/2026: an answer
/// to `request_context_args` without this block makes the server fail the run
/// with "Failed to get request context (internal)".
#[derive(Clone, PartialEq, Message)]
pub struct RequestContextEnv {
    #[prost(string, tag = "1")]
    pub os_version: String,
    #[prost(string, repeated, tag = "2")]
    pub workspace_paths: Vec<String>,
    #[prost(string, tag = "3")]
    pub shell: String,
    #[prost(string, tag = "10")]
    pub time_zone: String,
    #[prost(string, tag = "11")]
    pub project_folder: String,
    #[prost(bool, optional, tag = "14")]
    pub sandbox_supported: Option<bool>,
    #[prost(bool, optional, tag = "16")]
    pub sandbox_network_has_defaults: Option<bool>,
    #[prost(string, optional, tag = "21")]
    pub process_working_directory: Option<String>,
}

#[derive(Clone, PartialEq, Message)]
pub struct RequestContextSuccess {
    #[prost(message, optional, tag = "1")]
    pub request_context: Option<RequestContext>,
}

#[derive(Clone, PartialEq, Message)]
pub struct DeleteResult {
    #[prost(oneof = "delete_result::Result", tags = "6")]
    pub result: Option<delete_result::Result>,
}

pub mod delete_result {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "6")]
        Rejected(super::DeleteRejected),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct DeleteRejected {
    #[prost(string, tag = "1")]
    pub path: String,
    #[prost(string, tag = "2")]
    pub reason: String,
}

/// One message of a shell execution stream. A stream is a SEQUENCE of these
/// with the same `id`: start, stdout/stderr, then exit. Without the exit the
/// server never closes the execution.
#[derive(Clone, PartialEq, Message)]
pub struct ShellStream {
    #[prost(oneof = "shell_stream::Event", tags = "1, 2, 3, 4")]
    pub event: Option<shell_stream::Event>,
}

pub mod shell_stream {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Event {
        #[prost(message, tag = "1")]
        Stdout(super::ShellStreamStdout),
        #[prost(message, tag = "2")]
        Stderr(super::ShellStreamStderr),
        #[prost(message, tag = "3")]
        Exit(super::ShellStreamExit),
        #[prost(message, tag = "4")]
        Start(super::ShellStreamStart),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct ShellStreamStdout {
    #[prost(string, tag = "1")]
    pub data: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct ShellStreamStderr {
    #[prost(string, tag = "1")]
    pub data: String,
}

#[derive(Clone, PartialEq, Message)]
pub struct ShellStreamExit {
    #[prost(uint32, tag = "1")]
    pub code: u32,
    #[prost(string, tag = "2")]
    pub cwd: String,
    #[prost(bool, tag = "4")]
    pub aborted: bool,
}

#[derive(Clone, PartialEq, Message)]
pub struct ShellStreamStart {}

/// A final structured shell result. Cursor can keep the turn pending when it
/// receives only stream deltas, so the exit is followed by this acknowledgement.
#[derive(Clone, PartialEq, Message)]
pub struct ShellResult {
    #[prost(oneof = "shell_result::Result", tags = "1, 2")]
    pub result: Option<shell_result::Result>,
}

pub mod shell_result {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        #[prost(message, tag = "1")]
        Success(super::ShellSuccess),
        #[prost(message, tag = "2")]
        Failure(super::ShellFailure),
    }
}

#[derive(Clone, PartialEq, Message)]
pub struct ShellSuccess {
    #[prost(string, tag = "1")]
    pub command: String,
    #[prost(string, tag = "2")]
    pub working_directory: String,
    #[prost(int32, tag = "3")]
    pub exit_code: i32,
    #[prost(string, tag = "5")]
    pub stdout: String,
    #[prost(string, tag = "6")]
    pub stderr: String,
    #[prost(int32, tag = "7")]
    pub execution_time: i32,
}

#[derive(Clone, PartialEq, Message)]
pub struct ShellFailure {
    #[prost(string, tag = "1")]
    pub command: String,
    #[prost(string, tag = "2")]
    pub working_directory: String,
    #[prost(int32, tag = "3")]
    pub exit_code: i32,
    #[prost(string, tag = "5")]
    pub stdout: String,
    #[prost(string, tag = "6")]
    pub stderr: String,
    #[prost(int32, tag = "7")]
    pub execution_time: i32,
}