SFMC Tips #336: Agentforce, Starter Prompts per un Service Agent

Quando si integra un Agentforce Service Agent su un sito web, normalmente si utilizza Enhanced Web Chat v1 o v2 di Salesforce, avviando la conversazione dal pulsante di chat standard.

Tuttavia, su un sito reale, invece di aprire subito una schermata di chat a testo libero, potrebbe essere necessario mostrare prima alcune opzioni, ad esempio:

• Scopri i nostri servizi
• Scopri i prezzi
• Parla con un operatore

lasciando che l’utente scelga il proprio obiettivo prima di iniziare la conversazione con Agentforce.

In questo articolo vedremo come creare una schermata iniziale personalizzata con starter prompts lato sito web, e come avviare da lì una conversazione con un Agentforce Service Agent.

Durante questa verifica, mi ha richiesto un po’ di tempo capire che la realizzazione di una schermata di questo tipo non implica modificare Agentforce in sé.

Invece di modificare Agentforce Builder o altri componenti per creare uno start screen personalizzato, si costruisce una UI custom lato sito web e si utilizza la JavaScript API fornita da Enhanced Web Chat per avviare una Conversation con Agentforce.

Comprendere questa differenza fin dall’inizio è stato fondamentale per questa implementazione.

Cosa vogliamo ottenere

Quello che costruiremo in questo articolo è, ad esempio, uno start screen come il seguente.

Assistenza Online

Come possiamo aiutarti?

・ [ Scopri i nostri servizi ]
・ [ Scopri i prezzi ]
・ [ Parla con un operatore ]

— — — — — — OPPURE — — — — — –

[ Scrivi il tuo messaggio… ] [Invia]

Questa schermata non è qualcosa che viene creato all’interno di Salesforce Enhanced Web Chat. Non esiste una schermata di configurazione per creare una UI di questo tipo.

Si tratta quindi di una UI custom creata lato sito web utilizzando normale HTML, CSS e JavaScript.

Ad esempio, quando l’utente clicca su:

• Scopri i prezzi

il flusso è il seguente:

Click su uno starter prompt
↓
Avvio di Enhanced Web Chat
↓
Agentforce entra nella Conversation
↓
Invio di "Scopri i prezzi" come primo messaggio dell'utente
↓
Agentforce risponde

Naturalmente, anche i messaggi inseriti nel campo di testo libero possono essere passati ad Agentforce utilizzando lo stesso meccanismo.

Non è necessario modificare Agentforce

Inizialmente stavo cercando un modo per implementare questa funzionalità partendo dall’ottica della “personalizzazione della schermata iniziale di Agentforce”.

Per questo avevo indagato principalmente sui metodi di personalizzazione lato Salesforce, come:

• Agentforce Builder
• Enhanced Web Chat UI
• Lightning Web Components
• Custom Lightning Types
• Pre-chat

Tuttavia, riorganizzando ciò che volevo realmente ottenere in questo caso, ho capito che la schermata da modificare non era quella successiva all’avvio della Conversation con Agentforce.

Il requisito era modificare l’esperienza web precedente all’inizio della Conversation.

In altre parole, ho capito che la seguente struttura avrebbe funzionato:

Sito web
↓
Schermata iniziale custom
↓
Enhanced Web Chat
↓
Agentforce

Salesforce Enhanced Web Chat fornisce una JavaScript API per avviare la chat da un sito web.

Quindi, invece di implementare una schermata iniziale speciale lato Agentforce, è possibile ottenere questo risultato utilizzando la Enhanced Web Chat API lato sito web.

Avviare Enhanced Web Chat con launchChat()

La prima API utilizzata in questa implementazione è:

embeddedservice_bootstrap.utilAPI.launchChat()

Utilizzando launchChat(), è possibile avviare Enhanced Web Chat da JavaScript lato sito web, senza richiedere all’utente di cliccare sul pulsante di chat standard di Salesforce.

Quindi, invece del:

• Pulsante di chat standard di Salesforce

è possibile utilizzare:

• Starter prompts personalizzati
• Pulsanti personalizzati
• Web UI personalizzata

come punto di ingresso a Enhanced Web Chat.

Quando si crea uno start screen custom come questo, è possibile anche nascondere fin dall’inizio il pulsante di chat standard di Salesforce.

embeddedservice_bootstrap.settings.hideChatButtonOnLoad = true;

Poi, dalla UI custom, si esegue:

