mdstream 0.2.0

Streaming-first Markdown middleware for LLM output (committed + pending blocks, render-agnostic).
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

use crate::types::BlockKind;

#[derive(Debug, Clone, Copy)]
pub struct PendingTransformInput<'a> {
    pub kind: BlockKind,
    pub raw: &'a str,
    pub display: &'a str,
}

#[cfg(feature = "sync")]
pub trait PendingTransformer: Send + Sync {
    /// Transform the pending display string.
    ///
    /// - `kind` is a best-effort hint (block-level).
    /// - `raw` is the original pending text (never mutated).
    /// - `display` is the current pending display string (already includes built-in termination/repair).
    ///
    /// Return `Some(new_display)` to replace `display`, or `None` to leave it unchanged.
    fn transform(&mut self, input: PendingTransformInput<'_>) -> Option<String>;

    fn reset(&mut self) {}
}

#[cfg(not(feature = "sync"))]
pub trait PendingTransformer: Send {
    /// Transform the pending display string.
    ///
    /// - `kind` is a best-effort hint (block-level).
    /// - `raw` is the original pending text (never mutated).
    /// - `display` is the current pending display string (already includes built-in termination/repair).
    ///
    /// Return `Some(new_display)` to replace `display`, or `None` to leave it unchanged.
    fn transform(&mut self, input: PendingTransformInput<'_>) -> Option<String>;

    fn reset(&mut self) {}
}

pub struct FnPendingTransformer<F>(pub F);

#[cfg(not(feature = "sync"))]
impl<F> PendingTransformer for FnPendingTransformer<F>
where
    for<'a> F: FnMut(PendingTransformInput<'a>) -> Option<String> + Send,
{
    fn transform(&mut self, input: PendingTransformInput<'_>) -> Option<String> {
        (self.0)(input)
    }
}

#[cfg(feature = "sync")]
impl<F> PendingTransformer for FnPendingTransformer<F>
where
    for<'a> F: FnMut(PendingTransformInput<'a>) -> Option<String> + Send + Sync,
{
    fn transform(&mut self, input: PendingTransformInput<'_>) -> Option<String> {
        (self.0)(input)
    }
}

fn tail_window(text: &str, window_bytes: usize) -> (&str, usize) {
    if text.len() <= window_bytes {
        return (text, 0);
    }
    let start = text.len() - window_bytes;
    let mut s = start;
    while !text.is_char_boundary(s) {
        s += 1;
    }
    (&text[s..], s)
}

#[derive(Debug, Clone)]
pub struct IncompleteLinkPlaceholderTransformer {
    pub incomplete_link_url: String,
    pub window_bytes: usize,
}

impl Default for IncompleteLinkPlaceholderTransformer {
    fn default() -> Self {
        Self {
            incomplete_link_url: "streamdown:incomplete-link".to_string(),
            window_bytes: 16 * 1024,
        }
    }
}

impl PendingTransformer for IncompleteLinkPlaceholderTransformer {
    fn transform(&mut self, input: PendingTransformInput<'_>) -> Option<String> {
        // Avoid touching code fences entirely.
        if matches!(input.kind, BlockKind::CodeFence) {
            return None;
        }
        let (window, offset) = tail_window(input.display, self.window_bytes);
        let fixed = crate::pending::fix_incomplete_link_or_image(
            window,
            &self.incomplete_link_url,
            true,
            false,
        )?;
        if fixed == window {
            return None;
        }
        let mut out = String::with_capacity(offset + fixed.len());
        out.push_str(&input.display[..offset]);
        out.push_str(&fixed);
        Some(out)
    }
}

#[derive(Debug, Clone, Copy)]
pub struct IncompleteImageDropTransformer {
    pub window_bytes: usize,
}

impl Default for IncompleteImageDropTransformer {
    fn default() -> Self {
        Self {
            window_bytes: 16 * 1024,
        }
    }
}

impl PendingTransformer for IncompleteImageDropTransformer {
    fn transform(&mut self, input: PendingTransformInput<'_>) -> Option<String> {
        if matches!(input.kind, BlockKind::CodeFence) {
            return None;
        }
        let (window, offset) = tail_window(input.display, self.window_bytes);
        let fixed = crate::pending::fix_incomplete_link_or_image(window, "", false, true)?;
        if fixed == window {
            return None;
        }
        let mut out = String::with_capacity(offset + fixed.len());
        out.push_str(&input.display[..offset]);
        out.push_str(&fixed);
        Some(out)
    }
}