Method parse_response

core/src/llm/mistralai.rs:124–186

Parse `MistralAI` response to `GraphBit` response

(&self, response: MistralAiResponse)

    /// Parse `MistralAI` response to `GraphBit` response
    fn parse_response(&self, response: MistralAiResponse) -> GraphBitResult<LlmResponse> {
        let choice = response.choices.into_iter().next().ok_or_else(|| {
            GraphBitError::llm_provider("mistralai", "No choices in response".to_string())
        })?;

        let tool_calls: Vec<LlmToolCall> = choice
            .message
            .tool_calls
            .unwrap_or_default()
            .into_iter()
            .map(|tc| {
                // Production-grade argument parsing with error handling
                let parameters = if tc.function.arguments.trim().is_empty() {
                    serde_json::Value::Object(serde_json::Map::new())
                } else {
                    match serde_json::from_str(&tc.function.arguments) {
                        Ok(params) => params,
                        Err(e) => {
                            tracing::warn!(
                                "Failed to parse tool call arguments for {}: {e}. Arguments: '{}'",
                                tc.function.name,
                                tc.function.arguments
                            );
                            // Try to create a simple object with the raw arguments
                            serde_json::json!({ "raw_arguments": tc.function.arguments })
                        }
                    }
                };

                LlmToolCall {
                    id: tc.id,
                    name: tc.function.name,
                    parameters,
                }
            })
            .collect();

        // Handle content - provide default message for tool calls
        let mut content = choice.message.content.unwrap_or_default();
        if content.trim().is_empty() && !tool_calls.is_empty() {
            content = "I'll help you with that using the available tools.".to_string();
        }

        let finish_reason = match choice.finish_reason.as_deref() {
            Some("stop") => FinishReason::Stop,
            Some("length") => FinishReason::Length,
            Some("tool_calls") => FinishReason::ToolCalls,
            Some("content_filter") => FinishReason::ContentFilter,
            Some(other) => FinishReason::Other(other.to_string()),
            None => FinishReason::Stop,
        };

        let usage = LlmUsage::new(
            response.usage.prompt_tokens,
            response.usage.completion_tokens,
        );

        Ok(LlmResponse::new(content, &self.model)