Function calling inner function that has a different signature

[Geane Norm]

Hi,
I have a func with the following signature:

myOuterFunction(ctx context.Context, act action.MyAction) (repository.MyRepository, []event.Event, error) {
req := action.Data(*SomeRequest)
// some other business logic is happening here
}

I have some business logic firing off internally, but it holds different return types and generally speaking a different signature

E.g.

retrieveID(p []*SomeParamsStruct) (uuid.UUID, error){
// some magic happens here
}

and then the ID that I succesfully retrieved is used here:

getSomethingByThatID(ctx context.Context, id uuid.UUID) (*AnotherStruct, error) {
// some other magic happens here
}

My understanding is that whatever logic I fired off inside a func that is part of an external function needs aligning with

myOuterFunction 

returned types. I ended up having something along these lines, but I truly dislike it:

func haveYouFoundTheID(request *SomeRequest) (uuid.UUID, error, repository.MyRepository, []event.Event, error, bool){
id, err := retrieveID(request.params) (uuid.UUID, error)
....
}

then  it is used in my outer func like this:

	id, _, _, _, err, isErr := haveYouFoundTheID(request)
	if isErr {
		return nil, nil, err
	}

Is there a better way to do it? Thank you