embeddedservice_bootstrap.utilAPI.launchChat();

Questo crea il seguente flusso:

UI custom
↓
launchChat()
↓
Enhanced Web Chat

Inviare lo Starter Prompt ad Agentforce

Se si desidera semplicemente aprire Enhanced Web Chat, launchChat() è sufficiente.

Tuttavia, in questo caso, se ad esempio l’utente seleziona il seguente starter prompt:

• Scopri i prezzi

vogliamo usare direttamente questo contenuto come primo scambio della conversazione con Agentforce.

In Enhanced Web Chat v2:

embeddedservice_bootstrap.utilAPI.sendTextMessage()

può essere utilizzato per inviare un messaggio dell’utente.

Ad esempio:

embeddedservice_bootstrap.utilAPI.sendTextMessage(
  "Tell me about pricing"
);

In questo modo, il contenuto può essere passato ad Agentforce come messaggio dell’utente.

Ciò rende possibile la seguente struttura:

Starter prompt
↓
launchChat()
↓
sendTextMessage()
↓
Agentforce

L’invio del messaggio immediatamente dopo launchChat() non ha funzionato

Questo è stato il primo punto in cui mi sono bloccato durante l’implementazione.

Inizialmente pensavo semplicemente che il seguente approccio funzionasse:

await embeddedservice_bootstrap.utilAPI.launchChat();

await embeddedservice_bootstrap.utilAPI.sendTextMessage(
  "Tell me about pricing"
);

Tuttavia, testandolo effettivamente, non funzionava in modo affidabile.

Questo perché, anche se launchChat() è stato completato, Agentforce non è necessariamente pronto a ricevere il messaggio dell’utente.

Anche se la schermata di Enhanced Web Chat è già stata avviata, può esserci un momento in cui Agentforce non è ancora entrato nella Conversation.

A questo punto, si potrebbe pensare di usare:

setTimeout(…)

e fare qualcosa del tipo:

Attendi 1 secondo
Attendi 2 secondi
Attendi 3 secondi

Tuttavia, poiché il tempo necessario varia in base alla rete e all’ambiente, questo metodo non è affidabile.

Ho quindi utilizzato un evento Salesforce come alternativa.

Usare onEmbeddedMessagingFirstBotMessageSent

Enhanced Web Chat fornisce eventi che permettono al sito web di intercettare i cambiamenti di stato che avvengono all’interno della chat.

L’evento particolarmente importante in questo caso è stato:

onEmbeddedMessagingFirstBotMessageSent

Questo evento si verifica quando il primo Bot entra nella Conversation e invia il suo primo messaggio.

Ho quindi modificato l’ordine in questo modo:

Click su uno starter prompt
↓
launchChat()
↓
Agentforce entra nella Conversation
↓
Agentforce invia il suo primo messaggio
↓
onEmbeddedMessagingFirstBotMessageSent
↓
sendTextMessage()

Ad esempio, l’implementazione è simile a questa:

let pendingMessage = null;

window.addEventListener(
  "onEmbeddedMessagingFirstBotMessageSent",
  async function () {
    if (!pendingMessage) {
      return;
    }
    await embeddedservice_bootstrap
      .utilAPI
      .sendTextMessage(
        pendingMessage
      );
    pendingMessage = null;
  }
);

Quando lo starter prompt viene cliccato, invece di inviare immediatamente il messaggio, lo si memorizza temporaneamente così:

pendingMessage = "Tell me about pricing";

Poi, dopo aver confermato tramite l’evento che Agentforce è pronto, si esegue:

sendTextMessage()

Con questo cambio di approccio, è stato possibile inviare il primo messaggio in modo affidabile.

Usare gli eventi piuttosto che “quanti secondi attendere”

Il punto importante in questa implementazione è eseguire il processo successivo basandosi sullo stato piuttosto che sul tempo.

Ad esempio:

setTimeout(
  function () {
    sendMessage();
  },
  2000
);

Con un’implementazione di questo tipo:

• Rete veloce → i 2 secondi sono superflui
• Rete lenta → anche 2 secondi non sono sufficienti

possono verificarsi questi problemi.

Al contrario, utilizzando:

onEmbeddedMessagingFirstBotMessageSent

la sequenza diventa:

Agentforce è pronto
↓
Invio del messaggio

Enhanced Web Chat fornisce anche molti altri eventi standard.

