Struct PostToolUseEvent 

pub struct PostToolUseEvent {
    pub tool_name: String,
    pub tool_input: Value,
    pub tool_use_id: String,
    pub tool_result: Value,
    pub history: Vec<Value>,
}

Event fired after a tool completes execution, enabling audit, filtering, or validation.

This event provides complete visibility into what a tool did, including both the input parameters and the output result. Use this for auditing, metrics collection, output filtering, or post-execution validation.

Use Cases

• Audit logging: Record all tool executions with inputs and outputs for compliance
• Output filtering: Redact sensitive information from tool results
• Metrics collection: Track tool performance, success rates, error patterns
• Result validation: Ensure tool outputs meet quality or safety standards
• Error handling: Implement custom error recovery or alerting

Fields

• tool_name: The name of the tool that was executed
• tool_input: The parameters that were actually used (may have been modified by PreToolUse hooks)
• tool_use_id: Unique identifier for this invocation (matches PreToolUseEvent.tool_use_id)
• tool_result: The result returned by the tool (contains either success data or error info)
• history: Read-only snapshot of conversation history including this tool’s execution

Example: Audit Logging

use open_agent::{PostToolUseEvent, HookDecision};

async fn audit_logger(event: PostToolUseEvent) -> Option<HookDecision> {
    // Log all tool executions to your audit system
    let is_error = event.tool_result.get("error").is_some();

    println!(
        "[AUDIT] Tool: {}, ID: {}, Status: {}",
        event.tool_name,
        event.tool_use_id,
        if is_error { "ERROR" } else { "SUCCESS" }
    );

    // Send to external logging service
    // log_to_service(&event).await;

    None // Don't interfere with execution
}

Example: Sensitive Data Redaction

use open_agent::{PostToolUseEvent, HookDecision};
use serde_json::json;

async fn redact_secrets(event: PostToolUseEvent) -> Option<HookDecision> {
    // Redact API keys from Read tool output
    if event.tool_name == "Read" {
        if let Some(content) = event.tool_result.get("content") {
            if let Some(text) = content.as_str() {
                if text.contains("API_KEY=") {
                    let redacted = text.replace(
                        |c: char| c.is_alphanumeric(),
                        "*"
                    );
                    // Note: PostToolUse hooks typically don't modify results,
                    // but you could log this for security review
                    println!("Warning: Potential API key detected in output");
                }
            }
        }
    }
    None
}

Note on Modification

While HookDecision theoretically allows modification in PostToolUse hooks, this is rarely used in practice. The tool has already executed, and most agents don’t support modifying historical results. PostToolUse hooks are primarily for observation and auditing.

Fields

tool_name: String

Name of the tool that was executed

tool_input: Value

Input parameters that were actually used (may differ from original if modified by PreToolUse)

tool_use_id: String

Unique identifier for this tool use (correlates with PreToolUseEvent)

tool_result: Value

Result returned by the tool - may contain “content” on success or “error” on failure

history: Vec<Value>

Snapshot of conversation history (read-only) including this tool execution

Implementations

impl PostToolUseEvent

pub fn new( tool_name: String, tool_input: Value, tool_use_id: String, tool_result: Value, history: Vec<Value>, ) -> Self

Creates a new PostToolUseEvent.

This constructor is typically called by the agent runtime after tool execution, not by user code. Users receive instances of this struct in their hook handlers.

Trait Implementations

impl Clone for PostToolUseEvent

fn clone(&self) -> PostToolUseEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PostToolUseEvent

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

Formats the value using the given formatter.