Varsle agenter

Ved å bruke varslingsmodulen kan du utvikle agenter som svarer på hendelser og varsler fra Microsoft 365-programmer. Ved å bruke varslingsstøtte kan agenter motta og behandle varsler når brukere samhandler med dem via e-post, dokumentkommentarer eller andre samarbeidsscenarioer.

Varslingsarbeidsflyt

Følg denne arbeidsflyten for å aktivere varsling for KI-agenten din:

Installer varlingspakker.
Importer varslingskomponenter
- Importer varslingsklasser og håndterere.
- Importer aktivitetstyper og kanalidentifikatorer.
Registrer varslingshåndterere
- Bruk varslingshåndteringsmetoder for å registrere ruter.
- Konfigurer håndterere for spesifikke varslingstyper, som e-post, Word, Excel eller PowerPoint.
Behandle varsler i agentkoden
- Agenten mottar varsler fra Microsoft 365-programmer.
- Håndter innkommende varsler og svar på riktig måte.

Varslingstyper

SDK for Agent 365 støtter nå følgende varslingstyper:

Varslingstype	Description	Underkanal-ID
E-post	Agenten mottar en e-post der agenten blir nevnt eller adressert	`email`
Word	Agenten nevnes i en kommentar i et Word-dokument	`word`
Excel	Agenten nevnes i en kommentar i et Excel-dokument	`excel`
PowerPoint	Agenten nevnes i en kommentar i et PowerPoint-dokument	`powerpoint`
Livssyklushendelser	Agentlivssyklusvarsler (brukeridentitet opprettet, arbeidsbelastningspålasting, bruker slettet)	Ikke tilgjengelig

Agentlivssyklushendelser

Agentlivssyklushendelser gjør det mulig for agenten din å svare på spesifikke systemhendelser knyttet til håndtering av agentbrukeridentitet. SDK-en støtter for øyeblikket tre livssyklushendelser:

Hendelsestype	Hendelses-ID	Description
Brukeridentitet opprettet	`agenticUserIdentityCreated`	Utløses når en agentbrukeridentitet opprettes
Pålasting av arbeidsbelastning oppdatert	`agenticUserWorkloadOnboardingUpdated`	Utløses når en agentbrukers pålastingsstatus for arbeidsbelastning oppdateres
Bruker slettet	`agenticUserDeleted`	Utløses når en agentbrukeridentitet slettes

Ved å bruke disse hendelsene kan agenter utføre initialiseringsoppgaver, oppryddingsoperasjoner eller tilstandshåndtering i forbindelse med endringer i brukerens livssyklus.

Varslingsnyttelastreferanse

Når agenten din mottar et varsel, inneholder nyttelasten strukturert data tilpasset varslingstypen. Å forstå disse nyttelastene hjelper deg å hente ut informasjonen du trenger for å behandle varslinger effektivt.

E-postvarslingsnyttelast

Når en bruker sender en e-post til agenten din eller nevner agenten din i en e-post, mottar agenten en e-postvarsling med følgende struktur:

{
  "id": "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
  "timestamp": "2026-02-06T17:45:20.740Z",
  "channelId": "agents",
  "serviceUrl": "http://localhost:56150/_connector",
  "recipient": {
    "id": "AgentName@contoso.onmicrosoft.com",
    "name": "My Agent",
    "agenticUserId": "<agentic-user-id>",
    "agenticAppId": "<agentic-app-id>",
    "tenantId": "<tenant-id>",
    "role": "agenticUser"
  },
  "conversation": {
    "id": "<conversation-id>",
    "conversationType": "personal",
    "tenantId": "<tenant-id>"
  },
  "from": {
    "id": "sender@contoso.onmicrosoft.com",
    "name": "Sender Name",
    "role": "user"
  },
  "type": "message",
  "channelData": {
    "tenant": {
      "id": "<tenant-id>"
    }
  },
  "locale": "en-US",
  "name": "emailNotification",
  "entities": [
    {
      "type": "clientInfo",
      "locale": "en-US",
      "timezone": null
    },
    {
      "id": "email",
      "type": "productInfo"
    },
    {
      "type": "emailNotification",
      "id": "<email-id>",
      "conversationId": "<conversation-id>",
      "htmlBody": "<body dir=\"ltr\">\n<div class=\"elementToProof\">Your email message content here</div>\n</body>"
    }
  ]
}

