Skip to main content

zai_rs/knowledge/
list.rs

1use super::types::KnowledgeListResponse;
2use crate::ZaiResult;
3use crate::client::ZaiClient;
4
5/// Query parameters for knowledge list API
6#[derive(Debug, Clone, serde::Serialize, validator::Validate)]
7pub struct KnowledgeListQuery {
8    /// Page index starting from 1 (default 1)
9    #[serde(skip_serializing_if = "Option::is_none")]
10    #[validate(range(min = 1))]
11    pub page: Option<u32>,
12    /// Page size (default 10)
13    #[serde(skip_serializing_if = "Option::is_none")]
14    #[validate(range(min = 1))]
15    pub size: Option<u32>,
16}
17
18impl KnowledgeListQuery {
19    /// Create a new query (page 1, size 10).
20    pub fn new() -> Self {
21        Self {
22            page: Some(1),
23            size: Some(10),
24        }
25    }
26    /// Set the page index (1-based).
27    pub fn with_page(mut self, page: u32) -> Self {
28        self.page = Some(page);
29        self
30    }
31    /// Set the page size.
32    pub fn with_size(mut self, size: u32) -> Self {
33        self.size = Some(size);
34        self
35    }
36
37    /// Build the `(&str, String)` query pairs (in stable order) used to form
38    /// the request URL.
39    fn pairs(&self) -> Vec<(&'static str, String)> {
40        let mut params: Vec<(&'static str, String)> = Vec::new();
41        if let Some(page) = self.page.as_ref() {
42            params.push(("page", page.to_string()));
43        }
44        if let Some(size) = self.size.as_ref() {
45            params.push(("size", size.to_string()));
46        }
47        params
48    }
49}
50
51impl Default for KnowledgeListQuery {
52    fn default() -> Self {
53        Self::new()
54    }
55}
56
57/// Knowledge list request (GET /llm-application/open/knowledge)
58///
59/// Credentials and transport live on the [`ZaiClient`], passed to
60/// [`send_via`](Self::send_via).
61pub struct KnowledgeListRequest {
62    query: KnowledgeListQuery,
63}
64
65impl KnowledgeListRequest {
66    /// Create a new knowledge-list request (default query: page 1, size 10).
67    pub fn new() -> Self {
68        Self {
69            query: KnowledgeListQuery::new(),
70        }
71    }
72
73    /// Apply a query (replaces the current one).
74    pub fn with_query(mut self, q: KnowledgeListQuery) -> Self {
75        self.query = q;
76        self
77    }
78
79    /// Send via a [`ZaiClient`] and parse the typed response.
80    pub async fn send_via(&self, client: &ZaiClient) -> ZaiResult<KnowledgeListResponse> {
81        use validator::Validate;
82
83        self.query.validate()?;
84        let params = self.query.pairs();
85        let route = crate::client::routes::KNOWLEDGE_LIST;
86        let url = client.endpoints().resolve_route_with_query(
87            route,
88            &[],
89            &params
90                .iter()
91                .map(|(k, v)| (*k, v.as_str()))
92                .collect::<Vec<_>>(),
93        )?;
94        client
95            .send_empty::<KnowledgeListResponse>(route.method(), url)
96            .await
97    }
98}
99
100impl Default for KnowledgeListRequest {
101    fn default() -> Self {
102        Self::new()
103    }
104}