Notifier les assistants

Important

Vous devez faire partie du programme Frontier en version préliminaire pour obtenir un accès anticipé à Microsoft Agent 365. Frontier vous connecte directement aux dernières innovations d’IA de Microsoft. Les versions préliminaires Frontier sont soumises aux conditions existantes de vos contrats clients qui régissent les versions préliminaires. Comme ces fonctionnalités sont encore en cours de développement, leur disponibilité et leurs capacités peuvent évoluer au fil du temps.

Le module Notifications permet aux développeurs de créer des assistants capables de répondre aux événements et notifications provenant des applications Microsoft 365. Grâce à la prise en charge des notifications, les assistants peuvent recevoir et traiter des alertes lorsque les utilisateurs interagissent avec eux par courrier électronique, via des commentaires dans des documents ou dans d’autres scénarios collaboratifs.

Flux de travail de notifications

Suivez ce flux de travail pour activer les notifications pour votre application d’assistant IA :

1. Installer les packages de notification.

2. Importer des composants de notification

   • Importer des classes de notification et des gestionnaires
   • Importer des types d’activités et des identificateurs de canal

3. Inscrire des gestionnaires de notification

   • Utiliser des méthodes de gestionnaire de notification pour inscrire des routages
   • Configurer des gestionnaires pour des types de notification spécifiques (par exemple : courrier électronique, Word, Excel, PowerPoint)

4. Traiter les notifications dans le code de l’assistant

   • L’assistant reçoit des notifications provenant des applications Microsoft 365
   • Gérer les notifications entrantes et répondre de manière appropriée

Types de notifications

Le SDK Agents 365 prend en charge les types de notifications suivants :

Type de notification	Description	ID de sous-canal
Courrier électronique	L’assistant reçoit un courrier électronique dans lequel il est mentionné ou directement adressé	email
Word	L’assistant est mentionné dans un commentaire d’un document Word	word
Excel	L’assistant est mentionné dans un commentaire d’un document Excel	excel
PowerPoint	L’assistant est mentionné dans un commentaire d’un document PowerPoint	powerpoint
Événements de cycle de vie	Notifications du cycle de vie de l’assistant (identité utilisateur créée, intégration à une charge de travail, utilisateur supprimé)	S.O.

Événements de cycle de vie de l’assistant

Les événements du cycle de vie de l’assistant permettent à votre assistant de répondre à des événements système spécifiques liés à la gestion de l’identité utilisateur agentique. Le SDK prend actuellement en charge trois événements du cycle de vie :

Type d'événement	ID de l’événement	Description
Identité utilisateur créée	agenticUserIdentityCreated	Déclenché lors de la création d’une identité d’utilisateur agentique
Mise à jour de l’intégration à une charge de travail	agenticUserWorkloadOnboardingUpdated	Déclenché lorsque le statut d’intégration à une charge de travail d’un utilisateur agentique est mis à jour
Utilisateur supprimé	agenticUserDeleted	Déclenché lors de la suppression d’une identité d’utilisateur agentique

Ces événements permettent aux assistants d’exécuter des tâches d’initialisation, des opérations de nettoyage ou une gestion d’état en réponse aux changements du cycle de vie de l’utilisateur.

Ajouter des notifications à votre assistant

Procédez comme suit pour activer la gestion des notifications dans votre assistant existant :

Importer des composants de notification

Ajoutez ces importations à votre fichier d’assistant :

Python

from microsoft_agents_a365 import AgentApplication
from microsoft_agents_a365.notifications import (
    AgentNotification,
    AgentNotificationActivity,
    NotificationTypes
)
from microsoft_agents.activity import ChannelId
from microsoft_agents.hosting.core import Authorization, TurnContext

