Améliorer l'accès aux outils et réduire les temps d'attente dus à la latence

Lorsqu’un agent vocal appelle des outils externes ou prend du temps pour générer une réponse, les utilisateurs subissent un silence. Les réponses intermédiaires comblent ces temps d’attente avec des messages parlés courts, ce qui permet à la conversation de circuler naturellement pendant que le travail se déroule en arrière-plan.

Voice Live fournit la configuration de session interim_response pour générer automatiquement ces messages de pontage. La fonctionnalité prend en charge le mode agent (Foundry Agent Service) ainsi que le mode modèle.

Note

En mode Modélisation, les réponses intermédiaires sont uniquement prises en charge avec les LLM de texte en mode Cascade, ainsi que la sortie vocale azure-speech. Les modèles audio en temps réel ne prennent pas en charge les réponses intermédiaires.

Voice Live offre deux modes de réponse intermédiaires :

  • Réponse intermédiaire générée par LLM (llm_interim_response) : utilise un LLM léger pour générer dynamiquement du texte de remplissage prenant en charge le contexte. Idéal pour les réponses adaptatives et naturelles.
  • Réponse intermédiaire statique (static_interim_response) : sélectionne de manière aléatoire dans une liste prédéfinie de textes que vous fournissez. Idéal pour la messagerie déterministe ou personnalisée.

Les deux modes peuvent être déclenchés par :

Déclencheur Descriptif
latency Se déclenche lorsque la latence de réponse dépasse un seuil configurable (valeur par défaut : 2000 ms).
tool Se déclenche lorsqu’un appel d’outil est en cours d’exécution.

Les déclencheurs utilisent une logique OR : tout déclencheur correspondant active une réponse intermédiaire.

Prerequisites

Avant de commencer, procédez comme suit :

Configurer les réponses intermédiaires générées par LLM

Les réponses intermédiaires générées par LLM utilisent un modèle léger (par défaut : gpt-4.1-mini) pour créer du texte de liaison tenant compte du contexte. Vous pouvez personnaliser les instructions et les limites des jetons.

Paramètres de configuration

Paramètre Type Descriptif
type ficelle Doit être llm_interim_response (ou l’énumération du Kit de développement logiciel (SDK) équivalente).
triggers tableau Liste des déclencheurs : latency, toolou les deux. Par défaut : ["latency"].
latency_threshold_ms entier Millisecondes avant le déclenchement du déclencheur de latence. Valeur par défaut : 2000. Minimum : 0.
model ficelle Modèle de génération de texte intermédiaire. Par défaut : gpt-4.1-mini.
instructions ficelle Demande personnalisée pour la réponse intermédiaire LLM.
max_completion_tokens entier Nombre maximal de jetons pour la réponse générée. Valeur par défaut : 50. Minimum : 1.

Configuration du kit de développement logiciel (SDK)

from azure.ai.voicelive.models import (
    LlmInterimResponseConfig,
    InterimResponseTrigger,
    RequestSession,
)

interim_response_config = LlmInterimResponseConfig(
    triggers=[InterimResponseTrigger.TOOL, InterimResponseTrigger.LATENCY],
    latency_threshold_ms=200,
    instructions="Create friendly interim responses indicating wait time "
                 "due to ongoing processing, if any. Do not include in "
                 "all responses!"
)

session_config = RequestSession(
    interim_response=interim_response_config,
    # ... other session options
)

await connection.session.update(session=session_config)

Configuration du kit de développement logiciel (SDK)

var interimConfig = new LlmInterimResponseConfig
{
    Instructions = "Create friendly interim responses indicating "
        + "wait time due to ongoing processing, if any. "
        + "Do not include in all responses!",
};
interimConfig.Triggers.Add(InterimResponseTrigger.Tool);
interimConfig.Triggers.Add(InterimResponseTrigger.Latency);
interimConfig.LatencyThresholdMs = 200;

var options = new VoiceLiveSessionOptions
{
    InterimResponse = BinaryData.FromObjectAsJson(interimConfig),
    // ... other session options
};

await session.ConfigureSessionAsync(options, cancellationToken);

Configuration du kit de développement logiciel (SDK)

