Struct TaskResponse 

pub struct TaskResponse {

    pub task_id: Uuid,
    pub completed: Option<bool>,
    pub status: Option<String>,
    pub user_output: Option<String>,
    pub process_response: Option<Value>,
    pub download: Option<TaskDownload>,
    pub upload: Option<TaskUpload>,
    pub file_browser: Option<FileBrowserEntry>,
    pub credentials: Vec<Credential>,
    pub artifacts: Vec<Artifact>,
    pub processes: Vec<ProcessEntry>,
    pub commands: Vec<CommandAction>,
    pub keylogs: Vec<KeylogEntry>,
    pub tokens: Vec<TokenEntry>,
    pub callback_tokens: Vec<CallbackToken>,
    pub removed_files: Vec<RemovedFileInfo>,
    pub alerts: Vec<AlertMessage>,
    pub edges: Vec<EdgeMessage>,
    pub socks: Vec<SocksMessage>,
    pub rpfwd: Vec<ReversePortForwardMessage>,
    pub interactive: Vec<InteractiveMessage>,
}

Task output sent by the agent. All fields are optional except task_id so an agent can send back only what it needs (user output, file chunk, SOCKS data, etc.).

Fields

task_id: Uuid

completed: Option<bool>

status: Option<String>

user_output: Option<String>

process_response: Option<Value>

download: Option<TaskDownload>

upload: Option<TaskUpload>

file_browser: Option<FileBrowserEntry>

credentials: Vec<Credential>

artifacts: Vec<Artifact>

processes: Vec<ProcessEntry>

commands: Vec<CommandAction>

keylogs: Vec<KeylogEntry>

tokens: Vec<TokenEntry>

callback_tokens: Vec<CallbackToken>

removed_files: Vec<RemovedFileInfo>

alerts: Vec<AlertMessage>

edges: Vec<EdgeMessage>

socks: Vec<SocksMessage>

rpfwd: Vec<ReversePortForwardMessage>

interactive: Vec<InteractiveMessage>

Implementations

impl TaskResponse

pub fn completed(task_id: Uuid, user_output: &str) -> Self

Examples found in repository

examples/mythic_facade.rs (line 118)

fn main() {
    let payload_uuid = Uuid::parse_str("f0f0f0f0-1111-2222-3333-444444444444").unwrap();

    // ── Plaintext checkin ─────────────────────────────────
    {
        let c2 = HttpC2 { key_b64: None };
        let agent = MythicAgent::easy_checkin(
            payload_uuid,
            &c2,
            vec!["10.0.0.1".into()],
            Some("linux".into()),
            Some("root".into()),
            Some("web01".into()),
            Some(1337),
            Some("x86_64".into()),
            None, None, None, None, None, None,
        )
        .unwrap();
        println!("Plaintext callback UUID: {}", agent.callback_uuid());
    }

    // ── Static-key checkin ────────────────────────────────
    {
        let key = Aes256HmacCrypto::new([0xAB; 32]).key_b64();
        let c2 = HttpC2 { key_b64: Some(key) };
        let agent = MythicAgent::easy_checkin(
            payload_uuid,
            &c2,
            vec!["192.168.1.100".into()],
            Some("windows".into()),
            Some("admin".into()),
            Some("DESKTOP-XYZ".into()),
            Some(2048),
            Some("x86_64".into()),
            None, None, None, None, None, None,
        )
        .unwrap();
        println!("Static-key callback UUID: {}", agent.callback_uuid());
    }

    // ── Full lifecycle: get_tasking → post_response ───────
    {
        let c2 = HttpC2 { key_b64: None };

        // 1. Checkin
        let agent = MythicAgent::easy_checkin(
            payload_uuid,
            &c2,
            vec!["10.0.0.2".into()],
            Some("linux".into()),
            Some("operator".into()),
            Some("implant01".into()),
            Some(9999),
            Some("aarch64".into()),
            None, None, None, None, None, None,
        )
        .unwrap();

        // 2. Poll for tasks
        match agent.get_tasking(1, &c2) {
            Ok(resp) => {
                for task in &resp.tasks {
                    println!("Received task {}: {}", task.id, task.command);

                    // 3. Execute and respond
                    let _ = agent.post_response(
                        vec![TaskResponse::completed(task.id, "task executed successfully")],
                        &c2,
                    );
                }
            }
            Err(e) => eprintln!("get_tasking failed: {e}"),
        }
    }

    println!("All demo scenarios complete.");
}

pub fn failed(task_id: Uuid, error: &str) -> Self

Trait Implementations

impl Clone for TaskResponse

fn clone(&self) -> TaskResponse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskResponse

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

Formats the value using the given formatter.

impl Default for TaskResponse

fn default() -> TaskResponse

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TaskResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TaskResponse

fn eq(&self, other: &TaskResponse) -> 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 TaskResponse

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 TaskResponse