• AgentApplication : classe de base pour la création d’applications Agent365 ; fournit les fonctionnalités essentielles pour le routage des activités, la gestion de l’état et le traitement des requêtes
• AgentNotification : classe permettant d’enregistrer des gestionnaires de notifications à l’aide de méthodes décoratrices. Fournit on_agent_notification(), on_email(), on_word()et d’autres décorateurs utilitaires
• AgentNotificationActivity : wrapper contenant des données de notification analysées, avec des propriétés typées telles que email_notification et wpx_comment_notification qui contiennent des métadonnées spécifiques à la notification (ID, détails de conversation, références de document)
• NotificationTypes : énumération des types de notification pris en charge (EMAIL_NOTIFICATION, WPX_COMMENT, AGENT_LIFECYCLE)
• ChannelId : utilisé pour spécifier des canaux de notification (par exemple, ChannelId(channel="agents", sub_channel="*"))
• Authorization : contexte d’autorisation pour le traitement des notifications
• TurnContext : contexte de tour de conversation actuel à partir du SDK Agents

JavaScript

import { AgentApplication, TurnContext, TurnState } from '@microsoft/agents-hosting';
import { ActivityTypes } from '@microsoft/agents-activity';
import { 
  AgentNotificationActivity,
  NotificationType
} from '@microsoft/agents-a365-notifications';

• AgentApplication : classe de base pour la création d’applications Agent365 ; fournit les fonctionnalités essentielles pour le routage des activités, la gestion de l’état et le traitement des requêtes. Utiliser onAgentNotification() pour inscrire des gestionnaires
• AgentNotificationActivity : activité de notification analysée contenant des données de notification fortement typées. Les propriétés comme emailNotification et wpxCommentNotification contiennent des métadonnées spécifiques aux notifications (ID, détails de conversation, références de document)
• NotificationType : énumération des types de notification (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
• TurnContext : contexte de tour de conversation actuel
• TurnState : gestion de l’état pour la conversation

.NET

using Microsoft.Agents.Hosting;
using Microsoft.Agents.A365.Notifications;
using Microsoft.Agents.A365.Notifications.Extensions;
using Microsoft.Agents.A365.Notifications.Models;

• AgentApplication : classe de base pour la création d’applications Agent365 ; fournit les fonctionnalités essentielles pour le routage des activités, la gestion de l’état et le traitement des requêtes. Utiliser OnAgentNotification() pour inscrire des gestionnaires
• AgentNotificationActivity : enveloppe une activité avec des données de notification fortement typées. Les propriétés comme EmailNotification et WpxCommentNotification contiennent des métadonnées spécifiques aux notifications (ID, détails de conversation, références de document)
• NotificationTypeEnum : énumération des types de notification pris en charge (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
• ITurnContext : interface représentant le contexte de tour de conversation actuel
• ITurnState : interface de gestion de l’état de conversation

Inscrire des gestionnaires de notification dans votre assistant

Ajouter des gestionnaires de notifications à l’initialisation de votre assistant :

Python

class YourAgent(AgentApplication):
    def __init__(self, app):
        # Create notification handler
        agent_notification = AgentNotification(app)
        
        # Register handler for all notifications
        @agent_notification.on_agent_notification(
            ChannelId(channel="agents", sub_channel="*")
        )
        async def handle_all_notifications(context, state, notification):
            # Route based on notification type
            if notification.notification_type == NotificationTypes.EMAIL_NOTIFICATION:
                await self.handle_email_notification(context, state, notification)
            elif notification.notification_type == NotificationTypes.WPX_COMMENT:
                await self.handle_comment_notification(context, state, notification)
            else:
                await context.send_activity('Notification type not yet implemented.')

JavaScript

export class YourAgent extends AgentApplication {
  constructor() {
    super();
    
    // Register notification handler
    this.onAgentNotification("*", async (context, state, notification) => {
      await this.handleAgentNotificationActivity(context, state, notification);
    });
  }
  
  async handleAgentNotificationActivity(context, state, notification) {
    // Route based on notification type
    switch (notification.notificationType) {
      case NotificationType.EmailNotification:
        await this.handleEmailNotification(context, state, notification);
        break;
      case NotificationType.WpxComment:
        await this.handleCommentNotification(context, state, notification);
        break;
      default:
        await context.sendActivity('Notification type not yet implemented.');
    }
  }
}

.NET

public class YourAgent : AgentApplication
{
    public YourAgent()
    {
        // Register notification handler
        this.OnAgentNotification(
            "*",
            HandleNotificationAsync
        );
    }
    
    private async Task HandleNotificationAsync(
        ITurnContext turnContext,
        ITurnState turnState,
        AgentNotificationActivity activity,
        CancellationToken cancellationToken)
    {
        // Route based on notification type
        switch (activity.NotificationType)
        {
            case NotificationTypeEnum.EmailNotification:
                await HandleEmailNotificationAsync(turnContext, turnState, activity, 
                    cancellationToken);
                break;
            case NotificationTypeEnum.WpxComment:
                await HandleCommentNotificationAsync(turnContext, turnState, activity, 
                    cancellationToken);
                break;
            default:
                await turnContext.SendActivityAsync("Notification type not yet implemented.", 
                    cancellationToken: cancellationToken);
                break;
        }
    }
}

Implémenter des gestionnaires de notification spécifiques

Ajouter des méthodes de gestionnaire pour chaque type de notification :

Python

class YourAgent(AgentApplication):
    # ... __init__ from above ...
    
    async def handle_email_notification(self, context, state, notification):
        """Handle email notifications"""
        email = notification.email_notification
        
        if not email:
            await context.send_activity('No email data found')
            return
        
        # Process the email
        await context.send_activity(
            f'Received email notification. Email ID: {email.id}'
        )
        
        # Your email processing logic here
    
    async def handle_comment_notification(self, context, state, notification):
        """Handle document comment notifications"""
        comment = notification.wpx_comment_notification
        
        if not comment:
            await context.send_activity('No comment data found')
            return
        
        # Process the comment
        await context.send_activity(
            f'Received comment notification. Document ID: {comment.document_id}'
        )
        
        # Your comment processing logic here

JavaScript

async handleEmailNotification(context, state, notification) {
  const email = notification.emailNotification;
  
  if (!email) {
    await context.sendActivity('No email data found');
    return;
  }
  
  // Process the email
  await context.sendActivity(`Received email notification. Email ID: ${email.id}`);
  
  // Your email processing logic here
}

async handleCommentNotification(context, state, notification) {
  const comment = notification.wpxCommentNotification;
  
  if (!comment) {
    await context.sendActivity('No comment data found');
    return;
  }
  
  // Process the comment
  await context.sendActivity(`Received comment. Document ID: ${comment.documentId}`);
  
  // Your comment processing logic here
}

.NET

private async Task HandleEmailNotificationAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    var email = activity.EmailNotification;
    
    if (email == null)
    {
        await turnContext.SendActivityAsync("No email data found", 
            cancellationToken: cancellationToken);
        return;
    }
    
    // Process the email
    await turnContext.SendActivityAsync(
        $"Received email notification. Email ID: {email.Id}",
        cancellationToken: cancellationToken
    );
    
    // Your email processing logic here
}

private async Task HandleCommentNotificationAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    var comment = activity.WpxCommentNotification;
    
    if (comment == null)
    {
        await turnContext.SendActivityAsync("No comment data found", 
            cancellationToken: cancellationToken);
        return;
    }
    
    // Process the comment
    await turnContext.SendActivityAsync(
        $"Received comment. Document ID: {comment.DocumentId}",
        cancellationToken: cancellationToken
    );
    
    // Your comment processing logic here
}