Quando si gestisce Enhanced Web Chat lato sito web come in questo caso, costruire il processo utilizzando quanto più possibile gli eventi forniti da Salesforce porta a un’implementazione più stabile.

Anche onEmbeddedMessagingReady è importante

La Enhanced Web Chat API non è disponibile immediatamente all’apertura della pagina web.

Salesforce fornisce un evento chiamato:

onEmbeddedMessagingReady

Quando questo evento si verifica, la JavaScript API di Enhanced Web Chat diventa disponibile.

Ad esempio:

let messagingReady = false;

window.addEventListener(
  "onEmbeddedMessagingReady",
  function () {
    messagingReady = true;
  }
);

Poi, quando viene cliccato uno starter prompt, si può verificare:

if (!messagingReady) {
  return;
}

Questo evita che il processo venga eseguito prima che l’API sia pronta.

Verificare anche onEmbeddedMessagingButtonCreated per launchChat()

Per launchChat(), la documentazione ufficiale di Salesforce descrive un metodo che lo utilizza dopo aver aggiunto un event listener per:

onEmbeddedMessagingButtonCreated

Ad esempio:

let buttonCreated = false;

window.addEventListener(
  "onEmbeddedMessagingButtonCreated",
  function () {
    buttonCreated = true;
  }
);

Poi, quando lo starter prompt viene cliccato, si verifica:

if (!buttonCreated) {
  return;
}

prima di eseguire:

embeddedservice_bootstrap.utilAPI.launchChat();

Anche se il pulsante di chat standard di Salesforce viene nascosto con:

hideChatButtonOnLoad = true;

questo evento può comunque essere utilizzato.

Un po’ di confusione tra sendMessage() e sendTextMessage()

Un altro punto che ha generato qualche incertezza in questo caso è stata l’API utilizzata per inviare il messaggio dell’utente.

Salesforce ha documentazione ufficiale per sendMessage(), utilizzata per inviare un messaggio come utente.

D’altra parte, gli Context Events di Enhanced Web Chat v2 forniscono anche:

sendTextMessage()

Quando ho verificato dagli Developer Tools nell’ambiente reale utilizzato in questo test:

typeof embeddedservice_bootstrap.utilAPI.sendMessage

il risultato era:

undefined

Al contrario:

typeof embeddedservice_bootstrap.utilAPI.sendTextMessage

ha restituito:

function

Quando ho effettivamente eseguito:

embeddedservice_bootstrap
  .utilAPI
  .sendTextMessage(
    "Test message"
  );

è apparso in Enhanced Web Chat come messaggio dell’utente, e anche Agentforce ha ricevuto il contenuto.

Pertanto, nell’ambiente Enhanced Web Chat v2 utilizzato in questo caso, sto usando sendTextMessage().

Se il comportamento dell’API differisce da quanto ci si aspetta durante l’implementazione, verificare:

embeddedservice_bootstrap.utilAPI

dai Developer Tools del browser per confermare quali API sono effettivamente disponibili è risultato molto utile.

Considerare le Conversation già esistenti

Quando si utilizza questo meccanismo realmente su un sito web, un altro aspetto da considerare sono le Conversation già esistenti.

Ad esempio, supponiamo che l’utente ricarichi la pagina web mentre sta già conversando con Agentforce.

In questo caso, sarebbe innaturale che vengano mostrati contemporaneamente sia:

• Enhanced Web Chat esistente

sia:

• Starter prompts personalizzati

Per questo si può utilizzare:

onEmbeddedMessagingConversationOpened

Questo evento si verifica quando una Messaging Conversation viene caricata nella tab del browser.

Ad esempio:

window.addEventListener(
  "onEmbeddedMessagingConversationOpened",
  function () {

    document.getElementById(
      "starterPanel"
    ).style.display = "none";

  }
);

Con questa implementazione, quando una Conversation esistente viene caricata, la schermata iniziale custom può essere nascosta.

Non esiste un evento “nessuna Conversation esistente”

Questo è stato un altro punto su cui ho dovuto lavorare un po’ durante l’implementazione.

Salesforce fornisce:

onEmbeddedMessagingConversationOpened

quindi è possibile determinare tramite un evento che:

• Una Conversation esiste

Tuttavia, al contrario, non esiste un evento che indica:

• Non esiste alcuna Conversation esistente

Pertanto, nella versione pratica, invece di mostrare gli starter prompts immediatamente dopo l’apertura della pagina, ho mostrato un breve messaggio di caricamento, ad esempio:

