How to update Core Data and then UI via a background operation from a button press using Swift Async/Await in SwiftUI

I've read other questions and answers on this topic but can't seem to find a solution to make this work in my situation. My specific situation is I have a button that the user presses to kick-off some async work, like an API call. On completion of this async work a Core Data object, and thus the UI that is referencing that object, needs to be updated with the newly retrieved data, but I can't figure out the exact way this needs to be set up. Below is my current attempt:

@ObservedObject data: MyDataObject // Core Data entity passed in from an upper view
let managedObjectContext = DataController.shared.context // Core Data NSPersistentContainer singleton

var body: some View {
  VStack {
    Text(data.info)

    Button("Tap") {
      getResponseFromNetworkAPI(using: data)
    }
  }
}

func getResponseFromNetworkAPI(using data: MyDataObject) {
  // Do work that should be in the background. Once the response is fetched, I want to
  // update my Core Data entity on the MainActor (which I believe is best practice).
  Task.detached(priority: .userInitiated) {
    var response: String? = nil
    response = await APIServiceClass.requestResponse(using: data)

    await MainActor.run {
       // Error here on the below line:
       // "Reference to capture var 'response' in concurrently-executing code"
       data.info = response
       try? managedObjectContext.save()
    }
  }
}

My intuiton is that I can schedule a MainActor task from the background task, but I'm not sure how to pass data into it correctly, as I'm not allowed to reference the data retrieved in the background task. There may be a fix to my specific setup, but I'm also curious about a best practice way to do this.

The APIServiceClass.requestResponse(using:) function is an async function that returns a String? from some network call.

Here is what I would do, see the comments.

struct SampleFlowView: View {
    @Environment(\.managedObjectContext) var context
    @ObservedObject var data: MyDataObject
    @State private var gettingResponse: Bool = false
    var body: some View {
        VStack {
            Text(data.info ?? "no info")
            
            Button {
                gettingResponse.toggle() //Use the Button to trigger a .task
            } label: {
                Text("Tap").overlay {
                    if gettingResponse {
                        ProgressView() //Show a Progress View when the task is running
                    }
                }
            }
            .disabled(gettingResponse) //Disable the button to prevent duplicate calls
            .task(id: gettingResponse) { // async await task
                guard gettingResponse else {
                    return
                }
                print("updating")
                await getResponseFromNetworkAPI(using: data) //Run your method
                
                gettingResponse = false //Let the UI know you ae done
                print("done")
            }
        }
    }
    
    func getResponseFromNetworkAPI(using data: MyDataObject) async {
        //Set the Response String when the long APi call returns
        let responseString = await Task.detached(priority: .userInitiated) {
            try? await Task.sleep(for: .seconds(2)) //Mimicking a delay
            //Mimic returning a String
            return "test \((0...100).randomElement()!)"//await APIServiceClass.requestResponse(using: data)
        }.value
        
        //Use Core Data Concurrency
        await context.perform { //Use async await to let the "actor" determine how to save the context
            
            data.info = responseString
            try? context.save()
        }
    }
}