Gestionnaires de notification spécialisés

Après avoir configuré le routage de notification de base, utilisez des méthodes de gestionnaire spécialisées pour un contrôle plus granulaire. Ces méthodes vous permettent d’effectuer les tâches suivantes :

• Inscrire plusieurs gestionnaires pour le même type de notification
• Définir la priorité des gestionnaires à l’aide d’un classement
• Configurer l’authentification automatique par gestionnaire

Note

Pour la plupart des cas d’usage, le modèle de gestionnaire générique est suffisant. Utilisez ces gestionnaires spécialisés lorsque vous avez besoin d’un routage avancé ou de plusieurs gestionnaires pour le même type de notification.

Gestionnaire spécialisé pour toutes les notifications

Inscrire d’autres gestionnaires qui traitent tous les types de notification :

Python

from microsoft_agents_a365.notifications import (
    AgentNotification,
    NotificationTypes
)
from microsoft_agents.activity import ChannelId

# Create notification handler
agent_notification = AgentNotification(app)

# Register handler for all notifications
@agent_notification.on_agent_notification(
    ChannelId(channel="agents", sub_channel="*")
)
async def handle_all_notifications(context, state, notification):
    if notification.notification_type == NotificationTypes.EMAIL_NOTIFICATION:
        if notification.email_notification:
            await context.send_activity(f"Received email: {notification.email_notification.id}")
    elif notification.notification_type == NotificationTypes.WPX_COMMENT:
        if notification.wpx_comment_notification:
            await context.send_activity(f"Received comment: {notification.wpx_comment_notification.comment_id}")

