Agents benachrichtigen

Wichtig

Sie müssen Teil des Frontier-Vorschauversionsprogramms sein, um Vorabzugriff auf Microsoft Agent 365 zu erhalten. Frontier verbindet Sie direkt mit den neuesten KI-Innovationen von Microsoft. Frontier-Vorschauversionen unterliegen den bestehenden Vorschauversionsbedingungen Ihrer Kundenvereinbarungen. Da sich diese Funktionen noch in der Entwicklung befinden, können sich ihre Verfügbarkeit und Merkmale im Laufe der Zeit ändern.

Mit dem Benachrichtigungsmodul können Entwickler Agents erstellen, die auf Ereignisse und Benachrichtigungen von Microsoft 365-Anwendungen reagieren können. Mit Unterstützung von Benachrichtigungen können Agents Warnungen empfangen und verarbeiten, wenn Benutzer über E-Mails, Dokumentkommentare oder andere Szenarien für die Zusammenarbeit mit ihnen interagieren.

Benachrichtigungs-Workflow

Folgen Sie diesem Workflow, um Benachrichtigungen für Ihre KI-Agent-Anwendung zu aktivieren:

Benachrichtigungspakete installieren.
Importieren von Benachrichtigungskomponenten
- Importieren von Benachrichtigungsklassen und -handlern
- Importieren von Aktivitätstypen und Kanalbezeichnern
Registrieren von Benachrichtigungshandlern
- Verwenden von Benachrichtigungshandlermethoden zum Registrieren von Routen
- Konfigurieren von Handlern für bestimmte Benachrichtigungstypen (z. B. E-Mail, Word, Excel, PowerPoint)
Verarbeiten von Benachrichtigungen im Agentcode
- Agent empfängt Benachrichtigungen von Microsoft 365-Anwendungen
- Behandeln eingehender Benachrichtigungen und geeignetes Antworten

Benachrichtigungstypen

Das Agents 365 SDK unterstützt die folgenden Benachrichtigungstypen:

Benachrichtigungstyp	Beschreibung des Dataflows	Unterkanal-ID
E-Mail	Agent empfängt eine E-Mail, in der sie erwähnt oder adressiert werden	`email`
Word	Agent wird in einem Kommentar in einem Word-Dokument erwähnt	`word`
Excel	Agent wird in einem Kommentar in einem Excel-Dokument erwähnt	`excel`
PowerPoint	Agent wird in einem Kommentar in einem PowerPoint-Dokument erwähnt	`powerpoint`
Lebenszyklusereignisse	Agent-Lebenszyklusbenachrichtigungen (Benutzeridentität erstellt, Workload-Onboarding, Benutzer gelöscht)	NICHT ZUTREFFEND

Agent-Lebenszyklusereignisse

Agent-Lebenszyklusereignisse ermöglichen es Ihrem Agent, auf bestimmte Systemereignisse im Zusammenhang mit der agentischen Benutzeridentitätsverwaltung zu reagieren. Das SDK unterstützt derzeit drei Lebenszyklusereignisse:

Veranstaltungstyp	Ereignis-ID	Beschreibung des Dataflows
Benutzeridentität erstellt	`agenticUserIdentityCreated`	Wird ausgelöst, wenn eine Agent-Benutzeridentität erstellt wird
Workload-Onboarding aktualisiert	`agenticUserWorkloadOnboardingUpdated`	Wird ausgelöst, wenn der Onboarding-Status eines Agent-Benutzers aktualisiert wird
Benutzer gelöscht	`agenticUserDeleted`	Wird ausgelöst, wenn eine Agent-Benutzeridentität gelöscht wird

Diese Ereignisse ermöglichen es Agents, Initialisierungsaufgaben, Bereinigungsvorgänge oder Zustandsverwaltung als Reaktion auf Änderungen des Benutzerlebenszyklus auszuführen.

Hinzufügen von Benachrichtigungen zu Ihrem Agent

Führen Sie die folgenden Schritte aus, um die Benachrichtigungsverarbeitung in Ihrem vorhandenen Agent zu aktivieren:

Importieren von Benachrichtigungskomponenten

Fügen Sie diese Importe zu Ihrer Agentdatei hinzu:

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 zum Erstellen von Agent365-Anwendungen; bietet Kernfunktionen für Routingaktivitäten, verwalten des Zustands und Verarbeiten von Anforderungen
AgentNotification: Klasse zum Registrieren von Benachrichtigungshandlern mit Dekoriermethoden. Bietet on_agent_notification(), on_email(), on_word() und andere Komfortdekorierungen
AgentNotificationActivity: Wrapper mit analysierten Benachrichtigungsdaten mit typisierten Eigenschaften wie email_notification und wpx_comment_notification, die benachrichtigungsspezifische Metadaten enthalten (IDs, Details zur Unterhaltung, Dokumente)
NotificationTypes: Enumeration der unterstützten Benachrichtigungstypen (EMAIL_NOTIFICATION, WPX_COMMENT, AGENT_LIFECYCLE)
ChannelId: Wird verwendet, um Benachrichtigungskanäle anzugeben (z. B. ChannelId(channel="agents", sub_channel="*"))
Autorisierung: Autorisierungskontext für die Verarbeitung von Benachrichtigungen
TurnContext: Aktueller Unterhaltungskontext aus dem Agents SDK

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

