opencrabs 0.3.60

The autonomous, self-improving AI agent. Single Rust binary. Every channel. Install with: cargo install opencrabs
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

//! OpenAI-compatible TTS provider.
//!
//! Supports any OpenAI-compatible `/v1/audio/speech` endpoint, including:
//! - Official OpenAI API
//! - Ollama (`http://localhost:11434/v1`)
//! - LocalAI, OMLX, Unsloth, etc.

use anyhow::{Context, Result};
use reqwest::Client;
use url::Url;

/// Synthesize speech using an OpenAI-compatible TTS endpoint.
///
/// # Arguments
/// * `text` - Text to synthesize
/// * `api_key` - API key for the endpoint
/// * `voice` - Voice name (e.g. "ash", "alloy")
/// * `model` - Model name (e.g. "gpt-4o-mini-tts")
/// * `base_url` - Base URL of the endpoint (e.g. "https://api.openai.com" or "http://localhost:11434")
///
/// # Returns
/// OGG/Opus audio bytes suitable for Telegram voice notes.
pub async fn synthesize_speech(
    text: &str,
    api_key: &str,
    voice: &str,
    model: &str,
    base_url: &str,
) -> Result<Vec<u8>> {
    if text.is_empty() {
        anyhow::bail!("Cannot synthesize empty text");
    }

    let speech_url = build_endpoint_url(base_url, "v1/audio/speech")?;

    let client = Client::new();

    let body = serde_json::json!({
        "model": model,
        "input": text,
        "voice": voice,
        "response_format": "opus",
    });

    let response = client
        .post(&speech_url)
        .header("Authorization", format!("Bearer {}", api_key))
        .header("Content-Type", "application/json")
        .json(&body)
        .send()
        .await
        .context("Failed to send TTS request")?;

    let status = response.status();
    if !status.is_success() {
        let error_text = response.text().await.unwrap_or_default();
        anyhow::bail!("TTS error ({}): {}", status, error_text);
    }

    let audio_bytes = response
        .bytes()
        .await
        .context("Failed to read TTS audio bytes")?
        .to_vec();

    tracing::info!(
        "OpenAI-compatible TTS: generated {} bytes of audio (voice={}, model={}, url={})",
        audio_bytes.len(),
        voice,
        model,
        speech_url,
    );

    Ok(audio_bytes)
}

/// Build a properly joined endpoint URL from base_url + path.
///
/// Handles missing trailing slashes, `v1/` prefix variations, etc.
pub fn build_endpoint_url(base_url: &str, path: &str) -> Result<String> {
    let mut url = Url::parse(base_url).context("Invalid base URL")?;
    // Ensure trailing slash so `join` replaces the last segment
    if !url.path().ends_with('/') {
        url.set_path(&format!("{}/", url.path()));
    }
    let joined = url.join(path).context("Failed to join URL path")?;
    Ok(joined.to_string())
}