crabtalk-core 0.0.18

Core types and traits for the Crabtalk agent runtime
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

//! Streaming response abstractions for the unified LLM Interfaces

use crate::model::{
    FinishReason,
    response::{Choice, CompletionMeta, Delta},
    tool::ToolCall,
};
use serde::Deserialize;

/// A streaming chat completion chunk
#[derive(Debug, Clone, Deserialize, Default)]
pub struct StreamChunk {
    /// Completion metadata
    #[serde(flatten)]
    pub meta: CompletionMeta,

    /// The list of completion choices (with delta content)
    pub choices: Vec<Choice>,

    /// Token usage statistics (only in final chunk)
    pub usage: Option<crate::model::Usage>,
}

impl StreamChunk {
    /// Create a new tool chunk
    pub fn tool(calls: &[ToolCall]) -> Self {
        Self {
            choices: vec![Choice {
                delta: Delta {
                    tool_calls: Some(calls.to_vec()),
                    ..Default::default()
                },
                ..Default::default()
            }],
            ..Default::default()
        }
    }

    /// Create a content-only chunk with the given text.
    pub fn text(content: String) -> Self {
        Self {
            choices: vec![Choice {
                delta: Delta {
                    content: Some(content),
                    ..Default::default()
                },
                ..Default::default()
            }],
            ..Default::default()
        }
    }

    /// Create a separator chunk (newline) emitted between tool-call rounds.
    pub fn separator() -> Self {
        Self {
            choices: vec![Choice {
                delta: Delta {
                    content: Some("\n".into()),
                    ..Default::default()
                },
                ..Default::default()
            }],
            ..Default::default()
        }
    }

    /// Get the content of the first choice
    pub fn content(&self) -> Option<&str> {
        self.choices
            .first()
            .and_then(|c| c.delta.content.as_deref())
            .filter(|s| !s.is_empty())
    }

    /// Get the reasoning content of the first choice
    pub fn reasoning_content(&self) -> Option<&str> {
        self.choices
            .first()
            .and_then(|c| c.delta.reasoning_content.as_deref())
            .filter(|s| !s.is_empty())
    }

    /// Get the tool calls of the first choice
    pub fn tool_calls(&self) -> Option<&[ToolCall]> {
        self.choices
            .first()
            .and_then(|choice| choice.delta.tool_calls.as_deref())
    }

    /// Get the reason the model stopped generating
    pub fn reason(&self) -> Option<&FinishReason> {
        self.choices
            .first()
            .and_then(|choice| choice.finish_reason.as_ref())
    }
}