a3s-ahp 2.4.0

Agent Harness Protocol v2.4 — Universal, transport-agnostic protocol for supervising autonomous AI agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! HTTP server example

use a3s_ahp::server::EventHandler;
use a3s_ahp::{AhpEvent, AhpServer, Decision, QueryRequest, QueryResponse, Result};
use async_trait::async_trait;
use std::sync::Arc;

/// Simple event handler that blocks dangerous commands
struct SimpleHandler;

#[async_trait]
impl EventHandler for SimpleHandler {
    async fn handle_event(&self, event: &AhpEvent) -> Result<Decision> {
        match event.event_type {
            a3s_ahp::EventType::PreAction => {
                // Check if command is dangerous
                if let Some(command) = event
                    .payload
                    .get("arguments")
                    .and_then(|args| args.get("command"))
                    .and_then(|cmd| cmd.as_str())
                {
                    if command.contains("rm -rf") || command.contains("dd if=") {
                        return Ok(Decision::Block {
                            reason: "Dangerous command detected".to_string(),
                            metadata: None,
                        });
                    }
                }
                Ok(Decision::Allow {
                    modified_payload: None,
                    metadata: None,
                })
            }
            _ => Ok(Decision::Allow {
                modified_payload: None,
                metadata: None,
            }),
        }
    }

    async fn handle_notification(&self, event: &AhpEvent) -> Result<()> {
        tracing::info!("Received notification: {:?}", event.event_type);
        Ok(())
    }

    async fn handle_query(&self, query: &QueryRequest) -> Result<QueryResponse> {
        let question = query
            .payload
            .get("question")
            .and_then(|q| q.as_str())
            .unwrap_or("");

        if question.to_lowercase().contains("delete") {
            Ok(QueryResponse {
                answer: serde_json::json!("no"),
                reason: Some("Deletion requires explicit confirmation".to_string()),
                alternatives: Some(vec![
                    "Move to trash".to_string(),
                    "Create backup first".to_string(),
                ]),
            })
        } else {
            Ok(QueryResponse {
                answer: serde_json::json!("yes"),
                reason: Some("No concerns detected".to_string()),
                alternatives: None,
            })
        }
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt::init();

    // Create server with simple handler
    let handler = Arc::new(SimpleHandler);
    let server = Arc::new(AhpServer::new(handler));

    // Create HTTP server
    let http_server = a3s_ahp::transport::http::HttpServer::new(server);

    println!("Starting HTTP server on http://0.0.0.0:8080/ahp");
    println!("Press Ctrl+C to stop");

    // Run server
    http_server.run(([0, 0, 0, 0], 8080)).await?;

    Ok(())
}