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

use crate::{
    api::{AgentRetrievalResult, CodeGraphContextResponse, RequestContext, RuntimeIdentity},
    application::RelayKnowledgeService,
};

use super::prompt_mapping::MappedPromptRequest;

pub(super) struct AcpPromptResult {
    pub(super) retrieval: Option<AgentRetrievalResult>,
    pub(super) codegraph: Option<CodeGraphContextResponse>,
}

impl AcpPromptResult {
    pub(super) fn result_count(&self) -> usize {
        self.retrieval
            .as_ref()
            .map(|result| result.results.len())
            .or_else(|| {
                self.codegraph
                    .as_ref()
                    .map(|context| context.pack.entry_points.len())
            })
            .unwrap_or(0)
    }

    pub(super) fn truncated(&self) -> bool {
        self.retrieval
            .as_ref()
            .map(|result| result.truncated)
            .or_else(|| self.codegraph.as_ref().map(|context| context.truncated))
            .unwrap_or(false)
    }
}

// Keep the stable 1.x `ApiError` return type shared with the application boundary. Changing the
// DTO's public metadata field to a box is reserved for the 2.0 contract cleanup.
#[allow(clippy::result_large_err)]
pub(super) async fn run_mapped_prompt(
    service: RelayKnowledgeService,
    mapped: MappedPromptRequest,
    context: RequestContext,
    identity: RuntimeIdentity,
    elapsed_ms: u64,
) -> Result<AcpPromptResult, crate::api::ApiError> {
    if mapped.repository.is_some() {
        let request = mapped
            .into_codegraph_request()
            .map_err(|error| crate::api::ApiError::invalid_argument(error.to_string()))?
            .expect("repository presence creates a codegraph request");
        let response = service.codegraph_context(request, context).await?;
        return Ok(AcpPromptResult {
            retrieval: None,
            codegraph: Some(response),
        });
    }

    let max_context_bytes = mapped.max_context_bytes;
    let response = service
        .retrieve_context(mapped.into_retrieval_request(), context)
        .await?;
    Ok(AcpPromptResult {
        retrieval: Some(AgentRetrievalResult::from_retrieval(
            response,
            identity,
            max_context_bytes,
            elapsed_ms,
        )),
        codegraph: None,
    })
}

#[cfg(test)]
#[path = "prompt_context_tests.rs"]
mod tests;