qai-sdk 0.1.26

Universal Rust SDK for AI Providers
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

use qai_sdk::mcp::{McpClient, McpTransport};
use std::time::Duration;
use tokio::time::sleep;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Connecting to dummy MCP server...");
    let transport = McpTransport::stdio("node", vec!["examples/dummy_mcp.js"]);
    let mcp_client = McpClient::connect(transport).await?;

    let uri = "file:///logs/app.log";
    
    // Create the broadcast channel stream
    let mut rx = mcp_client.resource_updates();

    println!("Subscribing to {}", uri);
    mcp_client.subscribe_resource(uri).await?;

    println!("Waiting for live updates...");
    
    // We should receive a few updates within 1.5 seconds
    for _ in 0..3 {
        match rx.recv().await {
            Ok(updated_uri) => {
                println!("\n✅ Received Notification: Resource updated -> {}", updated_uri);
                
                // Read the actual new content
                let content = mcp_client.read_resource(&updated_uri).await?;
                if let Some(c) = content.first() {
                    println!("=> New Content: {}", c.text.clone().unwrap_or_default());
                }
            }
            Err(e) => {
                println!("❌ Error receiving update: {:?}", e);
            }
        }
    }

    println!("\nUnsubscribing from {}", uri);
    mcp_client.unsubscribe_resource(uri).await?;

    // Wait a bit to ensure no more messages arrive
    println!("Waiting 1.5 seconds to verify stream is closed...");
    sleep(Duration::from_millis(1500)).await;
    
    if let Ok(late_msg) = rx.try_recv() {
        println!("❌ Unexpected late message: {}", late_msg);
    } else {
        println!("✅ Successfully halted subscription! No new messages arrived.");
    }

    Ok(())
}