Gérer les sessions pour l'API Live

Les processus Gemini Live API traitent des flux continus d'audio ou de texte appelés sessions. Vous pouvez gérer le cycle de vie de la session, de la première prise de contact à l'arrêt progressif.

Limites pour les sessions

Pour Live API, une session fait référence à une connexion persistante où les entrées et les sorties sont diffusées en continu sur la même connexion.

Si la session dépasse l'une des limites suivantes, la connexion est interrompue.

  • La durée de la connexion est limitée à environ 10 minutes.

  • La durée de la session dépend des modalités d'entrée :

    • Les sessions d'entrée audio uniquement sont limitées à 15 minutes.
    • Les entrées vidéo et audio sont limitées à deux minutes.

  • La fenêtre de contexte de session est limitée à 128 000 jetons.

Vous recevrez une notification de fin de service avant la fin de la connexion, ce qui vous permettra de prendre d'autres mesures.

Démarrer une session

Consultez le guide de démarrage de Live API pour obtenir un extrait complet montrant comment démarrer une session.

Mettre à jour en cours de session

Les modèles Live API sont compatibles avec les fonctionnalités avancées suivantes pour les mises à jour en cours de session :

Ajouter des mises à jour incrémentielles du contenu

Vous pouvez ajouter des mises à jour incrémentielles pendant une session active. Utilisez-le pour envoyer une entrée textuelle, ou établir ou restaurer le contexte de la session.

  • Pour les contextes plus longs, nous vous recommandons de fournir un seul résumé des messages afin de libérer la fenêtre de contexte pour les interactions ultérieures.

  • Pour les contextes courts, vous pouvez envoyer des interactions au fur et à mesure pour représenter la séquence exacte des événements, comme dans l'extrait ci-dessous.

Swift 

// Define initial turns (history/context).
let turns: [ModelContent] = [
  ModelContent(role: "user", parts: [TextPart("What is the capital of France?")]),
  ModelContent(role: "model", parts: [TextPart("Paris")]),
]

// Send history, keeping the conversational turn OPEN (false).
await session.sendContent(turns, turnComplete: false)

// Define the new user query.
let newTurn: [ModelContent] = [
  ModelContent(role: "user", parts: [TextPart("What is the capital of Germany?")]),
]

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.sendContent(newTurn, turnComplete: true)

Kotlin 

Not yet supported for Android apps - check back soon!

Java 

Not yet supported for Android apps - check back soon!

Web 

const turns = [{ text: "Hello from the user!" }];

await session.send(
  turns,
  false // turnComplete: false
);

console.log("Sent history. Waiting for next input...");

// Define the new user query.
const newTurn [{ text: "And what is the capital of Germany?" }];

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.send(
    newTurn,
    true // turnComplete: true
);
console.log("Sent final query. Model response expected now.");

Dart 

// Define initial turns (history/context).
final List turns = [
  Content(
    "user",
    [Part.text("What is the capital of France?")],
  ),
  Content(
    "model",
    [Part.text("Paris")],
  ),
];

// Send history, keeping the conversational turn OPEN (false).
await session.send(
  input: turns,
  turnComplete: false,
);

// Define the new user query.
final List newTurn = [
  Content(
    "user",
    [Part.text("What is the capital of Germany?")],
  ),
];

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.send(
  input: newTurn,
  turnComplete: true,
);

Unity 

// Define initial turns (history/context).
List turns = new List {
    new ModelContent("user", new ModelContent.TextPart("What is the capital of France?") ),
    new ModelContent("model", new ModelContent.TextPart("Paris") ),
};

// Send history, keeping the conversational turn OPEN (false).
foreach (ModelContent turn in turns)
{
    await session.SendAsync(
        content: turn,
        turnComplete: false
    );
}

// Define the new user query.
ModelContent newTurn = ModelContent.Text("What is the capital of Germany?");

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.SendAsync(
    content: newTurn,
    turnComplete: true
);

Mettre à jour les instructions système en cours de session

Disponible uniquement lorsque vous utilisez Vertex AI Gemini API comme fournisseur d'API.

Vous pouvez mettre à jour les instructions système pendant une session active. Utilisez-le pour adapter les réponses du modèle, par exemple pour changer la langue de la réponse ou modifier le ton.

Pour mettre à jour les instructions système en cours de session, vous pouvez envoyer du contenu textuel avec le rôle system. Les instructions système modifiées resteront en vigueur pour le reste de la session.

Swift 

await session.sendContent(
  [ModelContent(
    role: "system",
    parts: [TextPart("new system instruction")]
  )],
  turnComplete: false
)

Kotlin 

Not yet supported for Android apps - check back soon!

Java 

Not yet supported for Android apps - check back soon!

Web 

Not yet supported for Web apps - check back soon!

Dart 

try {
  await _session.send(
    input: Content(
      'system',
      [Part.text('new system instruction')],
    ),
    turnComplete: false,
  );
} catch (e) {
  print('Failed to update system instructions: $e');
}

Unity 

try
{
    await session.SendAsync(
        content: new ModelContent(
            "system",
            new ModelContent.TextPart("new system instruction")
        ),
        turnComplete: false
    );
}
catch (Exception e)
{
    Debug.LogError($"Failed to update system instructions: {e.Message}");
}

Détecter la fin d'une session

Une notification going away est envoyée au client 60 secondes avant la fin de la session, ce qui vous permet d'effectuer d'autres actions.

L'exemple suivant montre comment détecter l'arrêt imminent d'une session en écoutant une notification going away :

Swift 

for try await response in session.responses {
  switch response.payload {

  case .goingAwayNotice(let goingAwayNotice):
    // Prepare for the session to close soon
    if let timeLeft = goingAwayNotice.timeLeft {
        print("Server going away in \(timeLeft) seconds")
    }
  }
}

Kotlin 

for (response in session.responses) {
    when (val message = response.payload) {
        is LiveServerGoAway -> {
            // Prepare for the session to close soon
            val remaining = message.timeLeft
            logger.info("Server going away in $remaining")
        }
    }
}

Java 

session.getResponses().forEach(response -> {
    if (response.getPayload() instanceof LiveServerResponse.GoingAwayNotice) {
        LiveServerResponse.GoingAwayNotice notice = (LiveServerResponse.GoingAwayNotice) response.getPayload();
        // Prepare for the session to close soon
        Duration timeLeft = notice.getTimeLeft();
    }
});

Web 

for await (const message of session.receive()) {
  switch (message.type) {

  ...
  case "goingAwayNotice":
    console.log("Server going away. Time left:", message.timeLeft);
    break;
  }
}

Dart 

Future _handleLiveServerMessage(LiveServerResponse response) async {
  final message = response.message;
  if (message is GoingAwayNotice) {
     // Prepare for the session to close soon
     developer.log('Server going away. Time left: ${message.timeLeft}');
  }
}

Unity 

foreach (var response in session.Responses) {
    if (response.Payload is LiveSessionGoingAway notice) {
        // Prepare for the session to close soon
        TimeSpan timeLeft = notice.TimeLeft;
        Debug.Log($"Server going away notice received. Remaining: {timeLeft}");
    }
}