Method convert_request

crates/opencode-provider/src/anthropic.rs:100–145

(&self, request: ChatRequest)

    }

    fn convert_request(&self, request: ChatRequest) -> AnthropicRequest {
        let max_tokens = request.max_tokens.unwrap_or(4096);
        let mut messages = Vec::new();
        let mut system = None;

        for msg in request.messages {
            match msg.role {
                crate::Role::System => {
                    if let crate::Content::Text(text) = msg.content {
                        system = Some(text);
                    }
                }
                _ => {
                    messages.push(AnthropicMessage {
                        role: match msg.role {
                            crate::Role::User => "user".to_string(),
                            crate::Role::Assistant => "assistant".to_string(),
                            _ => "user".to_string(),
                        },
                        content: match msg.content {
                            crate::Content::Text(text) => vec![AnthropicContent::Text { text }],
                            crate::Content::Parts(parts) => parts
                                .into_iter()
                                .filter_map(|p| {
                                    if let Some(text) = p.text {
                                        Some(AnthropicContent::Text { text })
                                    } else {
                                        None
                                    }
                                })
                                .collect(),
                        },
                    });
                }
            }
        }

        AnthropicRequest {
            model: request.model,
            max_tokens,
            messages,
            system,
            stream: request.stream,
            thinking: anthropic_thinking_config(request.variant.as_deref(), max_tokens),
        }
    }
}

#[async_trait]