gpt5 0.2.3

A Rust client library for OpenAI's GPT-5 API with support for function calling, reasoning, and streaming
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

//! Function calling example with GPT-5
//!
//! This example shows how to use GPT-5 with function calling capabilities
//! Run with: cargo run --example function_calling

use gpt5::{Gpt5Client, Gpt5Model, Gpt5RequestBuilder, ReasoningEffort, Tool, VerbosityLevel};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key =
        std::env::var("OPENAI_API_KEY").expect("Please set OPENAI_API_KEY environment variable");

    let client = Gpt5Client::new(api_key);

    // Define a simple calculator tool
    let calculator_tool = Tool {
        tool_type: "function".to_string(),
        name: Some("calculate".to_string()),
        description: Some("Perform basic arithmetic calculations".to_string()),
        parameters: Some(json!({
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "Mathematical expression to evaluate (e.g., '2 + 2', '10 * 5')"
                }
            },
            "required": ["expression"]
        })),
    };

    // Define a weather tool (mock)
    let weather_tool = Tool {
        tool_type: "function".to_string(),
        name: Some("get_weather".to_string()),
        description: Some("Get current weather information for a city".to_string()),
        parameters: Some(json!({
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "The city name to get weather for"
                }
            },
            "required": ["city"]
        })),
    };

    println!("🧮 Testing calculator function...");

    // Build a request with tools
    let request = Gpt5RequestBuilder::new(Gpt5Model::Gpt5Nano)
        .input("What is 15 * 8 + 42?")
        .instructions("Use the calculator tool to solve this math problem")
        .tools(vec![calculator_tool])
        .tool_choice("auto")
        .verbosity(VerbosityLevel::Medium)
        .reasoning_effort(ReasoningEffort::Low)
        .max_output_tokens(200)
        .build();

    // Send the request
    let response = client.request(request).await?;

    // Check for function calls
    let function_calls = response.function_calls();
    if !function_calls.is_empty() {
        println!("🔧 Function calls made: {}", function_calls.len());
        for call in function_calls {
            println!("  Function: {}", call.name.as_deref().unwrap_or("unknown"));
            println!("  Arguments: {}", call.arguments.as_deref().unwrap_or("{}"));
        }
    }

    // Get text response
    if let Some(text) = response.text() {
        println!("🤖 Response: {}", text);
    }

    println!("\n🌤️ Testing weather function...");

    // Test weather tool
    let weather_request = Gpt5RequestBuilder::new(Gpt5Model::Gpt5Nano)
        .input("What's the weather like in Tokyo?")
        .instructions("Use the weather tool to get current conditions")
        .tools(vec![weather_tool])
        .tool_choice("auto")
        .verbosity(VerbosityLevel::Low)
        .reasoning_effort(ReasoningEffort::Low)
        .max_output_tokens(150)
        .build();

    let weather_response = client.request(weather_request).await?;

    let weather_calls = weather_response.function_calls();
    if !weather_calls.is_empty() {
        println!("🔧 Weather function calls made: {}", weather_calls.len());
        for call in weather_calls {
            println!("  Function: {}", call.name.as_deref().unwrap_or("unknown"));
            println!("  Arguments: {}", call.arguments.as_deref().unwrap_or("{}"));
        }
    }

    if let Some(text) = weather_response.text() {
        println!("🤖 Response: {}", text);
    }

    Ok(())
}