just-llm-client 0.2.0

Just a lightweight, composable, and minimal LLM client — not an agent framework
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

use crate::{
    BackendError,
    types::chat::{ChatCompletionRequest, ToolChoice},
};

/// Validates that a request is suitable for a non-streaming endpoint.
pub fn validate_non_streaming_request(
    request: &ChatCompletionRequest,
    method_name: &'static str,
    streaming_method_name: &'static str,
) -> Result<(), BackendError> {
    validate_common_request(request)?;

    if request.stream.unwrap_or(false) {
        return Err(BackendError::invalid_request(format!(
            "stream=true is not supported by {method_name}; use {streaming_method_name} instead"
        )));
    }

    if request.stream_options.is_some() {
        return Err(BackendError::invalid_request(
            "stream_options require stream=true",
        ));
    }

    Ok(())
}

/// Validates a request and ensures streaming is enabled, returning the modified request.
pub fn into_validated_streaming_request(
    mut request: ChatCompletionRequest,
    method_name: &'static str,
) -> Result<ChatCompletionRequest, BackendError> {
    validate_common_request(&request)?;

    if request.stream == Some(false) {
        return Err(BackendError::invalid_request(format!(
            "stream=false is not supported by {method_name}"
        )));
    }

    request.stream = Some(true);
    Ok(request)
}

/// Validates request fields shared by streaming and non-streaming paths.
pub fn validate_common_request(request: &ChatCompletionRequest) -> Result<(), BackendError> {
    if request.tool_choice.is_some() && request.tools.as_ref().is_none_or(Vec::is_empty) {
        return Err(BackendError::invalid_request(
            "tool_choice requires at least one configured tool",
        ));
    }

    if let Some(ToolChoice::Named(choice)) = &request.tool_choice {
        let tool_exists = request.tools.as_ref().is_some_and(|tools| {
            tools
                .iter()
                .any(|tool| tool.function.name == choice.function.name)
        });

        if !tool_exists {
            return Err(BackendError::invalid_request(format!(
                "tool_choice references unknown tool '{}'",
                choice.function.name
            )));
        }
    }

    if request.top_logprobs.is_some() && request.logprobs != Some(true) {
        return Err(BackendError::invalid_request(
            "top_logprobs requires logprobs=true",
        ));
    }

    Ok(())
}