origin-asset 0.1.0

Rust SDK for Origin platform — asset generation, AI search, and knowledge graph services
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

pub mod types;
pub use types::*;

use serde::Deserialize;
use serde_json::{json, Value};

use crate::error::Result;
use crate::transport::HttpTransport;

#[derive(Debug, Clone)]
pub struct SearchClient {
    pub(crate) transport: HttpTransport,
}

impl SearchClient {
    pub fn new(transport: HttpTransport) -> Self {
        Self { transport }
    }

    pub async fn search(
        &self,
        query: &str,
        options: Option<SearchOptions>,
    ) -> Result<SearchResponse> {
        let options = options.unwrap_or(SearchOptions {
            mode: None,
            model: None,
            split: None,
            num: None,
        });

        let mut body = json!({ "query": query });
        let payload = body
            .as_object_mut()
            .expect("search request payload should be an object");

        if let Some(mode) = options.mode {
            payload.insert("mode".to_string(), serde_json::to_value(mode)?);
        }
        if let Some(model) = options.model {
            payload.insert("model".to_string(), Value::String(model));
        }
        if let Some(split) = options.split {
            payload.insert("split".to_string(), json!(split));
        }
        if let Some(num) = options.num {
            payload.insert("num".to_string(), json!(num));
        }

        self.transport.post("/api/search", &body).await
    }

    pub async fn search_fast(&self, query: &str) -> Result<SearchResponse> {
        self.search(
            query,
            Some(SearchOptions {
                mode: Some(SearchMode::Fast),
                model: None,
                split: None,
                num: None,
            }),
        )
        .await
    }

    pub async fn search_deep(&self, query: &str) -> Result<SearchResponse> {
        self.search(
            query,
            Some(SearchOptions {
                mode: Some(SearchMode::Deep),
                model: None,
                split: None,
                num: None,
            }),
        )
        .await
    }

    pub async fn search_answer(&self, query: &str) -> Result<SearchResponse> {
        self.search(
            query,
            Some(SearchOptions {
                mode: Some(SearchMode::Answer),
                model: None,
                split: None,
                num: None,
            }),
        )
        .await
    }

    pub async fn models(&self) -> Result<Vec<String>> {
        let response: ModelsResponse = self.transport.get("/api/models").await?;
        Ok(response.models)
    }

    pub async fn providers(&self) -> Result<Value> {
        self.transport.get("/api/providers").await
    }

    pub async fn health(&self) -> Result<bool> {
        let payload: Value = self.transport.get("/health").await?;

        let status = payload.get("status").and_then(Value::as_str).or_else(|| {
            payload
                .get("data")
                .and_then(|data| data.get("status"))
                .and_then(Value::as_str)
        });

        Ok(matches!(status, Some("ok")))
    }
}

#[derive(Debug, Deserialize)]
struct ModelsResponse {
    models: Vec<String>,
}