• Preparazione assistenza in corso…

Ho quindi utilizzato la seguente struttura:

onEmbeddedMessagingReady
↓
Breve attesa
↓
ConversationOpened non si è verificato
↓
Determinare che si tratta di un nuovo utente
↓
Mostrare gli starter prompts

Ad esempio, l’implementazione è simile a questa:

window.addEventListener(
  "onEmbeddedMessagingReady",
  function () {

    setTimeout(
      function () {

        if (!conversationOpen) {

          showStarterPanel();

        }

      },
      2000
    );

  }
);

Questa è l’idea di base.

Qui viene utilizzato un Fallback Timer di circa 2 secondi.

Tuttavia, questo ha un significato completamente diverso rispetto al processo descritto in precedenza:

• Attendere 2 secondi fino a quando Agentforce è pronto

Per l’invio di un messaggio ad Agentforce, la readiness viene determinata tramite l’evento:

onEmbeddedMessagingFirstBotMessageSent

Il Fallback Timer viene utilizzato solo una volta, all’inizio, per determinare se sia opportuno mostrare gli starter prompts personalizzati.

Codice di esempio utilizzabile in generale

Di seguito un esempio semplificato che riassume tutto quanto spiegato finora.

Ho anche preparato un sito di esempio per mostrare cosa è possibile creare.

Agentforce Service Agent Demo

Sostituisci i valori con quelli ottenuti dal Code Snippet del tuo Enhanced Web Chat Deployment.

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">

<style>
body {
  font-family: Arial, sans-serif;
}

/* Loading */
#starterLoading {
  position: fixed;
  right: 24px;
  bottom: 24px;
  padding: 10px 16px;
  background: #032d60;
  color: #ffffff;
  border-radius: 20px;
  font-size: 13px;
}

/* Starter Panel */
#starterPanel {
  display: none;
  position: fixed;
  right: 24px;
  bottom: 24px;
  width: 350px;
  padding: 20px;
  box-sizing: border-box;
  background: #ffffff;
  border: 1px solid #dddddd;
  border-radius: 16px;
  box-shadow: 0 12px 30px rgba(0,0,0,0.15);
}

#starterPanel h2 {
  margin: 0 0 8px;
  font-size: 20px;
}

#starterPanel p {
  margin: 0 0 16px;
  color: #666666;
  font-size: 13px;
}

.starter-button {
  width: 100%;
  margin-bottom: 10px;
  padding: 12px;
  border: 1px solid #dddddd;
  border-radius: 10px;
  background: #ffffff;
  cursor: pointer;
  text-align: left;
}

.starter-button:hover {
  background: #f5f7fa;
}

.input-area {
  display: flex;
  gap: 8px;
  margin-top: 14px;
}

.input-area input {
  flex: 1;
  min-width: 0;
  padding: 10px;
  border: 1px solid #dddddd;
  border-radius: 10px;
}

.input-area button {
  padding: 10px 14px;
  border: 0;
  border-radius: 10px;
  background: #0176d3;
  color: #ffffff;
  cursor: pointer;
}

@media (max-width: 480px) {
  #starterPanel {
    right: 12px;
    bottom: 12px;
    width: calc(100vw - 24px);
  }

  #starterLoading {
    right: 12px;
    bottom: 12px;
  }
}
</style>
</head>

<body>

<!-- Loading -->
<div id="starterLoading">Preparing support...</div>

<!-- Starter Panel -->
<div id="starterPanel">
  <h2>How can we help?</h2>
  <p>Choose an option below or enter your message.</p>

  <button class="starter-button" onclick="startWithMessage('Tell me about your services')">
    Learn about services
  </button>

  <button class="starter-button" onclick="startWithMessage('Tell me about pricing')">
    Learn about pricing
  </button>

  <button class="starter-button" onclick="startWithMessage('I would like to speak with a support representative')">
    Contact customer support
  </button>

  <div class="input-area">
    <input
      id="freeText"
      type="text"
      placeholder="Type your message..."
      onkeydown="handleKeyDown(event)"
    >
    <button onclick="sendFreeText()">Send</button>
  </div>
</div>

<スクリプト>
let messagingReady = false;
let buttonCreated = false;
let conversationOpen = false;
let botReady = false;
let pendingMessage = null;
let sending = false;
let starterDecisionCompleted = false;

