I have made the two SIP registrations. I have attached one to scenario A (Openai) and the other to a new scenario B (testing scenario). I have a routing rule for each scenario, do I need just one that applies to both?

scenario A:

require(Modules.ASR)

async function sendUtterance(query,session){
    const url = "xxxxxxxx"
    Logger.write("Session: " + session)
    const options = {
      headers: {
        "Content-Type": "application/json",
        "Ocp-Apim-Subscription-Key": "xxxxxxx"
      },
      method: "POST",
      postData: JSON.stringify({
        "query": query,
        "session": session,
        "origin": "phone"
      })
    }
    const result = await Net.httpRequestAsync(url, options);
    Logger.write(result.text);
    const response = JSON.parse(result.text)
    var textresponse = ""
    response.responses.forEach(element => {
      textresponse += element.text + ". "
    });
    return textresponse
}

var waitMessagePlaying = false;
var isProcessing;
var isResponding = false;

var waitingMessages = [
    "Un momento, por favor.",
    "Deme un instante.",
    "Permítame un momento.",
    "Necesito un segundo.",
    "Deme un momento.",
    "Un instante si es tan amable.",
    "Un segundito, por favor.",
    "Espere un momento, por favor.",
    "Un segundito, si es tan amable.",
];
var waitingIndex = 0;

async function waitMessage(){
    if (waitMessagePlaying){
        return
    }
    waitMessagePlaying = true;

    function recursiveWait() {
        if (isProcessing && !isResponding) {
            var message = waitingMessages[waitingIndex];
            player = VoxEngine.createTTSPlayer(message, {
                language: defaultVoice,
                progressivePlayback: true
            })
            player.sendMediaTo(call)
            player.addMarker(-300)
            player.addEventListener(PlayerEvents.PlaybackMarkerReached, (ev) => {
                player.removeEventListener(PlayerEvents.PlaybackMarkerReached)
                setTimeout(recursiveWait,6000)
                waitingIndex++;
                if (waitingIndex == waitingMessages.length) {
                    waitingIndex = 0;
                }
            })
        } else {
            waitMessagePlaying = false;
        }
    }

    recursiveWait();
}


async function queryProc(messages,session){
    if (messages == ""){
        return
    }
    if (messages != "/start"){
        timer = setTimeout(waitMessage,2000)
    }
    isProcessing=true;
    try {
        let ts1 = Date.now();
        var res = await sendUtterance(messages, session)
        let ts2 = Date.now();
        Logger.write("Petición completada en " + (ts2 - ts1) + " ms")
        isResponding = true;
        if (timer){clearTimeout(timer);}
        if (waitMessagePlaying) {
            player.stop()
            waitMessagePlaying = false;
        }
        player = VoxEngine.createTTSPlayer(res,
            {
                language: defaultVoice,
                progressivePlayback: true
            })
        player.sendMediaTo(call)
        player.addMarker(-300)
    } catch(err){
        player = VoxEngine.createTTSPlayer('Disculpe, no le escuché, ha habido un error en sistema, ¿me lo puede repetir?',
           {
                language: defaultVoice,
                progressivePlayback: true
            })
        player.sendMediaTo(call)
        player.addMarker(-300)
    }
    player.addEventListener(PlayerEvents.PlaybackMarkerReached, (ev) => {
        player.removeEventListener(PlayerEvents.PlaybackMarkerReached)
        call.sendMediaTo(asr)
        isProcessing=false;
        isResponding = false;
    })
}

var call, player, asr, timer;
const defaultVoice = VoiceList.Microsoft.Neural.es_ES_LiaNeural

// Procesar la llamada entrante
VoxEngine.addEventListener(AppEvents.CallAlerting, (e) => {
    call = e.call
    const session = uuidgen()

    asr = VoxEngine.createASR({
        profile: ASRProfileList.Microsoft.es_ES,
        singleUtterance: true
    })
    // Procesar el resultado del ASR
    asr.addEventListener(ASREvents.Result, async (e) => {
        messages = e.text
        Logger.write("Enviando query '" + messages + "' al dto")
        // Tiempo de respuesta
        if (!isProcessing){
            await queryProc(messages,session)
        }
    }) 
    call.addEventListener(CallEvents.Connected, async (e) => {
        await queryProc('/start',session)
    })
    
    call.addEventListener(CallEvents.Disconnected, (e) => {
        VoxEngine.terminate()
    })
    
    call.answer()
})

scenario B:

require(Modules.ASR);
VoxEngine.addEventListener(AppEvents.CallAlerting, e => {
 e.call.startEarlyMedia();
 e.call.say("Hola melón, soy el contestador de las clínicas", VoiceList.Microsoft.Neural.es_ES_ElviraNeural);
 e.call.answer();
});

In the documentation I see this method:

const call = VoxEngine.callSIP("sips:[email protected]:5061", {
  callerid: "5510",
  displayName: "Steve Rogers",
  password: "shield",
  authUser: "captain",
 });

But I don't know how to integrate it into scenario A. Can you help?