Method parse_response

core/src/llm/azurellm.rs:338–436

Parse `Azure LLM` response to `GraphBit` response

(&self, response: AzureLlmResponse)

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

        let finish_reason = match choice.finish_reason.as_str() {
            "stop" => FinishReason::Stop,
            "length" => FinishReason::Length,
            "tool_calls" => FinishReason::ToolCalls,
            "content_filter" => FinishReason::ContentFilter,
            _ => FinishReason::Other(choice.finish_reason),
        };

        let tool_calls = if let Some(tool_calls) = choice.message.tool_calls {
            tool_calls
                .into_iter()
                .map(|tc| LlmToolCall {
                    id: tc.id,
                    name: tc.function.name,
                    parameters: serde_json::from_str(&tc.function.arguments).unwrap_or_default(),
                })
                .collect()
        } else {
            Vec::new()
        };

        // Handle Azure's null/empty content bug
        // When finish_reason is "length" or "content_filter", Azure returns EMPTY STRING (not null!)
        // despite consuming completion tokens. This is a known Azure API quirk.
        let has_content = choice
            .message
            .content
            .as_ref()
            .map(|s| !s.is_empty())
            .unwrap_or(false);
        let content_value = choice.message.content.unwrap_or_default();

        let content = if has_content {
            // Normal case: content exists and is not empty
            tracing::debug!("Azure response has content: {} chars", content_value.len());
            content_value
        } else if response.usage.completion_tokens > 0 {
            // Bug case: empty/null content but tokens were used
            match &finish_reason {
                FinishReason::Length => {
                    tracing::warn!(
                        "Azure API returned empty content despite using {} completion tokens (finish_reason: Length). \
                        This typically occurs with very low max_tokens limits. Consider increasing max_tokens for better results.",
                        response.usage.completion_tokens
                    );
                    let msg = format!(
                        "[Azure API used {} tokens but returned no content. This occurs when max_tokens is set too low. \
                        The model may have started generating a response but was cut off before producing visible text. \
                        Increase max_tokens for meaningful output.]",
                        response.usage.completion_tokens
                    );