Agenten op de hoogte stellen

Belangrijk

U moet deelnemen aan het preview-programma Frontier om vroegtijdige toegang te krijgen tot Microsoft Agent 365. Frontier verbindt u rechtstreeks met de nieuwste AI-innovaties van Microsoft. Op Frontier-previews zijn de bestaande preview-voorwaarden van uw klantovereenkomsten van toepassing. Omdat deze functies nog in ontwikkeling zijn, kunnen de beschikbaarheid en mogelijkheden hiervan na verloop van tijd veranderen.

Met de module Meldingen kunnen ontwikkelaars agenten bouwen die kunnen reageren op gebeurtenissen en meldingen van Microsoft 365-toepassingen. Met ondersteuning voor meldingen kunnen agenten waarschuwingen ontvangen en verwerken wanneer gebruikers via e-mail, documentopmerkingen of andere samenwerkingsscenario's met hen communiceren.

Werkstroom Meldingen

Volg deze werkstroom om meldingen in te schakelen voor uw AI-agenttoepassing:

1. Installeer meldingspakketten.

2. Importeer meldingsonderdelen

   • Meldingsklassen en -handlers importeren
   • Activiteitstypen en kanaal-id's importeren

3. Registreer meldingshandlers

   • Methoden voor meldingshandlers gebruiken om routes te registreren
   • Handlers configureren voor specifieke meldingstypen (bijvoorbeeld e-mail, Word, Excel, PowerPoint)

4. Verwerk meldingen in agentcode

   • Agent ontvangt meldingen van Microsoft 365-toepassingen
   • Binnenkomende meldingen verwerken en op de juiste wijze reageren

Meldingstypen

De SDK voor Agent 365 ondersteunt de volgende typen meldingen:

Berichttype	Omschrijving	Subkanaal-id
E-mail	Agent ontvangt een e-mailbericht waarin deze wordt vermeld of aangesproken	email
Word	Agent wordt vermeld in een opmerking in een Word-document	word
Excel	Agent wordt vermeld in een opmerking in een Excel-document	excel
PowerPoint	Agent wordt vermeld in een opmerking in een PowerPoint-document	powerpoint
Levenscyclusgebeurtenissen	Meldingen over de levenscyclus van agenten (gebruikersidentiteit gemaakt, onboarding van workload, gebruiker verwijderd)	N.v.t.

Levenscyclusgebeurtenissen van agenten

Gebeurtenissen in de levenscyclus van agenten stellen uw agent in staat om te reageren op specifieke systeemgebeurtenissen met betrekking tot identiteitsbeheer van agentische gebruikers. De SDK ondersteunt momenteel drie levenscyclusgebeurtenissen:

Soort evenement	Gebeurtenis-id	Omschrijving
Gebruikersidentiteit gemaakt	agenticUserIdentityCreated	Wordt geactiveerd wanneer een agentische gebruikersidentiteit wordt gemaakt
Onboarding van workload bijgewerkt	agenticUserWorkloadOnboardingUpdated	Wordt geactiveerd wanneer de onboardingstatus van de workload van een agentische gebruiker wordt bijgewerkt
Gebruiker verwijderd	agenticUserDeleted	Wordt geactiveerd wanneer een agentische gebruikersidentiteit wordt verwijderd

Met deze gebeurtenissen kunnen agenten initialisatietaken, opschoningsbewerkingen of statusbeheer uitvoeren als reactie op wijzigingen in de levenscyclus van gebruikers.

Meldingen toevoegen aan uw agent

Volg deze stappen om de verwerking van meldingen in te schakelen in uw bestaande agent:

Importeer meldingsonderdelen