LlmInterimResponseConfig interimResponseConfig = new LlmInterimResponseConfig()
        .setTriggers(Arrays.asList(
                InterimResponseTrigger.TOOL,
                InterimResponseTrigger.LATENCY))
        .setLatencyThresholdMs(200)
        .setInstructions("Create friendly interim responses indicating "
                + "wait time due to ongoing processing, if any. "
                + "Do not include in all responses!");

VoiceLiveSessionOptions sessionOptions = new VoiceLiveSessionOptions()
        .setInterimResponse(BinaryData.fromObject(interimResponseConfig));
        // ... other session options

session.sendEvent(new ClientEventSessionUpdate(sessionOptions)).block();

Configuration du kit de développement logiciel (SDK)

await session.updateSession({
    interimResponse: {
        type: "llm_interim_response",
        triggers: ["tool", "latency"],
        latencyThresholdInMs: 200,
        instructions:
            "Create friendly interim responses indicating wait time " +
            "due to ongoing processing, if any. " +
            "Do not include in all responses!",
    },
    // ... other session options
});

Configurer des réponses intermédiaires statiques

Les réponses intermédiaires statiques sélectionnent de manière aléatoire dans une liste prédéfinie de textes chaque fois qu’un déclencheur se déclenche. Cette approche vous donne un contrôle total sur ce que dit l’agent pendant les temps d’attente.

Paramètres de configuration

Paramètre Type Descriptif
type ficelle Doit être static_interim_response (ou l’énumération du Kit de développement logiciel (SDK) équivalente).
triggers tableau Liste des déclencheurs : latency, toolou les deux. Par défaut : ["latency"].
latency_threshold_ms entier Millisecondes avant le déclenchement du déclencheur de latence. Valeur par défaut : 2000. Minimum : 0.
texts tableau Liste des options de texte de réponse intermédiaire parmi lesquelles choisir au hasard.

Configuration JSON non traitée

Les réponses intermédiaires statiques peuvent être envoyées en tant que commande brute session.update :

import json

static_config = {
    "type": "session.update",
    "session": {
        "interim_response": {
            "type": "static_interim_response",
            "triggers": ["tool", "latency"],
            "latency_threshold_ms": 1500,
            "texts": [
                "Let me look that up for you.",
                "One moment while I check on that.",
                "Just a second, I'm working on it."
            ]
        }
    }
}
await connection.send(json.dumps(static_config))

Configuration du kit de développement logiciel (SDK)

var staticConfig = new StaticInterimResponseConfig();
staticConfig.Texts.Add("Let me look that up for you.");
staticConfig.Texts.Add("One moment while I check on that.");
staticConfig.Texts.Add("Just a second, I'm working on it.");
staticConfig.Triggers.Add(InterimResponseTrigger.Tool);
staticConfig.Triggers.Add(InterimResponseTrigger.Latency);
staticConfig.LatencyThresholdMs = 1500;

var options = new VoiceLiveSessionOptions
{
    InterimResponse = BinaryData.FromObjectAsJson(staticConfig),
    // ... other session options
};

await session.ConfigureSessionAsync(options, cancellationToken);

Configuration JSON non traitée

String staticConfig = """
    {
        "type": "session.update",
        "session": {
            "interim_response": {
                "type": "static_interim_response",
                "triggers": ["tool", "latency"],
                "latency_threshold_ms": 1500,
                "texts": [
                    "Let me look that up for you.",
                    "One moment while I check on that.",
                    "Just a second, I'm working on it."
                ]
            }
        }
    }
    """;
session.sendEvent(BinaryData.fromString(staticConfig)).block();

Configuration JSON non traitée

await session.updateSession({
    interimResponse: {
        type: "static_interim_response",
        triggers: ["tool", "latency"],
        latencyThresholdInMs: 1500,
        texts: [
            "Let me look that up for you.",
            "One moment while I check on that.",
            "Just a second, I'm working on it.",
        ],
    },
});

Choisir l’approche appropriée

Requirement Généré par LLM Statique
Réponses adaptatives prenant en charge le contexte ✔ ✖
Texte déterministe et prévisible ✖ ✔
Langage contrôlé par la marque Selon les instructions ✔
Variété conversationnelle ✔ Limité aux textes configurés
Aucun coût d’inférence de modèle supplémentaire ✖ ✔
Configuration minimale ✔ Nécessite une liste de texte

Prochaines étapes

  • Dernière mise à jour :