Varslingsnyttelast for dokumentkommentarer (Word, Excel, PowerPoint)

Når en bruker nevner agenten din i en kommentar i et Word-, Excel- eller PowerPoint-dokument, mottar agenten din en WPX-kommentarvarslingsnyttelast:

{
  "id": "bbbbbbbb-1111-2222-3333-cccccccccccc",
  "timestamp": "2026-02-06T17:46:02.248Z",
  "channelId": "agents",
  "serviceUrl": "http://localhost:56150/_connector",
  "recipient": {
    "id": "AgentName@contoso.onmicrosoft.com",
    "name": "My Agent",
    "agenticUserId": "<agentic-user-id>",
    "agenticAppId": "<agentic-app-id>",
    "tenantId": "<tenant-id>",
    "role": "agenticUser"
  },
  "conversation": {
    "id": "<conversation-id>",
    "conversationType": "personal",
    "tenantId": "<tenant-id>",
    "topic": "<document-topic>"
  },
  "from": {
    "id": "sender@contoso.onmicrosoft.com",
    "name": "Sender Name",
    "role": "user"
  },
  "type": "message",
  "channelData": {
    "tenant": {
      "id": "<tenant-id>"
    },
    "productContext": "Word"
  },
  "locale": "en-US",
  "textFormat": "plain",
  "text": "<at>My Agent</at> - Please review this section\n",
  "attachments": [
    {
      "contentUrl": "<document-url>",
      "name": "<document-name>",
      "content": {
        "uniqueId": "<document-unique-id>",
        "fileType": "docx"
      },
      "contentType": "application/vnd.microsoft.teams.file.download.info"
    }
  ],
  "entities": [
    {
      "type": "clientInfo",
      "locale": "en-US",
      "timezone": null
    },
    {
      "mentioned": {
        "id": "AgentName@contoso.onmicrosoft.com",
        "name": "@My Agent"
      },
      "text": "<at>My Agent</at>",
      "type": "mention"
    },
    {
      "id": "Word",
      "type": "productInfo"
    },
    {
      "parentCommentId": "<parent-comment-id>",
      "commentId": "<comment-id>",
      "documentId": "<document-id>",
      "type": "wpxcomment"
    }
  ]
}

Legg til varslinger i agenten

Følg disse trinnene for å aktivere varslingshåndtering i din eksisterende agent:

Importer varslingskomponenter

Legg til disse importene i agentfilen din:

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 for å bygge Agent365-programmer. Den gir kjernefunksjonalitet for ruting av aktiviteter, tilstandshåndtering og behandling av forespørsler.
AgentNotification: Klasse for registrering av varslingshåndterere med dekoratørmetoder. Den tilbyr on_agent_notification(), on_email(), on_word() og andre praktiske dekoratører.
AgentNotificationActivity: Wrapper som inneholder tolket varslingsdata med typede egenskaper som email_notification og wpx_comment_notification, som inneholder varslingsspesifikke metadata som ID-er, samtaledetaljer og dokumentreferanser.
NotificationTypes: Opplisting over støttede varslingstyper, som EMAIL_NOTIFICATION og WPX_COMMENT.
ChannelId: Brukes til å angi varslingskanaler, f.eks. ChannelId(channel="agents", sub_channel="*").
Autorisasjon: Autorisasjonskontekst for behandling av varslinger.
TurnContext: Nåværende kontekst for samtalerunde fra SDK for agenter.

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

