async fn handle_transcription_job(
    event: LambdaEvent<Value>,
    transcribe_client: &aws_sdk_transcribe::Client,
    s3_client: &aws_sdk_s3::Client,
    bedrock_agent_client: &aws_sdk_bedrockagent::Client,
    kb_bucket_name: &str,
    kb_id: &str,
    data_source_id: &str,
    media_bucket_name: &str,
) -> Result<(), Error> {
    let e: TranscriptionSuccessEvent = serde_json::from_value(event.payload)?;

    let job_name = e.transcription_job;

    let file_url = transcribe_client
        .get_transcription_job()
        .transcription_job_name(&job_name)
        .send()
        .await?
        .transcription_job
        .ok_or_else(|| Error::from("Transcription Job error"))?
        .transcript
        .ok_or_else(|| Error::from("Transcript error"))?
        .transcript_file_uri
        .ok_or_else(|| Error::from("Transcript file uri error"))?;

    match reqwest::get(file_url).await {
        Ok(resp) => {
            let transcription_result = resp.json::<TranscriptionResult>().await?;

            let transcription_content: Vec<String> = transcription_result
                .results
                .transcripts
                .iter()
                .map(|t| t.transcript.clone())
                .collect();

            let result = transcription_content.join(" ");

            let metadata =
                get_staging_media_metadata(s3_client, media_bucket_name, &job_name).await?;

            store_metadata_content(
                s3_client,
                kb_bucket_name,
                &job_name,
                &result,
                &metadata.to_string(),
            )
            .await?;

            bedrock_agent_client
                .start_ingestion_job()
                .knowledge_base_id(kb_id)
                .data_source_id(data_source_id)
                .send()
                .await?;
        }
        Err(err) => {
            error!({ %err }, "downloading transcription");
            return Err(Box::new(err));
        }
    };

    Ok(())
}