letta 0.1.2

A robust Rust client for the Letta REST API
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

//! Integration tests for the Voice API (beta).

use letta::client::{ClientConfig, LettaClient};
use letta::error::LettaResult;
use letta::types::*;
use serde_json::json;
use std::str::FromStr;

/// Get a test client for the local server.
fn get_test_client() -> LettaResult<LettaClient> {
    let config = ClientConfig::new("http://localhost:8283")?;
    LettaClient::new(config)
}

#[tokio::test]
#[ignore = "Voice API requires OPENAI_API_KEY to be configured"]
async fn test_voice_chat_completions() -> LettaResult<()> {
    let client = get_test_client()?;

    // We need an agent ID to test with
    let agents = client.agents().list(None).await?;

    if agents.is_empty() {
        println!("No agents available for voice test, creating one");
        // Create a test agent
        let request = CreateAgentRequest::builder()
            .name("Voice Test Agent")
            .agent_type(AgentType::MemGPT)
            .model("letta/letta-free")
            .embedding("letta/letta-free")
            .build();

        let agent = client.agents().create(request).await?;
        println!("Created test agent: {}", agent.id);

        // Test voice endpoint with the created agent
        let result = test_voice_endpoint(&client, &agent.id).await;

        // Clean up
        client.agents().delete(&agent.id).await?;

        result
    } else {
        // Use existing agent
        test_voice_endpoint(&client, &agents[0].id).await
    }
}

async fn test_voice_endpoint(client: &LettaClient, agent_id: &LettaId) -> LettaResult<()> {
    println!("Testing voice endpoint with agent: {}", agent_id);

    // Create a test request - since the structure isn't documented,
    // we'll use a generic JSON object
    let request = VoiceChatCompletionRequest {
        data: json!({
            "message": "Hello from voice test",
            "voice_settings": {
                "language": "en",
                "speed": 1.0
            }
        }),
    };

    // Test without user_id first
    let response = client
        .voice()
        .create_voice_chat_completions(agent_id, request.clone(), None)
        .await?;
    println!(
        "Voice response received without user_id: {:?}",
        response.data
    );

    // Also test with user_id
    let response = client
        .voice()
        .create_voice_chat_completions(agent_id, request, Some("test-user-123"))
        .await?;
    println!("Voice response received: {:?}", response.data);
    // Since this is a beta endpoint, we can't make strong assertions
    // about the response structure
    Ok(())
}

#[tokio::test]
async fn test_voice_with_invalid_agent() -> LettaResult<()> {
    let client = get_test_client()?;

    let fake_agent_id = LettaId::from_str("agent-00000000-0000-0000-0000-000000000000").unwrap();

    let request = VoiceChatCompletionRequest {
        data: json!({
            "message": "Test message"
        }),
    };

    let result = client
        .voice()
        .create_voice_chat_completions(&fake_agent_id, request, None)
        .await;

    // We expect this to fail
    match result {
        Err(_) => {
            println!("Expected error for invalid agent ID");
            Ok(())
        }
        Ok(_) => {
            panic!("Expected error but got success for invalid agent ID");
        }
    }
}