JavaScript

import '@microsoft/agents-a365-notifications';

// Register handler for all notifications
app.onAgentNotification('*', async (context, state, notification) => {
  const { notificationType, emailNotification, wpxCommentNotification } = notification;

  switch (notificationType) {
    case NotificationType.EmailNotification:
      if (emailNotification) {
        console.log('Email ID:', emailNotification.id);
        await context.sendActivity('Processing your email...');
      }
      break;
    
    case NotificationType.WpxComment:
      if (wpxCommentNotification) {
        console.log('Comment ID:', wpxCommentNotification.commentId);
        await context.sendActivity('Responding to your comment...');
      }
      break;
  }
});

.NET

using Microsoft.Agents.A365.Notifications;
using Microsoft.Agents.A365.Notifications.Extensions;
using Microsoft.Agents.A365.Notifications.Models;

// Register handler for all notifications (wildcard)
this.OnAgentNotification(
    "*",
    AgentNotificationActivityAsync
);

private async Task AgentNotificationActivityAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    switch (activity.NotificationType)
    {
        case NotificationTypeEnum.EmailNotification:
            var email = activity.EmailNotification;
            if (email != null)
            {
                await turnContext.SendActivityAsync(
                    $"Received email: {email.Id}",
                    cancellationToken: cancellationToken
                );
            }
            break;
            
        case NotificationTypeEnum.WpxComment:
            var comment = activity.WpxCommentNotification;
            if (comment != null)
            {
                await turnContext.SendActivityAsync(
                    $"Received comment: {comment.CommentId}",
                    cancellationToken: cancellationToken
                );
            }
            break;
    }
}

Gestionnaire spécialisé pour les notifications de courrier électronique

Inscrire davantage de gestionnaires spécifiquement pour les notifications de courrier électronique :

Python

from microsoft_agents_a365.notifications import AgentNotification
from microsoft_agents.activity import ChannelId, AgentSubChannel

# Create notification handler
agent_notification = AgentNotification(app)

# Use the convenience method for email notifications
@agent_notification.on_email()
async def handle_email(context, state, notification):
    email = notification.email_notification
    
    if not email:
        await context.send_activity('No email found')
        return
    
    # Process the email
    email_id = email.id
    conversation_id = email.conversation_id
    
    # Send response
    await context.send_activity('Thank you for your email!')

JavaScript

app.onAgenticEmailNotification(async (context, state, notification) => {
  const email = notification.emailNotification;

  if (!email) {
    await context.sendActivity('No email found');
    return;
  }

  // Process the email
  console.log('Email ID:', email.id);
  console.log('Conversation ID:', email.conversationId);

  // Send a response
  await context.sendActivity('Thank you for your email!');
});

.NET

// Register handler for email notifications
this.OnAgenticEmailNotification(HandleEmailNotificationAsync);

private async Task HandleEmailNotificationAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    var email = activity.EmailNotification;
    
    if (email == null)
    {
        await turnContext.SendActivityAsync("No email found", 
            cancellationToken: cancellationToken);
        return;
    }
    
    // Process email
    var emailId = email.Id;
    var conversationId = email.ConversationId;
    
    // Send response
    await turnContext.SendActivityAsync(
        "Thank you for your email!",
        cancellationToken: cancellationToken
    );
}

Gestionnaires spécialisés pour les commentaires de documents

Inscrire davantage de gestionnaires pour les notifications de commentaires Word, Excel et PowerPoint :

Python

from microsoft_agents_a365.notifications import AgentNotification

# Create notification handler
agent_notification = AgentNotification(app)

# Use convenience methods for document notifications
@agent_notification.on_word()
async def handle_word(context, state, notification):
    comment = notification.wpx_comment_notification
    
    if comment:
        document_id = comment.document_id
        comment_id = comment.comment_id
        await context.send_activity(f'Processing Word comment: {comment_id}')

