telepi 0.2.0

Telegram bridge for the Pi coding agent — Rust implementation
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

use std::path::Path;

use crate::error::{Result, TelePiError};

/// Result of a voice transcription.
#[derive(Debug, Clone)]
pub struct TranscriptionResult {
    pub text: String,
    pub backend: VoiceBackend,
    pub duration_ms: u64,
}

/// Available voice transcription backends.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VoiceBackend {
    /// Parakeet CoreML — Apple Silicon only
    Parakeet,
    /// Sherpa-ONNX — cross-platform
    SherpaOnnx,
    /// OpenAI Whisper — cloud
    OpenAi,
}

impl std::fmt::Display for VoiceBackend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Parakeet => write!(f, "parakeet"),
            Self::SherpaOnnx => write!(f, "sherpa-onnx"),
            Self::OpenAi => write!(f, "openai"),
        }
    }
}

/// Check which voice backends are available on this system.
pub fn available_backends() -> Vec<VoiceBackend> {
    let mut backends = Vec::new();

    // Parakeet CoreML — macOS Apple Silicon only
    #[cfg(target_os = "macos")]
    {
        if which::which("parakeet").is_ok() {
            backends.push(VoiceBackend::Parakeet);
        }
    }

    // Sherpa-ONNX — cross-platform
    if which::which("sherpa-onnx").is_ok() || std::env::var("SHERPA_ONNX_MODEL_DIR").is_ok() {
        backends.push(VoiceBackend::SherpaOnnx);
    }

    // OpenAI Whisper — cloud, needs API key
    if std::env::var("OPENAI_API_KEY").is_ok() {
        backends.push(VoiceBackend::OpenAi);
    }

    backends
}

/// Transcribe an audio file using the best available backend.
pub async fn transcribe(file_path: &Path) -> Result<TranscriptionResult> {
    let backends = available_backends();
    let backend = backends.first().copied().ok_or_else(|| {
        TelePiError::Voice("no voice transcription backend available".into())
    })?;

    match backend {
        VoiceBackend::Parakeet => transcribe_parakeet(file_path).await,
        VoiceBackend::SherpaOnnx => transcribe_sherpa(file_path).await,
        VoiceBackend::OpenAi => transcribe_openai(file_path).await,
    }
}

/// Transcribe using Parakeet CoreML.
async fn transcribe_parakeet(_file_path: &Path) -> Result<TranscriptionResult> {
    // TODO: Implement Parakeet CoreML transcription
    Err(TelePiError::Voice("Parakeet transcription not yet implemented".into()))
}

/// Transcribe using Sherpa-ONNX.
async fn transcribe_sherpa(_file_path: &Path) -> Result<TranscriptionResult> {
    // TODO: Implement Sherpa-ONNX transcription
    Err(TelePiError::Voice("Sherpa-ONNX transcription not yet implemented".into()))
}

/// Transcribe using OpenAI Whisper API.
async fn transcribe_openai(file_path: &Path) -> Result<TranscriptionResult> {
    let api_key = std::env::var("OPENAI_API_KEY")
        .map_err(|_| TelePiError::Voice("OPENAI_API_KEY not set".into()))?;

    let client = reqwest::Client::new();

    let file_bytes = tokio::fs::read(file_path).await?;
    let file_name = file_path
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("audio.ogg");

    let file_part = reqwest::multipart::Part::bytes(file_bytes)
        .file_name(file_name.to_string())
        .mime_str("audio/ogg")
        .map_err(|e| TelePiError::Voice(format!("invalid mime type: {e}")))?;

    let form = reqwest::multipart::Form::new()
        .part("file", file_part)
        .text("model", "whisper-1")
        .text("response_format", "text");

    let response = client
        .post("https://api.openai.com/v1/audio/transcriptions")
        .bearer_auth(&api_key)
        .multipart(form)
        .send()
        .await?;

    if !response.status().is_success() {
        let status = response.status();
        let body = response.text().await.unwrap_or_default();
        return Err(TelePiError::Voice(format!(
            "OpenAI Whisper API error {status}: {body}"
        )));
    }

    let text = response.text().await?;

    Ok(TranscriptionResult {
        text,
        backend: VoiceBackend::OpenAi,
        duration_ms: 0,
    })
}