Method complete

core/src/llm/huggingface.rs:113–184

(&self, request: LlmRequest)

    }

    async fn complete(&self, request: LlmRequest) -> GraphBitResult<LlmResponse> {
        let url = format!("{}/{}", self.base_url, self.model);

        // Format messages for `HuggingFace`
        let inputs = Self::format_messages_for_chat(&request.messages);

        let mut parameters = HashMap::new();
        if let Some(max_tokens) = request.max_tokens {
            parameters.insert(
                "max_new_tokens".to_string(),
                serde_json::Value::Number(max_tokens.into()),
            );
        }
        if let Some(temperature) = request.temperature {
            parameters.insert(
                "temperature".to_string(),
                serde_json::Value::Number(
                    serde_json::Number::from_f64(temperature as f64).unwrap(),
                ),
            );
        }
        if let Some(top_p) = request.top_p {
            parameters.insert(
                "top_p".to_string(),
                serde_json::Value::Number(serde_json::Number::from_f64(top_p as f64).unwrap()),
            );
        }

        // Add extra parameters
        for (key, value) in request.extra_params {
            parameters.insert(key, value);
        }

        let body = HuggingFaceRequest {
            inputs,
            parameters: if parameters.is_empty() {
                None
            } else {
                Some(parameters)
            },
            options: Some(HuggingFaceOptions {
                wait_for_model: true,
                use_cache: false,
            }),
        };

        let response = self
            .client
            .post(&url)
            .header("Authorization", format!("Bearer {}", self.api_key))
            .header("Content-Type", "application/json")
            .json(&body)
            .send()
            .await
            .map_err(|e| {
                GraphBitError::llm_provider("huggingface", format!("Request failed: {e}"))
            })?;