relay-knowledge 1.1.17

Graph-database-based knowledge graph project.
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
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::{
    api::AgentAccessPolicy,
    application::AgentRuntimeConfig,
    domain::{
        CODEGRAPH_CONTEXT_DEFAULT_LIMIT, CODEGRAPH_CONTEXT_DEFAULT_MAX_BYTES,
        CODEGRAPH_CONTEXT_MAX_BYTES, CODEGRAPH_CONTEXT_MIN_BYTES, FreshnessPolicy,
    },
    interfaces::agent::acp::{AcpPromptMeta, AcpRelayKnowledgePrompt},
};

use super::*;

#[test]
fn repository_prompt_maps_to_a_bounded_codegraph_request() {
    let mapped = map_prompt_request(
        &agent_config(),
        prompt(AcpRelayKnowledgePrompt {
            query: Some("retry policy".to_owned()),
            repository: Some("docs".to_owned()),
            path_filters: vec![" src ".to_owned()],
            language_filters: vec![" Rust ".to_owned()],
            freshness: Some("wait-until-fresh".to_owned()),
            exclude_generated: Some(true),
            ..AcpRelayKnowledgePrompt::default()
        }),
    )
    .expect("repository prompt should map");

    assert_eq!(mapped.audit_scope().as_deref(), Some("docs"));
    assert_eq!(mapped.source_scope, None);
    assert_eq!(mapped.limit, CODEGRAPH_CONTEXT_DEFAULT_LIMIT);
    let request = mapped
        .into_codegraph_request()
        .expect("request should validate")
        .expect("repository should create codegraph request");
    assert_eq!(request.repository.repository, "docs");
    assert_eq!(request.repository.ref_selector, "HEAD");
    assert_eq!(request.repository.path_filters, ["src"]);
    assert_eq!(request.repository.language_filters, ["Rust"]);
    assert_eq!(request.freshness_policy, FreshnessPolicy::WaitUntilFresh);
    assert!(request.exclude_generated);
}

#[test]
fn graph_prompt_maps_to_hybrid_retrieval_defaults() {
    let mapped = map_prompt_request(
        &agent_config(),
        prompt(AcpRelayKnowledgePrompt {
            query: Some("graph storage".to_owned()),
            source_scope: Some("docs".to_owned()),
            ..AcpRelayKnowledgePrompt::default()
        }),
    )
    .expect("graph prompt should map");

    assert_eq!(mapped.audit_scope().as_deref(), Some("docs"));
    let request = mapped.into_retrieval_request();
    assert_eq!(request.query, "graph storage");
    assert_eq!(request.source_scope.as_deref(), Some("docs"));
    assert_eq!(request.freshness, FreshnessPolicy::AllowStale);
}

#[test]
fn mapping_rejects_empty_queries_and_unknown_freshness() {
    let empty = map_prompt_request(
        &agent_config(),
        prompt(AcpRelayKnowledgePrompt {
            query: Some("  ".to_owned()),
            source_scope: Some("docs".to_owned()),
            ..AcpRelayKnowledgePrompt::default()
        }),
    )
    .expect_err("empty query should fail");
    let invalid_freshness = map_prompt_request(
        &agent_config(),
        prompt(AcpRelayKnowledgePrompt {
            source_scope: Some("docs".to_owned()),
            freshness: Some("eventually".to_owned()),
            ..AcpRelayKnowledgePrompt::default()
        }),
    )
    .expect_err("unknown freshness should fail");

    assert_eq!(empty.kind, AgentAdapterErrorKind::InvalidArgument);
    assert_eq!(
        invalid_freshness.kind,
        AgentAdapterErrorKind::InvalidArgument
    );
}

#[test]
fn codegraph_context_bytes_enforce_domain_bounds() {
    assert_eq!(
        authorize_context_bytes(None, CODEGRAPH_CONTEXT_MAX_BYTES * 4, true)
            .expect("default codegraph budget should be valid"),
        CODEGRAPH_CONTEXT_DEFAULT_MAX_BYTES
    );
    let too_small = authorize_context_bytes(Some(CODEGRAPH_CONTEXT_MIN_BYTES - 1), 1_000_000, true)
        .expect_err("small codegraph budget should be rejected");
    let too_large = authorize_context_bytes(Some(CODEGRAPH_CONTEXT_MAX_BYTES + 1), 1_000_000, true)
        .expect_err("large codegraph budget should be rejected");
    assert_eq!(too_small.kind, AgentAdapterErrorKind::InvalidArgument);
    assert_eq!(too_large.kind, AgentAdapterErrorKind::LimitExceeded);
}

fn prompt(relay_knowledge: AcpRelayKnowledgePrompt) -> AcpPromptRequest {
    AcpPromptRequest {
        prompt: "fallback query".to_owned(),
        request_id: None,
        meta: Some(AcpPromptMeta {
            relay_knowledge: Some(relay_knowledge),
        }),
    }
}

fn agent_config() -> AgentRuntimeConfig {
    AgentRuntimeConfig {
        mcp_streamable_http_enabled: false,
        mcp_endpoint: "/mcp".to_owned(),
        mcp_allowed_origins: Vec::new(),
        access_policy: AgentAccessPolicy::new(
            vec!["docs".to_owned()],
            false,
            50,
            CODEGRAPH_CONTEXT_MAX_BYTES,
            1_000,
            false,
        )
        .expect("policy should be valid"),
        audit_sink_enabled: false,
        audit_queue_depth: AgentRuntimeConfig::DEFAULT_AUDIT_QUEUE_DEPTH,
    }
}