Method chat_stream

crates/opencode-provider/src/bedrock.rs:351–397

(&self, request: ChatRequest)

    }

    async fn chat_stream(&self, request: ChatRequest) -> Result<StreamResult, ProviderError> {
        let endpoint = self.get_endpoint();
        let model_id = request.model.clone();
        let model_id_encoded = urlencoding::encode(&model_id);

        let bedrock_request = self.convert_request(request);
        let body = serde_json::to_vec(&bedrock_request)
            .map_err(|e| ProviderError::ApiError(e.to_string()))?;

        let headers = self
            .sign_request(
                "POST",
                &format!("/model/{}/converse-stream", model_id_encoded),
                &body,
            )
            .await?;

        let url = format!("{}/model/{}/converse-stream", endpoint, model_id_encoded);

        let response = self
            .client
            .post(&url)
            .headers(headers)
            .header("Accept", "application/vnd.amazon.eventstream")
            .body(body)
            .send()
            .await
            .map_err(|e| ProviderError::NetworkError(e.to_string()))?;

        if !response.status().is_success() {
            let status = response.status();
            let body = response.text().await.unwrap_or_default();
            return Err(ProviderError::ApiError(format!("{}: {}", status, body)));
        }

        let stream = response
            .bytes_stream()
            .map(move |chunk_result| match chunk_result {
                Ok(bytes) => {
                    let text = String::from_utf8_lossy(&bytes);
                    parse_bedrock_stream(&text)
                }
                Err(e) => Err(ProviderError::StreamError(e.to_string())),
            });

        Ok(Box::pin(stream))
    }
}

#[derive(Debug, Serialize)]