Struct Chat

Source

pub struct Chat<'c, P: Provider, H: HttpClient> { /* private fields */ }

Implementations§

Source §

impl<'c, P, H> Chat<'c, P, H>
where P: Provider, H: HttpClient,

Source

pub fn new(client: &'c Client<P, H>) -> Self

Source

pub async fn create<T>(&self, request: T) -> Result<P::ChatResponse, Error>
where T: TryInto<P::ChatRequest>, T::Error: Debug,

Examples found in repository ?

examples/generate.rs (line 139)

async fn generate<H: HttpClient>(
    client: &Option<Client<RawProvider, H>>,
    provider_name: impl Into<String>,
    model_name: impl Into<String>,
    test_name: impl Into<String>,
    prompt: impl Into<String>,
) -> Result<(), Error> {
    let test_name: String = test_name.into();
    let provider_name: String = provider_name.into();
    let model_name: String = model_name.into();
    match client {
        None => tracing::debug!(
            "Skip {}/{}/{} because client is None",
            provider_name,
            model_name,
            test_name
        ),
        Some(client) => {
            let request = ChatRequest::new(&model_name, vec![ChatMessage::user(prompt)]);
            let request = serde_json::to_value(request)?;
            tracing::debug!("Sending request: {:?}", request);
            let response = client.chat().create(request.clone()).await?;

            let provider_model_name =
                format!("{}_{}", provider_name, sanitize_folder_name(&model_name));

            let mut d = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
            d.push("data");
            d.push(&test_name);
            d.push(&provider_model_name);
            let output_path = d
                .to_str()
                .map(ToString::to_string)
                .ok_or(Error::InvalidArgument(format!(
                    "Failed to get path for data/{}/{}",
                    test_name, provider_model_name
                )))?;
            match fs::create_dir_all(&output_path) {
                Err(e) => tracing::error!("Failed to create folder: {:?}", e),
                Ok(_) => {
                    tracing::info!("Successfully created folder: {:?}", output_path);
                    // info.json
                    let mut info_path = PathBuf::from_str(&output_path).unwrap();
                    info_path.push("info.json");
                    let info = json!({
                        "provider_name": provider_name,
                        "test_name": test_name,
                        "model_name": model_name
                    });
                    match save_json_to_file(&info, &info_path) {
                        Ok(_) => tracing::info!("Succesfully created file: {:?}", info_path),
                        Err(e) => tracing::error!("Failed to create file: {:?}", e),
                    }

                    // request.json
                    let mut request_path = PathBuf::from_str(&output_path).unwrap();
                    request_path.push("request.json");
                    match save_json_to_file(&request, &request_path) {
                        Ok(_) => tracing::info!("Succesfully created file: {:?}", request_path),
                        Err(e) => tracing::error!("Failed to create file: {:?}", e),
                    }

                    // response.json
                    let mut response_path = PathBuf::from_str(&output_path).unwrap();
                    response_path.push("response.json");
                    match save_json_to_file(&response, &response_path) {
                        Ok(_) => tracing::info!("Succesfully created file: {:?}", response_path),
                        Err(e) => tracing::error!("Failed to create file: {:?}", e),
                    }
                }
            }
        }
    }

    Ok(())
}