Method parse_response

core/src/llm/anthropic.rs:150–222

Parse `Anthropic` response to `GraphBit` response

(&self, response: AnthropicResponse)

    /// Parse `Anthropic` response to `GraphBit` response
    fn parse_response(&self, response: AnthropicResponse) -> GraphBitResult<LlmResponse> {
        let mut content_text = String::new();
        let mut tool_calls = Vec::new();

        // Process content blocks
        for block in &response.content {
            match block.r#type.as_str() {
                "text" => {
                    if let Some(text) = &block.text {
                        if !content_text.is_empty() {
                            content_text.push('\n');
                        }
                        content_text.push_str(text);
                    }
                }
                "tool_use" => {
                    if let (Some(id), Some(name), Some(input)) =
                        (&block.id, &block.name, &block.input)
                    {
                        tool_calls.push(LlmToolCall {
                            id: id.clone(),
                            name: name.clone(),
                            parameters: input.clone(),
                        });
                    }
                }
                _ => {
                    // Handle other content types if needed
                }
            }
        }

        let finish_reason = match response.stop_reason.as_deref() {
            Some("end_turn" | "stop_sequence") => FinishReason::Stop,
            Some("max_tokens") => FinishReason::Length,
            Some("tool_use") => FinishReason::Other("tool_use".into()),
            Some(other) => FinishReason::Other(other.to_string()),
            None => FinishReason::Stop,
        };

        let usage = LlmUsage::new_with_cache(
            response.usage.input_tokens,
            response.usage.output_tokens,
            response.usage.cache_read_input_tokens,
            response.usage.cache_creation_input_tokens,
        );

        // Log cache savings when caching is active
        if let Some(read) = response.usage.cache_read_input_tokens {
            if read > 0 {
                tracing::debug!(
                    "Anthropic cache hit: {} tokens read from cache, {} creation tokens",
                    read,
                    response
                        .usage
                        .cache_creation_input_tokens
                        .unwrap_or(0)
                );