macp-runtime 0.7.1

MACP reference runtime: a coordination kernel and gRPC server enforcing session boundaries, message validation, append-only history, modes, and governance policy.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

#[path = "support/common.rs"]
mod common;

use common::{
    canonical_commitment_payload, canonical_start_payload, envelope, get_session_as, print_ack,
    send_as,
};
use macp_runtime::handoff_pb::{HandoffAcceptPayload, HandoffContextPayload, HandoffOfferPayload};
use prost::Message;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = common::connect_client().await?;
    let session_id = common::new_session_id();

    println!("=== Handoff Mode Demo ===\n");

    let ack = send_as(
        &mut client,
        "owner",
        envelope(
            "macp.mode.handoff.v1",
            "SessionStart",
            "m0",
            &session_id,
            "owner",
            canonical_start_payload("escalate support ticket", &["owner", "target"], 60_000),
        ),
    )
    .await?;
    print_ack("session_start", &ack);

    let offer = HandoffOfferPayload {
        handoff_id: "h1".into(),
        target_participant: "target".into(),
        scope: "customer-support".into(),
        reason: "specialist attention required".into(),
    };
    let ack = send_as(
        &mut client,
        "owner",
        envelope(
            "macp.mode.handoff.v1",
            "HandoffOffer",
            "m1",
            &session_id,
            "owner",
            offer.encode_to_vec(),
        ),
    )
    .await?;
    print_ack("handoff_offer", &ack);

    let context = HandoffContextPayload {
        handoff_id: "h1".into(),
        content_type: "text/plain".into(),
        context: b"customer issue: invoice mismatch".to_vec(),
    };
    let ack = send_as(
        &mut client,
        "owner",
        envelope(
            "macp.mode.handoff.v1",
            "HandoffContext",
            "m2",
            &session_id,
            "owner",
            context.encode_to_vec(),
        ),
    )
    .await?;
    print_ack("handoff_context", &ack);

    let accept = HandoffAcceptPayload {
        handoff_id: "h1".into(),
        accepted_by: "target".into(),
        reason: "taking ownership".into(),
        implicit: false,
    };
    let ack = send_as(
        &mut client,
        "target",
        envelope(
            "macp.mode.handoff.v1",
            "HandoffAccept",
            "m3",
            &session_id,
            "target",
            accept.encode_to_vec(),
        ),
    )
    .await?;
    print_ack("handoff_accept", &ack);

    let ack = send_as(
        &mut client,
        "owner",
        envelope(
            "macp.mode.handoff.v1",
            "Commitment",
            "m4",
            &session_id,
            "owner",
            canonical_commitment_payload(
                "c1",
                "handoff.accepted",
                "workflow",
                "target accepted handoff h1",
            ),
        ),
    )
    .await?;
    print_ack("commitment", &ack);

    let session = get_session_as(&mut client, "target", &session_id).await?;
    let meta = session.metadata.expect("metadata");
    println!("[get_session] state={} mode={}", meta.state, meta.mode);

    Ok(())
}