Method convert_request

crates/opencode-provider/src/vertex.rs:116–178

(&self, request: ChatRequest)

    }

    fn convert_request(&self, request: ChatRequest) -> VertexRequest {
        let mut contents = Vec::new();
        let mut system_instruction = None;

        for msg in request.messages {
            match msg.role {
                Role::System => {
                    if let Content::Text(text) = msg.content {
                        system_instruction = Some(VertexContent {
                            parts: vec![VertexPart::text(&text)],
                            role: "user".to_string(),
                        });
                    }
                }
                Role::User => {
                    let parts = self.content_to_parts(&msg.content);
                    contents.push(VertexContent {
                        parts,
                        role: "user".to_string(),
                    });
                }
                Role::Assistant => {
                    let parts = self.content_to_parts(&msg.content);
                    contents.push(VertexContent {
                        parts,
                        role: "model".to_string(),
                    });
                }
                Role::Tool => {
                    // Tool messages are handled as user messages with function response
                    if let Content::Parts(parts) = msg.content {
                        let vertex_parts: Vec<VertexPart> = parts
                            .into_iter()
                            .filter_map(|p| {
                                p.tool_result.map(|tr| {
                                    VertexPart::function_response(&tr.tool_use_id, &tr.content)
                                })
                            })
                            .collect();
                        if !vertex_parts.is_empty() {
                            contents.push(VertexContent {
                                parts: vertex_parts,
                                role: "user".to_string(),
                            });
                        }
                    }
                }
            }
        }

        let generation_config = VertexGenerationConfig {
            max_output_tokens: request.max_tokens,
            temperature: request.temperature,
            top_p: request.top_p,
        };

        VertexRequest {
            contents,