siumai 0.10.3

A unified LLM interface library for Rust
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Streaming event types for real-time responses

use super::chat::ChatResponse;
use super::common::FinishReason;
use super::common::{ResponseMetadata, Usage};
use crate::error::LlmError;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Chat streaming event
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ChatStreamEvent {
    /// Content delta (incremental text)
    ContentDelta {
        /// The incremental text content
        delta: String,
        /// Index of the choice (for multiple responses)
        index: Option<usize>,
    },
    /// Tool call delta
    ToolCallDelta {
        /// Tool call ID
        id: String,
        /// Function name (if this is the start of a tool call)
        function_name: Option<String>,
        /// Incremental arguments
        arguments_delta: Option<String>,
        /// Index of the choice
        index: Option<usize>,
    },
    /// Thinking/reasoning content delta (for models that support internal reasoning)
    /// This includes content from `<think>` tags, reasoning fields, and thinking modes
    ThinkingDelta {
        /// The incremental thinking/reasoning content
        delta: String,
    },
    /// Usage statistics update
    UsageUpdate {
        /// Token usage information
        usage: Usage,
    },
    /// Stream start event with metadata
    StreamStart {
        /// Response metadata
        metadata: ResponseMetadata,
    },
    /// Stream end event with final response
    StreamEnd {
        /// Final response
        response: ChatResponse,
    },
    /// Error occurred during streaming
    Error {
        /// Error message
        error: String,
    },
}

/// Audio streaming event
#[derive(Debug, Clone)]
pub enum AudioStreamEvent {
    /// Audio data chunk
    AudioDelta {
        /// Audio data bytes
        data: Vec<u8>,
        /// Audio format
        format: String,
    },
    /// Metadata about the audio
    Metadata {
        /// Sample rate
        sample_rate: Option<u32>,
        /// Duration estimate
        duration: Option<f32>,
        /// Additional metadata
        metadata: HashMap<String, serde_json::Value>,
    },
    /// Stream finished
    Done {
        /// Total duration
        duration: Option<f32>,
        /// Final metadata
        metadata: HashMap<String, serde_json::Value>,
    },
    /// Error occurred during streaming
    Error {
        /// Error message
        error: String,
    },
}

/// Completion streaming event (for non-chat completions)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CompletionStreamEvent {
    /// Text delta
    TextDelta {
        /// The incremental text
        text: String,
        /// Index of the completion
        index: Option<usize>,
    },
    /// Usage statistics
    Usage {
        /// Token usage information
        usage: Usage,
    },
    /// Stream finished
    Done {
        /// Final finish reason
        finish_reason: Option<FinishReason>,
        /// Final usage statistics
        usage: Option<Usage>,
    },
    /// Error occurred
    Error {
        /// Error message
        error: String,
    },
}

// Stream types
use futures::Stream;
use std::pin::Pin;

/// Audio stream for streaming TTS
pub type AudioStream =
    Pin<Box<dyn Stream<Item = Result<AudioStreamEvent, LlmError>> + Send + Sync>>;

/// Completion stream for streaming completions
pub type CompletionStream =
    Pin<Box<dyn Stream<Item = Result<CompletionStreamEvent, LlmError>> + Send + Sync>>;

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

    // Test that stream types are Send + Sync for multi-threading
    #[test]
    fn test_stream_types_are_send_sync() {
        // Test that stream types can be used in Arc (requires Send + Sync)
        fn test_arc_usage() {
            let _: Option<Arc<AudioStream>> = None;
            let _: Option<Arc<CompletionStream>> = None;
        }

        test_arc_usage();
    }
}