harn-serve 0.10.141

Shared outbound workflow server core for Harn adapters
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! How MCP server activity reaches an ACP client.
//!
//! Progress, elicitation, catalog changes and auth prompts all cross the
//! adapter as `ext` session updates, so they are asserted together: the shape
//! one of them projects is the shape the others have to match.

use super::*;

#[tokio::test(flavor = "current_thread")]
async fn mcp_progress_notification_reaches_acp_as_ext_event() {
    let actual = collect_notifications(vec![AgentEvent::McpNotification {
        session_id: "session-1".to_string(),
        server: "filesystem".to_string(),
        method: "notifications/progress".to_string(),
        direction: "notification".to_string(),
        params: serde_json::json!({
            "progressToken": "tok-1",
            "progress": 42.0,
            "total": 100.0,
            "server": "filesystem",
            "tool": "search_files"
        }),
    }])
    .await;

    let notification = &actual[0];
    assert_eq!(notification["method"], HARN_AGENT_EVENT_METHOD);
    let params = &notification["params"];
    assert_eq!(params["kind"], "mcp_notification");
    assert_eq!(params["sessionId"], "session-1");
    assert_eq!(params["server"], "filesystem");
    assert_eq!(params["method"], "notifications/progress");
    assert_eq!(params["direction"], "notification");
    assert_eq!(params["params"]["progress"], 42.0);
    assert_eq!(params["params"]["progressToken"], "tok-1");
    assert!(
        HARN_AGENT_EVENT_KINDS.contains(&"mcp_notification"),
        "mcp_notification must be advertised so clients can subscribe"
    );
}

#[tokio::test(flavor = "current_thread")]
async fn mcp_elicitation_request_reaches_acp_as_ext_event() {
    let actual = collect_notifications(vec![AgentEvent::McpNotification {
        session_id: "session-1".to_string(),
        server: "deploy-bot".to_string(),
        method: "elicitation/create".to_string(),
        direction: "request".to_string(),
        params: serde_json::json!({
            "message": "Confirm production deploy?",
            "requestedSchema": {"type": "object"}
        }),
    }])
    .await;

    let notification = &actual[0];
    assert_eq!(notification["method"], HARN_AGENT_EVENT_METHOD);
    let params = &notification["params"];
    assert_eq!(params["kind"], "mcp_notification");
    assert_eq!(params["direction"], "request");
    assert_eq!(params["method"], "elicitation/create");
    assert_eq!(params["params"]["message"], "Confirm production deploy?");
}

#[tokio::test(flavor = "current_thread")]
async fn mcp_catalog_changed_reaches_acp_as_ext_event() {
    let actual = collect_notifications(vec![AgentEvent::McpCatalogChanged {
        session_id: "session-1".to_string(),
        server: Some("github".to_string()),
        reason: "list_changed".to_string(),
    }])
    .await;

    let notification = &actual[0];
    assert_eq!(notification["method"], HARN_AGENT_EVENT_METHOD);
    let params = &notification["params"];
    assert_eq!(params["kind"], "mcp_catalog_changed");
    assert_eq!(params["sessionId"], "session-1");
    assert_eq!(params["server"], "github");
    assert_eq!(params["reason"], "list_changed");
    assert!(
        HARN_AGENT_EVENT_KINDS.contains(&"mcp_catalog_changed"),
        "mcp_catalog_changed must be advertised so clients can subscribe"
    );
}

#[tokio::test(flavor = "current_thread")]
async fn mcp_catalog_changed_allows_serverless_allowlist_update() {
    let actual = collect_notifications(vec![AgentEvent::McpCatalogChanged {
        session_id: "session-1".to_string(),
        server: None,
        reason: "allowlist_updated".to_string(),
    }])
    .await;

    let params = &actual[0]["params"];
    assert_eq!(params["kind"], "mcp_catalog_changed");
    assert!(params["server"].is_null());
    assert_eq!(params["reason"], "allowlist_updated");
}

#[tokio::test(flavor = "current_thread")]
async fn mcp_auth_required_reaches_acp_as_ext_event() {
    let actual = collect_notifications(vec![AgentEvent::McpAuthRequired {
        session_id: "session-1".to_string(),
        server: "notion".to_string(),
        resource: "https://mcp.notion.com".to_string(),
        scope: Some("read write".to_string()),
    }])
    .await;

    let notification = &actual[0];
    assert_eq!(notification["method"], HARN_AGENT_EVENT_METHOD);
    let params = &notification["params"];
    assert_eq!(params["kind"], "mcp_auth_required");
    assert_eq!(params["sessionId"], "session-1");
    assert_eq!(params["server"], "notion");
    assert_eq!(params["resource"], "https://mcp.notion.com");
    assert_eq!(params["scope"], "read write");
    assert!(
        HARN_AGENT_EVENT_KINDS.contains(&"mcp_auth_required"),
        "mcp_auth_required must be advertised so clients can subscribe"
    );
}

#[tokio::test(flavor = "current_thread")]
async fn mcp_auth_required_omits_absent_scope() {
    let actual = collect_notifications(vec![AgentEvent::McpAuthRequired {
        session_id: "session-1".to_string(),
        server: "notion".to_string(),
        resource: "https://mcp.notion.com".to_string(),
        scope: None,
    }])
    .await;

    let params = &actual[0]["params"];
    assert_eq!(params["kind"], "mcp_auth_required");
    assert!(params["scope"].is_null());
}