/* Enhanced Web Chat API Ready */
window.addEventListener("onEmbeddedMessagingReady", function () {
  messagingReady = true;

  /* Wait briefly to check whether an existing conversation is loaded */
  setTimeout(function () {
    if (starterDecisionCompleted) return;

    starterDecisionCompleted = true;
    document.getElementById("starterLoading").style.display = "none";

    if (!conversationOpen) {
      document.getElementById("starterPanel").style.display = "block";
    }
  }, 2000);
});

/* Chat Button Created */
window.addEventListener("onEmbeddedMessagingButtonCreated", function () {
  buttonCreated = true;
});

/* Existing Conversation Loaded */
window.addEventListener("onEmbeddedMessagingConversationOpened", function () {
  conversationOpen = true;
  starterDecisionCompleted = true;

  document.getElementById("starterLoading").style.display = "none";
  document.getElementById("starterPanel").style.display = "none";
});

/* First Bot Message */
window.addEventListener("onEmbeddedMessagingFirstBotMessageSent", async function () {
  botReady = true;

  if (pendingMessage) {
    await sendPendingMessage();
  }
});

/* Starter Prompt */
async function startWithMessage(message) {
  if (!messagingReady || !buttonCreated) return;

  pendingMessage = message;
  document.getElementById("starterPanel").style.display = "none";

  try {
    await embeddedservice_bootstrap.utilAPI.launchChat();

    /* Send immediately if the bot is already ready */
    if (botReady) {
      await sendPendingMessage();
    }
  } catch (error) {
    console.error("Unable to launch chat:", error);
    pendingMessage = null;
    document.getElementById("starterPanel").style.display = "block";
  }
}

/* Send Pending Message */
async function sendPendingMessage() {
  if (!pendingMessage || sending) return;

  sending = true;
  const message = pendingMessage;

  try {
    await embeddedservice_bootstrap.utilAPI.sendTextMessage(message);
    pendingMessage = null;
  } catch (error) {
    console.error("Unable to send message:", error);
  } finally {
    sending = false;
  }
}

/* Free Text */
function sendFreeText() {
  const input = document.getElementById("freeText");
  const message = input.value.trim();

  if (!message) return;

  startWithMessage(message);
}

/* Prevent Enter from sending a message while using an IME */
function handleKeyDown(event) {
  if (event.key === "Enter" && !event.isComposing) {
    event.preventDefault();
    sendFreeText();
  }
}

/* Enhanced Web Chat Initialization */
function initEmbeddedMessaging() {
  try {
    embeddedservice_bootstrap.settings.language = "en_US";

    /* Hide the standard Salesforce chat launcher */
    embeddedservice_bootstrap.settings.hideChatButtonOnLoad = true;

    /* Replace the following values with your own deployment settings */
    embeddedservice_bootstrap.init(
      "YOUR_ORG_ID",
      "YOUR_DEPLOYMENT_NAME",
      "YOUR_ESW_URL",
      {
        scrt2URL: "YOUR_SCRT2_URL"
      }
    );
  } catch (error) {
    console.error("Embedded Messaging initialization failed:", error);
  }
}
</スクリプト>

<!-- Replace with the bootstrap URL from your deployment -->
<スクリプト
  type="text/javaスクリプト"
  src="YOUR_ESW_URL/assets/js/bootstrap.min.js"
  onload="initEmbeddedMessaging()"
></スクリプト>

</body>
</html>

I principali valori da modificare sono:

• YOUR_ORG_ID
• YOUR_DEPLOYMENT_NAME
• YOUR_ESW_URL
• YOUR_SCRT2_URL

Una volta ottenuto il codice di embedding per Agentforce, è possibile applicarlo facilmente chiedendo a una IA generativa di adattarlo al codice di esempio riportato sopra.

Cosa fa questo codice di esempio

Osservando il codice completo, può sembrare un po’ lungo, ma il processo effettivo è semplice.

Prima di tutto:

hideChatButtonOnLoad = true

nasconde il Launcher standard di Salesforce.

Poi:

onEmbeddedMessagingReady

confirma che la Enhanced Web Chat API è pronta.

Se una Conversation esistente viene caricata:

onEmbeddedMessagingConversationOpened

nasconde gli starter prompts personalizzati.

Se non viene rilevata una Conversation esistente, gli starter prompts vengono mostrati dopo 2 secondi.

Quando l’utente clicca su uno starter prompt:

launchChat()

apre Enhanced Web Chat.

