oaapi 0.2.0

An unofficial Rust client for the OpenAI 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

//! Completes chat streaming by /chat/completions endpoint with stream response.
//!
//! ```shell
//! $ cargo run --example chat_completions_stream --features chat -- --prompt <prompt> --message <message>
//! ```
//!
//! e.g.
//! ```shell
//! $ cargo run --example chat_completions_stream --features chat -- --prompt "You are a excellent AI assistant." --message "Where is the capital of Japan?"
//! ```

use clap::Parser;
use tokio_stream::StreamExt;

use oaapi::chat::ChatModel;
use oaapi::chat::CompletionsRequestBody;
use oaapi::chat::StreamOption;
use oaapi::chat::SystemMessage;
use oaapi::chat::UserMessage;
use oaapi::Client;

#[derive(Parser)]
struct Arguments {
    #[arg(short, long)]
    prompt: String,
    #[arg(short, long)]
    message: String,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let arguments = Arguments::parse();

    // 1. Create a client with the API key from the environment variable: "OPENAI_API_KEY"
    let client = Client::from_env()?;
    // or specify the API key directly.
    // let client = Client::new(oaapi::ApiKey::new("OPENAI_API_KEY"), None, None);

    // 2. Create a request body parameters with specifying the streaming option: `StreamOption::ReturnStream`.
    let request_body = CompletionsRequestBody {
        messages: vec![
            SystemMessage::new(arguments.prompt, None).into(),
            UserMessage::new(arguments.message.into(), None).into(),
        ],
        model: ChatModel::Gpt35Turbo,
        stream: Some(StreamOption::ReturnStream),
        ..Default::default()
    };

    // 3. Call the API.
    let mut stream = client
        .chat_complete_stream(request_body)
        .await?;

    // 4. Set up text buffer.
    let mut text_buffer = String::new();

    // 5. Receive the response stream.
    while let Some(response) = stream.next().await {
        match response {
            | Ok(chunk) => {
                println!("Delta: {}", chunk);

                if let Some(delta) = chunk
                    .choices
                    .first()
                    .unwrap()
                    .delta
                    .as_ref()
                    .unwrap()
                    .content
                    .clone()
                {
                    // 6. Buffer delta result.
                    text_buffer.push_str(delta.clone().as_str());
                }
            },
            | Err(error) => {
                eprintln!(
                    "Error: {}, buffer: {}",
                    error, text_buffer
                );
                return Err(error.into());
            },
        }
    }

    // 7. Use the total response.
    println!("Result:\n{}", text_buffer);

    Ok(())
}