@agent_notification.on_excel()
async def handle_excel(context, state, notification):
    comment = notification.wpx_comment_notification
    
    if comment:
        await context.send_activity('Processing Excel comment')

@agent_notification.on_powerpoint()
async def handle_powerpoint(context, state, notification):
    comment = notification.wpx_comment_notification
    
    if comment:
        await context.send_activity('Processing PowerPoint comment')

JavaScript

// Handle Word notifications
app.onAgenticWordNotification(async (context, state, notification) => {
  const comment = notification.wpxCommentNotification;
  
  if (comment) {
    console.log('Word comment:', comment.commentText);
    await context.sendActivity('Processing your Word comment...');
  }
});

// Handle Excel notifications
app.onAgenticExcelNotification(async (context, state, notification) => {
  const comment = notification.wpxCommentNotification;
  
  if (comment) {
    await context.sendActivity('Processing your Excel comment...');
  }
});

// Handle PowerPoint notifications
app.onAgenticPowerPointNotification(async (context, state, notification) => {
  const comment = notification.wpxCommentNotification;
  
  if (comment) {
    await context.sendActivity('Processing your PowerPoint comment...');
  }
});

.NET

// Register handlers for document notifications
this.OnAgenticWordNotification(HandleWordNotificationAsync);
this.OnAgenticExcelNotification(HandleExcelNotificationAsync);
this.OnAgenticPowerPointNotification(HandlePowerPointNotificationAsync);

private async Task HandleWordNotificationAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    var comment = activity.WpxCommentNotification;
    
    if (comment != null)
    {
        await turnContext.SendActivityAsync(
            $"Processing Word comment: {comment.CommentText}",
            cancellationToken: cancellationToken
        );
    }
}

private async Task HandleExcelNotificationAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    var comment = activity.WpxCommentNotification;
    
    if (comment != null)
    {
        await turnContext.SendActivityAsync(
            "Processing Excel comment",
            cancellationToken: cancellationToken
        );
    }
}

private async Task HandlePowerPointNotificationAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    var comment = activity.WpxCommentNotification;
    
    if (comment != null)
    {
        await turnContext.SendActivityAsync(
            "Processing PowerPoint comment",
            cancellationToken: cancellationToken
        );
    }
}

Gestionnaires spécialisés pour les événements de cycle de vie

Inscrire d’autres gestionnaires pour les événements de cycle de vie de l’assistant, tels que la création d’identité d’utilisateur, l’intégration des charges de travail et la suppression des utilisateurs :

Python

from microsoft_agents_a365.notifications import AgentNotification

# Create notification handler
agent_notification = AgentNotification(app)

# Handle all lifecycle events
@agent_notification.on_agent_lifecycle_notification("*")
async def handle_lifecycle(context, state, notification):
    lifecycle_notification = notification.agent_lifecycle_notification
    if lifecycle_notification:
        event_type = lifecycle_notification.lifecycle_event_type
        
        if event_type == "agenticUserIdentityCreated":
            await context.send_activity('User identity created')
        elif event_type == "agenticUserWorkloadOnboardingUpdated":
            await context.send_activity('Workload onboarding completed')
        elif event_type == "agenticUserDeleted":
            await context.send_activity('User identity deleted')

JavaScript

// Handle all lifecycle notifications
app.onLifecycleNotification(async (context, state, notification) => {
  await context.sendActivity('Lifecycle event received');
});

// Handle specific lifecycle events
app.onAgenticUserCreatedNotification(async (context, state, notification) => {
  await context.sendActivity('User identity created');
});

app.onAgenticUserWorkloadOnboardingNotification(
  async (context, state, notification) => {
    await context.sendActivity('Workload onboarding completed');
  }
);

app.onAgenticUserIdentityDeletedNotification(
  async (context, state, notification) => {
    await context.sendActivity('User identity deleted');
  }
);

.NET

// Register lifecycle notification handlers
this.OnLifecycleNotification(HandleAllLifecycleEventsAsync);
this.OnAgenticUserIdentityCreatedNotification(HandleUserCreatedAsync);
this.OnAgenticUserWorkloadOnboardingNotification(HandleWorkloadOnboardingAsync);
this.OnAgenticUserDeletedNotification(HandleUserDeletedAsync);

private async Task HandleAllLifecycleEventsAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    await turnContext.SendActivityAsync(
        "Lifecycle event received",
        cancellationToken: cancellationToken
    );
}

private async Task HandleUserCreatedAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    await turnContext.SendActivityAsync(
        "User identity created",
        cancellationToken: cancellationToken
    );
}

private async Task HandleWorkloadOnboardingAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    await turnContext.SendActivityAsync(
        "Workload onboarding completed",
        cancellationToken: cancellationToken
    );
}

private async Task HandleUserDeletedAsync(
    ITurnContext turnContext,
    ITurnState turnState,
    AgentNotificationActivity activity,
    CancellationToken cancellationToken)
{
    await turnContext.SendActivityAsync(
        "User identity deleted",
        cancellationToken: cancellationToken
    );
}

Configuration avancée

Cette section décrit les options de configuration avancées pour affiner vos gestionnaires de notification. Ces configurations vous permettent de contrôler l’ordre d’exécution du gestionnaire, de gérer les exigences d’authentification et d’optimiser le traitement des notifications pour les scénarios complexes.

Priorité et classement des gestionnaires

Lorsque vous utilisez plusieurs gestionnaires spécialisés, vous pouvez spécifier l’ordre de priorité à l’aide de valeurs de classement. Des valeurs de classement plus faibles indiquent une priorité plus élevée :

Python

from microsoft_agents_a365.notifications import AgentNotification
from microsoft_agents.activity import ChannelId, AgentSubChannel

# Create notification handler
agent_notification = AgentNotification(app)

# Higher priority handler (processed first)
@agent_notification.on_email(rank=100)
async def high_priority_email(context, state, notification):
    # Handle with high priority
    pass

# Lower priority handler (processed after higher priority)
@agent_notification.on_email(rank=200)
async def low_priority_email(context, state, notification):
    # Handle with lower priority
    pass

JavaScript

// Higher priority handler (lower rank number)
app.onAgenticEmailNotification(
  async (context, state, notification) => {
    // Handle email with high priority
  },
  100 // rank
);

// Lower priority handler
app.onAgenticEmailNotification(
  async (context, state, notification) => {
    // Handle email with lower priority
  },
  200 // rank
);

.NET

// Higher priority handler (lower rank number)
this.OnAgenticEmailNotification(
    HighPriorityEmailHandlerAsync,
    rank: 100
);

// Lower priority handler
this.OnAgenticEmailNotification(
    LowerPriorityEmailHandlerAsync,
    rank: 200
);

Gestionnaires d’authentification

Configurer des gestionnaires de connexion automatique pour les notifications nécessitant une authentification :

Python

from microsoft_agents_a365.notifications import AgentNotification
from microsoft_agents.activity import ChannelId, AgentSubChannel

# Create notification handler
agent_notification = AgentNotification(app)

# Handler with automatic authentication
@agent_notification.on_email(auto_sign_in_handlers=['agentic'])
async def authenticated_email(context, state, notification):
    # Authentication is handled automatically
    pass

JavaScript

app.onAgenticEmailNotification(
  async (context, state, notification) => {
    // Handler with automatic authentication
  },
  32767, // rank (default)
  ['agentic'] // autoSignInHandlers
);

.NET

this.OnAgenticEmailNotification(
    HandleAuthenticatedEmailAsync,
    rank: 32767,
    autoSignInHandlers: new[] { "agentic" }
);

Tester et surveiller

Tester votre assistant avec des notifications

Après avoir implémenté les gestionnaires de notifications, testez votre assistant pour vous assurer qu’il reçoit et traite correctement les différents types de notifications. Suivez le guide de test pour configurer votre environnement, puis concentrez-vous principalement sur la section Tester avec des activités de notification pour valider vos notifications à l’aide de l’authentification agentique.

Surveiller la gestion des notifications

Surveiller la gestion des notifications de votre assistant en ajoutant des fonctionnalités d’observabilité. Suivre le traitement des notifications, les temps de réponse et les taux d’erreur pour comprendre les performances de l’assistant. En savoir plus sur l’implémentation du suivi et de la surveillance