Poi attende:

onEmbeddedMessagingFirstBotMessageSent

e invia il contenuto selezionato ad Agentforce utilizzando:

sendTextMessage()

Quindi, la struttura complessiva è la seguente:

Apertura della pagina web
↓
Enhanced Web Chat Ready
↓
Verifica di una Conversation esistente
↓
Mostra lo Starter personalizzato
↓
L'utente effettua una scelta
↓
launchChat()
↓
Agentforce entra
↓
FirstBotMessageSent
↓
sendTextMessage()
↓
Avvio della conversazione con Agentforce

Il contenuto degli starter prompts può essere modificato liberamente

In questo esempio:

<button
  onclick="startWithMessage('Tell me about pricing')"
>
  Learn about pricing
</button>

viene utilizzato.

È quindi possibile anche separare il testo mostrato all’utente dal testo effettivamente inviato ad Agentforce.

Ad esempio:

<button
  onclick="startWithMessage('Tell me about the pricing structure for Product A')"
>
  Learn about pricing
</button>

Con questa implementazione, l’utente vede solo:

• Scopri i prezzi

mentre Agentforce riceve il messaggio più specifico:

• Tell me about the pricing structure for Product A

Utilizzando questo meccanismo, è possibile anche progettare una combinazione tra il flusso utente lato sito web e i Topics e Instructions lato Agentforce.

Verificare di utilizzare Enhanced Web Chat v2

La sendTextMessage() utilizzata in questo caso è un’API fornita dai Context Events di Enhanced Web Chat v2.

Pertanto, se si utilizza questo esempio così com’è, verificare che il Deployment target sia Enhanced Web Chat v2.

Inoltre, durante questa verifica, controllare:

• embeddedservice_bootstrap.utilAPI

dai Developer Tools è stato molto utile per il troubleshooting.

Ad esempio, eseguendo:

typeof embeddedservice_bootstrap
  .utilAPI
  .sendTextMessage

se il risultato è:

function

è possibile confermare che sendTextMessage() è disponibile in quel Runtime.

Che ne pensate?

La scoperta più importante durante questa verifica è stata che non è necessario modificare Agentforce in sé per creare una schermata iniziale personalizzata con starter prompts.

Ciò che volevo creare in questo caso non era:

• Modificare la UI della Conversation di Agentforce

ma piuttosto:

• Modificare l’esperienza sul sito web prima che inizi la Conversation con Agentforce

Pertanto, ciò può essere realizzato con la seguente struttura:

Sito web
↓
UI Starter personalizzata
↓
Enhanced Web Chat API
↓
Agentforce

Inoltre, quando ho effettivamente implementato la soluzione, eseguire semplicemente:

launchChat()

e subito dopo eseguire:

sendTextMessage()

non era affidabile.

Ho quindi creato una struttura che procede in base allo stato di Enhanced Web Chat e di Agentforce, utilizzando eventi standard di Salesforce come:

• onEmbeddedMessagingReady
• onEmbeddedMessagingButtonCreated
• onEmbeddedMessagingConversationOpened
• onEmbeddedMessagingFirstBotMessageSent

In particolare, invece di chiedersi:

• Quanti secondi devo attendere prima di eseguire il processo successivo?

è importante pensare:

• Confermare tramite un evento Salesforce che lo stato richiesto è stato raggiunto, prima di procedere con il passaggio successivo.

Come eccezione, Salesforce non fornisce un evento che indichi che “non esiste una Conversation esistente”, quindi si utilizza un breve Fallback Timer solo per determinare se lo Starter personalizzato debba essere mostrato inizialmente.

Se avete un requisito per creare una schermata iniziale personalizzata per Agentforce, invece di chiedervi solo:

• “Come dovrei modificare Agentforce?”

considerare:

• “Posso utilizzare la Enhanced Web Chat API lato sito web?”

potrebbe aiutarvi a individuare un metodo di implementazione efficace.

Lascio questo contenuto come nota per i miei archivi personali, poiché quando ho provato a realizzare questo meccanismo non sono riuscito a trovare informazioni al riguardo da nessuna parte.

È tutto per questa volta.

Nobuyuki Watanabe

---

Tradotto e adattato da SFMC Tips #336 : Agentforce: Implementing Starter Prompts for a Service Agent di Nobuyuki Watanabe (@marketingcloudtips), pubblicato originariamente su Medium. Traduzione autorizzata dall’autore.