AgentApplication: Basisklasse for å bygge Agent365-programmer. Den gir kjernefunksjonalitet for ruting av aktiviteter, tilstandshåndtering og behandling av forespørsler. Bruk onAgentNotification() til å registrere håndterere.
AgentNotificationActivity: Tolket varslingsaktivitet med sterkt typet varslingsdata. Egenskaper som emailNotification og wpxCommentNotification inneholder varslingsspesifikk metadata, slik som ID-er, samtaledetaljer og dokumentreferanser.
NotificationType: opplisting over varslingstyper, inkludert Unknown, WpxComment, EmailNotification, AgentLifecycleNotification.
TurnContext: Kontekst for nåværende samtaleomgang.
TurnState: Tilstandshåndtering for samtale.

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

AgentApplication: Basisklasse for å bygge Agent365-programmer. Den gir kjernefunksjonalitet for ruting av aktiviteter, tilstandshåndtering og behandling av forespørsler. Bruk OnAgentNotification-metoden for å registrere handlere.
AgentNotificationActivity: Pakker inn en aktivitet med sterkt typet varslingsdata. Egenskaper som EmailNotification og WpxCommentNotification inneholder varslingsspesifikke metadata som ID-er, samtaledetaljer og dokumentreferanser.
NotificationTypeEnum: Opplisting av støttede varslingstyper, inkludert Unknown, WpxComment, EmailNotification, AgentLifecycleNotification.
ITurnContext: Grensesnitt som representerer den nåværende samtaleomgangskonteksten.
ITurnState: Grensesnitt for håndtering av samtaletilstand.

Registrer varslingshåndterere i agenten din

Legg til varslingshåndterere i agentens oppsett:

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.')

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

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

Implementer spesifikke varslingshåndterere

Legg til metoder for håndtering av hver varslingstype:

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

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
}

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
}

Identifiser avsenderen

Hver varslingsaktivitet inkluderer Activity.From. A365-plattformen fyller denne egenskapen med avsenderens grunnleggende identitet, så du trenger ingen API-kall eller tokeninnhenting. Få tilgang til den i enhver varslingshandler:

async def handle_email_notification(self, context, state, notification):
    from_prop = context.activity.from_property
    logger.info(
        "Notification from — DisplayName: '%s', UserId: '%s', AadObjectId: '%s'",
        getattr(from_prop, "name", None) or "(unknown)",
        getattr(from_prop, "id", None) or "(unknown)",
        getattr(from_prop, "aad_object_id", None) or "(none)",
    )
    display_name = getattr(from_prop, "name", None) or "unknown"
    # Use display_name in your response or LLM prompt

Activity.from_property er en ChannelAccount-klasseforekomst som har følgende egenskaper:

Egenskap	Description
`name`	Visningsnavn
`id`	Kanalbruker-ID
`aad_object_id`	Objekt-ID for Entra

async handleEmailNotification(context, state, notification) {
  const from = context.activity?.from;
  console.log(`Notification from — DisplayName: '${from?.name ?? "(unknown)"}', UserId: '${from?.id ?? "(unknown)"}', AadObjectId: '${from?.aadObjectId ?? "(none)"}'`);
  const displayName = from?.name ?? 'unknown';
  // Use displayName in your response or LLM prompt
}

Activity.from-egenskapen er en instans av ChannelAccount-grensesnittforekomst som har følgende egenskaper:

Egenskap	Description
`name`	Visningsnavn
`id`	Kanalbruker-ID
`aadObjectId`	Objekt-ID for Entra

private async Task HandleEmailNotificationAsync(
    ITurnContext turnContext, ITurnState turnState,
    AgentNotificationActivity activity, CancellationToken cancellationToken)
{
    var from = turnContext.Activity.From;
    _logger.LogInformation(
        "Notification from — DisplayName: '{Name}', UserId: '{Id}', AadObjectId: '{AadObjectId}'",
        from?.Name ?? "(unknown)", from?.Id ?? "(unknown)", from?.AadObjectId ?? "(none)");

    var displayName = from?.Name ?? "unknown";
    // Use displayName in your response or LLM prompt
}

