Method convert_request

crates/opencode-provider/src/github_copilot.rs:151–203

(&self, request: ChatRequest)

    }

    fn convert_request(&self, request: ChatRequest) -> CopilotRequest {
        let messages: Vec<CopilotMessage> = request
            .messages
            .into_iter()
            .map(|msg| CopilotMessage {
                role: match msg.role {
                    Role::System => "system".to_string(),
                    Role::User => "user".to_string(),
                    Role::Assistant => "assistant".to_string(),
                    Role::Tool => "user".to_string(),
                },
                content: match msg.content {
                    Content::Text(t) => CopilotContent::Text(t),
                    Content::Parts(parts) => {
                        let contents: Vec<CopilotContentPart> = parts
                            .into_iter()
                            .filter_map(|p| {
                                if let Some(text) = p.text {
                                    Some(CopilotContentPart {
                                        content_type: "text".to_string(),
                                        text: Some(text),
                                        image_url: p
                                            .image_url
                                            .map(|iu| CopilotImageUrl { url: iu.url }),
                                    })
                                } else if p.image_url.is_some() {
                                    Some(CopilotContentPart {
                                        content_type: "image_url".to_string(),
                                        text: None,
                                        image_url: p
                                            .image_url
                                            .map(|iu| CopilotImageUrl { url: iu.url }),
                                    })
                                } else {
                                    None
                                }
                            })
                            .collect();
                        CopilotContent::Parts(contents)
                    }
                },
            })
            .collect();

        CopilotRequest {
            model: request.model,
            messages,
            max_tokens: request.max_tokens,
            temperature: request.temperature,
            top_p: request.top_p,
            stream: false,
        }
    }

    fn responses_url(base_url: Option<&str>, path: &str) -> String {
        let path = path.trim_start_matches('/');