rustglm 1.0.0

Production-oriented async Rust SDK for Zhipu GLM, Realtime, Batch, RAG, and MCP
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

use std::pin::Pin;

use async_trait::async_trait;
use futures_util::Stream;

use crate::{ChatCompletionChunk, ChatCompletionRequest, ChatCompletionResponse, Result};

pub type ChatStream = Pin<Box<dyn Stream<Item = Result<ChatCompletionChunk>> + Send>>;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProviderCapabilities {
    pub streaming: bool,
    pub multimodal: bool,
    pub tools: bool,
    pub embeddings: bool,
    pub images: bool,
    pub audio: bool,
    pub video: bool,
    pub files: bool,
    pub batches: bool,
    pub realtime: bool,
}

impl ProviderCapabilities {
    pub const fn zhipu() -> Self {
        Self {
            streaming: true,
            multimodal: true,
            tools: true,
            embeddings: true,
            images: true,
            audio: true,
            video: true,
            files: true,
            batches: true,
            realtime: cfg!(feature = "realtime"),
        }
    }

    pub const fn openai_compatible() -> Self {
        Self {
            streaming: true,
            multimodal: true,
            tools: true,
            embeddings: false,
            images: false,
            audio: false,
            video: false,
            files: false,
            batches: false,
            realtime: false,
        }
    }
}

#[async_trait]
pub trait ChatProvider: Send + Sync {
    fn name(&self) -> &str;
    fn capabilities(&self) -> ProviderCapabilities;
    async fn complete(&self, request: ChatCompletionRequest) -> Result<ChatCompletionResponse>;
    async fn stream(&self, request: ChatCompletionRequest) -> Result<ChatStream>;
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn zhipu_capabilities_are_complete() {
        let value = ProviderCapabilities::zhipu();
        assert!(value.streaming);
        assert!(value.multimodal);
        assert!(value.tools);
        assert!(value.embeddings);
        assert!(value.images);
        assert!(value.audio);
        assert!(value.video);
        assert!(value.files);
        assert!(value.batches);
        assert_eq!(value.realtime, cfg!(feature = "realtime"));
    }

    #[test]
    fn compatible_capabilities_do_not_overclaim() {
        let value = ProviderCapabilities::openai_compatible();
        assert!(value.streaming);
        assert!(value.multimodal);
        assert!(value.tools);
        assert!(!value.embeddings);
        assert!(!value.images);
        assert!(!value.audio);
        assert!(!value.video);
        assert!(!value.files);
        assert!(!value.batches);
        assert!(!value.realtime);
    }
}