adk-audio 0.4.0

Audio intelligence and pipeline orchestration for ADK-Rust agents
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

//! GenerateMusicTool — generate music via a configured MusicProvider.

use std::sync::Arc;

use async_trait::async_trait;
use serde_json::Value;

use crate::traits::{MusicProvider, MusicRequest};

/// Tool that generates music from a text prompt.
///
/// Accepts JSON `{prompt, duration_secs, genre?}` and returns `{duration_ms}`.
pub struct GenerateMusicTool {
    music: Arc<dyn MusicProvider>,
}

impl GenerateMusicTool {
    /// Create a new `GenerateMusicTool` with the given music provider.
    pub fn new(music: Arc<dyn MusicProvider>) -> Self {
        Self { music }
    }
}

#[async_trait]
impl adk_core::Tool for GenerateMusicTool {
    fn name(&self) -> &str {
        "generate_music"
    }

    fn description(&self) -> &str {
        "Generate music or ambient audio from a text prompt"
    }

    fn parameters_schema(&self) -> Option<Value> {
        Some(serde_json::json!({
            "type": "object",
            "properties": {
                "prompt": { "type": "string", "description": "Text description of desired music" },
                "duration_secs": { "type": "integer", "description": "Duration in seconds" },
                "genre": { "type": "string", "description": "Genre hint (optional)" }
            },
            "required": ["prompt", "duration_secs"]
        }))
    }

    async fn execute(
        &self,
        _ctx: Arc<dyn adk_core::ToolContext>,
        args: Value,
    ) -> adk_core::Result<Value> {
        let prompt = args["prompt"].as_str().unwrap_or_default().to_string();
        let duration_secs = args["duration_secs"].as_u64().unwrap_or(10) as u32;
        let genre = args["genre"].as_str().map(String::from);

        let request = MusicRequest { prompt, duration_secs, genre, ..Default::default() };
        let frame = self
            .music
            .generate(&request)
            .await
            .map_err(|e| adk_core::AdkError::Tool(format!("generate_music: {e}")))?;

        Ok(serde_json::json!({
            "duration_ms": frame.duration_ms
        }))
    }
}