hedos-kernel 1.3.1

The hedos kernel: model records, registry, discovery, install planning, and resolution.
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

//! The streamed output vocabulary: one `CapabilityChunk` per thing a runtime
//! emits — text, separated thinking, timestamped segments, audio, embedding
//! vectors, free-text status, and a terminal `Done` carrying generation stats.

use serde::{Deserialize, Serialize};

use super::tools::ToolCall;

/// A chunk of a raw binary audio payload plus the sample rate it was produced
/// at (captured from the sidecar's ready handshake).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AudioFrame {
    pub data: Vec<u8>,
    pub sample_rate: i64,
}

impl AudioFrame {
    /// An audio frame carrying `data` at `sample_rate` hertz.
    pub fn new(data: Vec<u8>, sample_rate: i64) -> Self {
        Self { data, sample_rate }
    }
}

/// Metrics reported when a generation finishes. Every field is optional — a
/// runtime fills in what it can measure.
#[derive(Debug, Default, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GenerationStats {
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub prompt_tokens: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub completion_tokens: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub duration_ms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub ttft_ms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub load_ms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub finish_reason: Option<String>,
    #[serde(default)]
    pub token_counts_estimated: bool,
}

/// One item in a capability stream (chat, vision, speech, transcription,
/// embeddings).
#[derive(Debug, Clone, PartialEq)]
pub enum CapabilityChunk {
    /// Visible generated text.
    Text(String),
    /// Reasoning the runtime separated from the visible answer.
    Thinking(String),
    /// A transcription segment with its millisecond time span.
    Segment {
        text: String,
        start_ms: i64,
        end_ms: i64,
    },
    /// A raw audio payload at the handshake sample rate.
    Audio(AudioFrame),
    /// An embedding vector.
    Vector(Vec<f64>),
    /// A tool call the model emitted.
    ToolCall(ToolCall),
    /// A free-text status notice.
    Status(String),
    /// The terminal marker, carrying stats when the runtime reported any.
    Done(Option<GenerationStats>),
}