AgentApplication: Basisklasse zum Erstellen von Agent365-Anwendungen; bietet Kernfunktionen für Routingaktivitäten, verwalten des Zustands und Verarbeiten von Anforderungen. onAgentNotification() zum Registrieren von Handlern verwenden
AgentNotificationActivity: Analysierte Benachrichtigungsaktivität mit stark typisierten Benachrichtigungsdaten. Eigenschaften wie emailNotification und wpxCommentNotification enthalten benachrichtigungsspezifische Metadaten (IDs, Unterhaltungsdetails, Dokumentreferenzen)
NotificationType: Enumeration von Benachrichtigungstypen (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
TurnContext: Kontext der aktuellen Unterhaltung drehen
TurnState: Statusverwaltung für Unterhaltungen

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

AgentApplication: Basisklasse zum Erstellen von Agent365-Anwendungen; bietet Kernfunktionen für Routingaktivitäten, verwalten des Zustands und Verarbeiten von Anforderungen. OnAgentNotification() zum Registrieren von Handlern verwenden
AgentNotificationActivity: Dient als Wrapper für eine Aktivität mit stark typisierten Benachrichtigungsdaten. Eigenschaften wie EmailNotification und WpxCommentNotification enthalten benachrichtigungsspezifische Metadaten (IDs, Unterhaltungsdetails, Dokumentreferenzen)
NotificationTypeEnum: Aufzählung der unterstützten Benachrichtigungstypen (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
ITurnContext: Schnittstelle, die den aktuellen Unterhaltungskontext darstellt
ITurnState: Schnittstelle für die Verwaltung des Unterhaltungsstatus

Registrieren von Benachrichtigungshandlern in Ihrem Agent

Hinzufügen von Benachrichtigungshandlern zur Initialisierung des Agents:

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

Implementieren bestimmter Benachrichtigungshandler

Fügen Sie Handlermethoden für jeden Benachrichtigungstyp hinzu:

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
}

Spezielle Benachrichtigungshandler

Verwenden Sie nach dem Einrichten des grundlegenden Benachrichtigungsroutings spezielle Handlermethoden für eine genauere Steuerung. Diese Methoden bieten Ihnen die folgenden Möglichkeiten:

Registrieren mehrerer Handler für denselben Benachrichtigungstyp
Festlegen der Handlerpriorität mit Rangfolge
Konfigurieren der automatischen Authentifizierung pro Handler

Anmerkung

Für die meisten Anwendungsfälle reicht das generische Handlermuster aus. Verwenden Sie diese speziellen Handler, wenn Sie erweitertes Routing oder mehrere Handler für denselben Benachrichtigungstyp benötigen.

Spezieller Handler für alle Benachrichtigungen

Registrieren Sie weitere Handler, die alle Benachrichtigungstypen verarbeiten:

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

Spezieller Handler für E-Mail-Benachrichtigungen

Registrieren Sie weitere Handler speziell für E-Mail-Benachrichtigungen:

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

Spezielle Handler für Dokumentkommentare

Registrieren sie weitere Handler für Word-, Excel- und PowerPoint-Kommentarbenachrichtigungen:

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

Spezielle Handler für Lebenszyklusereignisse

Registrieren Sie weitere Handler für Agent-Lebenszyklusereignisse wie die Erstellung von Benutzeridentitäten, das Workload-Onboarding und das Löschen von Benutzern:

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

Erweiterte Konfiguration

In diesem Abschnitt werden die erweiterten Konfigurationsoptionen für die Feinabstimmung der Benachrichtigungshandler behandelt. Mit diesen Konfigurationen können Sie die Ausführungsreihenfolge des Handlers steuern, Authentifizierungsanforderungen verwalten und die Benachrichtigungsverarbeitung für komplexe Szenarien optimieren.

Priorität und Rangfolge des Handlers

Wenn Sie mehrere spezialisierte Handler verwenden, können Sie die Prioritätsreihenfolge mithilfe von Rangwerten angeben. Niedrigere Rangwerte weisen auf eine höhere Priorität hin:

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

Authentifizierungshandler

Konfigurieren Sie automatische Anmeldehandler für Benachrichtigungen, für die eine Authentifizierung erforderlich ist:

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

Testen und überwachen

Testen Ihres Agents mit Benachrichtigungen

Testen Sie den Agent nach der Implementierung von Benachrichtigungshandlern, um sicherzustellen, dass er ordnungsgemäß empfängt und verschiedene Benachrichtigungstypen verarbeitet. Folgen Sie der Anleitung zum Testen, um Ihre Umgebung einzurichten. Konzentrieren Sie sich dann vor allem auf den Abschnitt Test mit Benachrichtigungsaktivitäten, um Ihre Benachrichtigungen mithilfe der agentischen Authentifizierung zu validieren.

Überwachen der Benachrichtigungsverarbeitung

Überwachen Sie die Benachrichtigungsbehandlung Ihres Agents, indem Sie Einblick-Funktionen hinzufügen. Verfolgen Sie die Benachrichtigungsverarbeitung, Antwortzeiten und Fehlerraten, um die Leistung des Agents zu verstehen. Weitere Informationen zur Implementierung von Ablaufverfolgung und Überwachung

Feedback

War diese Seite hilfreich?

Last updated on 2025-12-08