Voeg deze importbewerkingen toe aan uw agentbestand:

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: basisklasse voor het bouwen van Agent 365-toepassingen; biedt kernfunctionaliteit voor routeringsactiviteiten, het beheren van de status en de verwerking van aanvragen
• AgentNotification: klasse voor het registreren van meldingshandlers met decorator-methoden. Biedt on_agent_notification(), on_email(), on_word()en andere decorators voor het gemak
• AgentNotificationActivity: wrapper met geparseerde meldingsgegevens met getypte eigenschappen, zoals email_notification en wpx_comment_notification die meldingsspecifieke metagegevens (id's, gespreksgegevens, documentverwijzingen) bevatten
• NotificationTypes: opsomming van ondersteunde meldingstypen (EMAIL_NOTIFICATION, WPX_COMMENT, AGENT_LIFECYCLE)
• ChannelId: wordt gebruikt om meldingskanalen op te geven (bijvoorbeeld ChannelId(channel="agents", sub_channel="*"))
• Authorization: autorisatiecontext voor het verwerken van meldingen
• TurnContext: de context van de huidige gesprekswisseling uit de SDK voor agenten

JavaScript

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

• AgentApplication: basisklasse voor het bouwen van Agent 365-toepassingen; biedt kernfunctionaliteit voor routeringsactiviteiten, het beheren van de status en de verwerking van aanvragen. Gebruik onAgentNotification() om handlers te registreren
• AgentNotificationActivity: activiteit van geparseerde meldingen met sterk getypeerde meldingsgegevens. Eigenschappen zoals emailNotification en wpxCommentNotification bevatten meldingsspecifieke metagegevens (id's, gespreksgegevens, documentverwijzingen)
• NotificationType: opsomming van meldingstypen (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
• TurnContext: context van huidige gesprekswisseling
• TurnState: statusbeheer voor gesprek

.NET

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

• AgentApplication: basisklasse voor het bouwen van Agent 365-toepassingen; biedt kernfunctionaliteit voor routeringsactiviteiten, het beheren van de status en de verwerking van aanvragen. Gebruik OnAgentNotification() om handlers te registreren
• AgentNotificationActivity: verpakt een activiteit met sterk getypeerde meldingsgegevens. Eigenschappen zoals EmailNotification en WpxCommentNotification bevatten meldingsspecifieke metagegevens (id's, gespreksgegevens, documentverwijzingen)
• NotificationTypeEnum: opsomming van ondersteunde meldingstypen (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
• ITurnContext: Interface waarin de context van de huidige gesprekswisseling wordt weergegeven
• ITurnState: interface voor beheer van gespreksstatus

Meldingshandlers registreren in uw agent

Voeg meldingshandlers toe aan de initialisatie van uw agent:

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;
        }
    }
}

Specifieke meldingshandlers implementeren

Voeg handlermethoden toe voor elk meldingstype:

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
}

Gespecialiseerde meldingshandlers

Nadat u de basisroutering voor meldingen hebt ingesteld, gebruikt u gespecialiseerde handlermethoden voor meer gedetailleerde controle. Deze methoden bieden u onder meer de volgende mogelijkheden:

• Meerdere handlers registreren voor hetzelfde meldingstype
• Handlerprioriteit instellen met rangschikking
• Automatische verificatie per handler configureren

Notitie

In de meeste gevallen volstaat het algemene handlerpatroon. Gebruik deze gespecialiseerde handlers wanneer u geavanceerde routering of meerdere handlers nodig hebt voor hetzelfde meldingstype.

Gespecialiseerde handler voor alle meldingen

Registreer meer handlers die alle meldingstypen verwerken:

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;
    }
}

Gespecialiseerde handler voor e-mailmeldingen

Registreer meer handlers specifiek voor e-mailmeldingen:

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
    );
}

Gespecialiseerde handlers voor documentopmerkingen

Registreer meer handlers voor meldingen voor opmerkingen in Word, Excel en 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
        );
    }
}

Gespecialiseerde handlers voor levenscyclusgebeurtenissen

Registreer meer handlers voor levenscyclusgebeurtenissen van agenten, zoals het maken van gebruikersidentiteiten, het onboarden van workloads en het verwijderen van gebruikers:

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
    );
}

Geavanceerde configuratie

In deze sectie worden geavanceerde configuratieopties beschreven voor het afstemmen van uw meldingshandlers. Met deze configuraties kunt u de uitvoeringsvolgorde van handlers bepalen, verificatievereisten beheren en de verwerking van meldingen optimaliseren voor complexe scenario's.

Prioriteit en rangschikking van handler

Wanneer u meerdere gespecialiseerde handlers gebruikt, kunt u de prioriteitsvolgorde opgeven met behulp van rangschikkingswaarden. Een lagere rangschikkingswaarde duidt op een hogere prioriteit:

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
);

Verificatiehandlers

Configureer handlers voor automatische aanmelding voor meldingen waarvoor verificatie vereist is:

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" }
);

Testen en monitoren

Uw agent testen met meldingen

Nadat u meldingshandlers hebt geïmplementeerd, test u uw agent om ervoor te zorgen dat deze op de juiste manier verschillende meldingstypen ontvangt en verwerkt. Volg de testhandleiding om uw omgeving in te stellen en richt u vervolgens voornamelijk op de sectie Testen met meldingsactiviteiten om uw meldingen te valideren met behulp van agentische verificatie.

Verwerking van meldingen bewaken

Bewaak de verwerking van meldingen door uw agent door mogelijkheden voor waarneembaarheid toe te voegen. Houd de verwerking van meldingen, reactietijden en foutpercentages bij om inzicht te krijgen in de prestaties van agenten. Meer informatie over het implementeren van tracering en bewaking