Activity.From-egenskapen er en ChannelAccount-klasseforekomst som har følgende egenskaper:

Egenskap	Description
From.Name	Visningsnavn
From.Id	Kanalbruker-ID
From.AadObjectId	Objekt-ID for Entra

Viktig!

Visningsnavnet er brukerstyrt tekst. Rens den (fjern kontrolltegn, begrens lengden) før du injiserer den i LLM-systemspørsmål for å forhindre instruksinjeksjonsangrep.

Tips

Bruk aadObjectId sammen med Microsoft Graph API for å hente utvidede profildata (stillingstittel, leder, avdeling) når agenten din har nødvendige tillatelser.

Spesialiserte varslingshåndterere

Når du har satt opp grunnleggende varslingsruting, bruker du spesialiserte håndteringsmetoder for mer granulær kontroll. Ved å bruke disse metodene kan du:

Registrer flere håndterere for samme varslingstype.
Sett handlerprioritet ved å bruke rangering.
Konfigurer automatisk autentisering for hvert behandlingsprogram.

Notat

For de fleste brukstilfeller er det generiske behandlingsprogrammønsteret tilstrekkelig. Bruk disse spesialiserte håndtererne når du trenger avansert ruting eller flere håndterere for samme varslingstype.

Spesialisert behandlingsprogram for alle varsler

Registrer flere behandlingsprogrammer som behandler alle varslingstyper:

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

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

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

Spesialisert behandlingsprogram for e-postvarslinger

Registrer flere behandlingsprogrammer spesielt for e-postvarslinger:

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!')

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

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

Spesialiserte behandlingsprogrammer for dokumentkommentarer

Registrer flere behandlingsprogrammer for kommentarvarsler fra Word, Excel og PowerPoint:

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

// 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...');
  }
});

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

Spesialiserte behandlingsprogrammer for livssyklushendelser

Registrer flere behandlingsprogrammer for agentlivssyklushendelser, slik som opprettelse av brukeridentitet, innføring av arbeidsområde og sletting av bruker:

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

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

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

Avansert konfigurasjon

Denne delen tar for seg avanserte konfigurasjonsalternativer for finjustering av varslingsbehandlingsprogrammer. Ved å bruke disse innstillingene kan du kontrollere handlernes kjørerekkefølge, håndtere autentiseringskrav og optimalisere varslingsbehandlingen for komplekse scenarioer.

Prioritet og rangering for handlere

Når du bruker flere spesialiserte behandlingsprogrammer, angir du prioritet ved å bruke rangverdier. Lavere rangverdier indikerer høyere prioritet:

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

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

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

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

Godkjenningsbehandlere

Konfigurer behandlingsprogrammer for automatisk pålogging for varsler som krever autentisering:

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

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

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

Eksempelkode

Se Agent 365-eksempler for fullstendige eksempler på varslingsbehandlingsprogram på tvers av alle støttede rammeverk.

Test agenten din med varsler

Etter å ha implementert varslingsbehandlingsprogrammer, tester du agenten din for å sikre at den mottar og behandler ulike varslingstyper korrekt. Følg testveiledning for å sette opp miljøet ditt, og fokuser hovedsakelig på økten Test med varslingsaktiviteter for å validere varslene dine ved hjelp av agentisk autentisering.

Overvåk håndtering av varsler

Legg til observasjonsfunksjoner for å overvåke håndtering av varsler hos agenten. Overvåk prosessering av varsler, responstider og feilrater for å forstå agentens ytelse. Les mer om implementering av sporing og overvåking.

Tilbakemeldinger

Var denne siden nyttig?

Last updated on 2026-07-29