Method complete

core/src/llm/replicate.rs:240–324

(&self, request: LlmRequest)

    }

    async fn complete(&self, request: LlmRequest) -> GraphBitResult<LlmResponse> {
        let model_identifier = self.get_model_identifier();

        // Convert messages to prompt format
        let mut prompt = String::new();

        // Add tools information if available and model supports it
        if !request.tools.is_empty() && self.model_supports_function_calling() {
            prompt.push_str(&Self::format_tools_for_prompt(&request.tools));
        }

        prompt.push_str(&Self::convert_messages_to_prompt(&request.messages));

        // Prepare input based on model type
        let mut input = serde_json::json!({
            "prompt": prompt
        });

        // Add common parameters
        if let Some(max_tokens) = request.max_tokens {
            input["max_new_tokens"] = serde_json::Value::Number(max_tokens.into());
        }
        if let Some(temperature) = request.temperature {
            input["temperature"] = serde_json::json!(temperature);
        }
        if let Some(top_p) = request.top_p {
            input["top_p"] = serde_json::json!(top_p);
        }

        // Add extra parameters
        for (key, value) in request.extra_params {
            input[key] = value;
        }

        let prediction_request = if self.version.is_some() {
            ReplicatePredictionRequest {
                version: self.version.clone(),
                input,
                webhook: None,
            }
        } else {
            // For models without explicit version, we need to use the model endpoint
            ReplicatePredictionRequest {
                version: Some(model_identifier),
                input,
                webhook: None,
            }
        };

        // Create prediction
        let url = format!("{}/predictions", self.base_url);
        let response = self
            .client
            .post(&url)
            .header("Authorization", format!("Token {}", self.api_key))
            .header("Content-Type", "application/json")
            .json(&prediction_request)
            .send()