Struct HookRequest 

pub struct HookRequest {
    pub hook_schema: u32,
    pub event: HookEvent,
    pub workspace: PathBuf,
    pub agent_id: String,
    pub tool_call_id: String,
    pub tool_name: String,
    pub input: Value,
    pub output: Option<Value>,
    pub is_error: Option<bool>,
}

The call as basis puts it to one participant.

The same struct reaches both bindings: a subprocess hook reads it as the JSON object on its stdin, and an Interceptor is handed a reference to it. That identity is what “one contract” means concretely — there is no in-process shape a hook cannot see and no wire field an interceptor is denied.

It carries HOOK_SCHEMA_VERSION for the binding that needs it. A subprocess hook is compiled against nothing and must be able to tell when the shape has moved; an interceptor is compiled against this crate and cannot skew, so the field is simply true for it rather than useful.

Fields

hook_schema: u32

event: HookEvent

workspace: PathBuf

The workspace root the run is scoped to, and a subprocess hook’s working directory.

agent_id: String

tool_call_id: String

tool_name: String

input: Value

Parsed tool input when it is valid JSON, else the raw string.

On a PostToolUse request this is the input the tool ran with, after any earlier modification — what happened, not what the model asked for.

output: Option<Value>

What the tool returned, on a PostToolUse request and on no other.

Absent rather than null before the call, because a call that has not run has no output to be null about. A structured result arrives as itself and a text result as a JSON string — the runtime already knows which it produced, so nothing here guesses by re-parsing text that happens to look like JSON.

is_error: Option<bool>

Whether the tool reported failure, beside the output it reported it with. Absent for the same reason.

Named as Event::ToolCompleted names it, so a hook and a stream consumer describe one result the same way.

Implementations

impl HookRequest

pub fn from_call(event: HookEvent, workspace: &Path, call: &HookCall) -> Self

Builds a request from the call the runtime is about to make.

The call carries input_json as a string. Parsing it here rather than passing it through means a participant reads .input.command instead of decoding a nested document — which matters to a shell script and to a Rust interceptor alike; when it is not valid JSON there is nothing to parse and the raw string is carried instead, which is what Event::ToolQueued does with the same value.

workspace is the root basis scoped the run to, and it is also the call’s working directory: mentra’s PreExecutionContext carries one (working_directory, the agent’s base_dir), and it is the key the dispatcher (runtime::dispatch) resolves to this workspace’s runner in the first place — so the two are one path by construction, and a second field would only invite them to disagree.

pub fn from_result( workspace: &Path, call: &HookCall, output: Value, is_error: bool, ) -> Self

Builds a request from the call the runtime has just made, and what it produced.

The event is PostToolUse and not a parameter: an output is the one thing a request can carry that says which seam it came from, so the two cannot be set to disagree.

pub fn with_input(self, input: Value) -> Self

The same request with a different tool input.

What threading a modification through the chain is made of: the next participant is asked about the call as the previous one left it.

pub fn with_output(self, output: Value, is_error: bool) -> Self

The same request with a different result.

The after-the-call twin of with_input, and the same property: a participant judges the result as its predecessors left it, never the one the tool returned.

Trait Implementations

impl Clone for HookRequest

fn clone(&self) -> HookRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HookRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HookRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for HookRequest

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for HookRequest

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 HookRequest