Powiadamianie agentów

Ważne

Aby uzyskać wczesny dostęp do programu Microsoft Agent 365, musisz być częścią programu Frontier w wersji zapoznawczej. Usługa Frontier łączy Cię bezpośrednio z najnowszymi innowacjami firmy Microsoft dotyczącymi sztucznej inteligencji. Wersje zapoznawcze platformy Frontier podlegają istniejącym warunkom obowiązywania wersji zapoznawczej umów klienta. Ponieważ te funkcje są nadal opracowywane, ich dostępność i możliwości mogą ulec zmianie w miarę upływu czasu.

Moduł Notifications umożliwia deweloperom tworzenie agentów, którzy mogą reagować na zdarzenia i powiadomienia z aplikacji platformy Microsoft 365. Dzięki obsłudze powiadomień agenci mogą odbierać i przetwarzać alerty, gdy użytkownicy wchodzą z nimi w interakcje za pośrednictwem poczty e-mail, komentarzy do dokumentów lub innych scenariuszy współpracy.

Przepływ pracy powiadomień

Postępuj zgodnie z tym przepływem pracy, aby włączyć powiadomienia dla aplikacji agenta sztucznej inteligencji:

Zainstaluj pakiety powiadomień.
Importowanie składników powiadomień
- Importowanie klas powiadomień i procedur obsługi
- Importowanie typów działań i identyfikatorów kanałów
Rejestrowanie procedur obsługi powiadomień
- Rejestrowanie tras przy użyciu metod obsługi powiadomień
- Konfigurowanie procedur obsługi dla określonych typów powiadomień (na przykład: poczta e-mail, Word, Excel, PowerPoint)
Przetwarzanie powiadomień w kodzie agenta
- Agent odbiera powiadomienia z aplikacji platformy Microsoft 365
- Obsługa powiadomień przychodzących i odpowiednie reagowanie

Typy powiadomień

Aplikacja obsługuje następujące typy powiadomień.

Typ powiadomienia	Podpis	Identyfikator kanału podrzędnego
E-mail	Agent otrzymuje wiadomość e-mail, w której są wymienione lub adresowane	`email`
Słowo	Agent jest wymieniony w komentarzu w dokumencie programu Word	`word`
Excel	Agent jest wymieniony w komentarzu w dokumencie programu Excel	`excel`
PowerPoint	Agent jest wymieniony w komentarzu w dokumencie programu PowerPoint	`powerpoint`
Zdarzenia cyklu życia	Powiadomienia dotyczące cyklu życia agenta (tożsamość użytkownika utworzona, dołączanie obciążenia, usuwanie użytkownika)	Brak

Zdarzenia cyklu życia agenta

Zdarzenia cyklu życia agenta umożliwiają agentowi reagowanie na określone zdarzenia systemowe związane z zarządzaniem tożsamościami użytkowników agenta. Zestaw SDK obsługuje obecnie trzy zdarzenia cyklu życia:

Typ wydarzenia	Identyfikator zdarzenia	Podpis
Utworzono tożsamość użytkownika	`agenticUserIdentityCreated`	Wyzwalane po utworzeniu tożsamości użytkownika agenta
Zaktualizowano dołączanie obciążenia	`agenticUserWorkloadOnboardingUpdated`	Wyzwalane po zaktualizowaniu stanu dołączania obciążenia użytkownika agenta
Usunięto użytkownika	`agenticUserDeleted`	Wyzwalane po usunięciu tożsamości użytkownika agenta

Te zdarzenia umożliwiają agentom wykonywanie zadań inicjowania, operacje oczyszczania lub zarządzanie stanem w odpowiedzi na zmiany cyklu życia użytkownika.

Dodawanie powiadomień do agenta

Wykonaj następujące kroki, aby włączyć obsługę powiadomień w istniejącym agencie:

Importowanie składników powiadomień

Dodaj te importy do pliku agenta:

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: klasa podstawowa do kompilowania aplikacji Agent365; zapewnia podstawowe funkcje routingu działań, zarządzania stanem i przetwarzania żądań
AgentNotification: Klasa do rejestrowania programów obsługi powiadomień za pomocą metod dekoratora. Zapewnia on_agent_notification(), , on_word()on_email()i inne dekoratory dla wygody
AgentNotificationActivity: Otoka zawierająca przeanalizowane dane powiadomień z typowymi właściwościami, takimi jak email_notification i wpx_comment_notification zawierające metadane specyficzne dla powiadomień (identyfikatory, szczegóły konwersacji, odwołania do dokumentów)
NotificationTypes: wyliczenie obsługiwanych typów powiadomień (EMAIL_NOTIFICATION, WPX_COMMENT, AGENT_LIFECYCLE)
ChannelId: służy do określania kanałów powiadomień (np. ChannelId(channel="agents", sub_channel="*"))
Autoryzacja: kontekst autoryzacji na potrzeby przetwarzania powiadomień
TurnContext: Kontekst bieżącej konwersacji z zestawu SDK agentów

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

AgentApplication: klasa podstawowa do tworzenia aplikacji Agent365; zapewnia podstawowe funkcje routingu działań, zarządzania stanem i przetwarzania żądań. Używanie onAgentNotification() do rejestrowania programów obsługi
AgentNotificationActivity: przeanalizowane działanie powiadomień z silnie typinymi danymi powiadomień. Właściwości takie jak emailNotification i wpxCommentNotification zawierają metadane specyficzne dla powiadomień (identyfikatory, szczegóły konwersacji, odwołania do dokumentów)
NotificationType: wyliczenie typów powiadomień (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
TurnContext: Kontekst kolei bieżącej konwersacji
TurnState: zarządzanie stanem konwersacji

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

AgentApplication: klasa podstawowa do tworzenia aplikacji Agent365; zapewnia podstawowe funkcje routingu działań, zarządzania stanem i przetwarzania żądań. Używanie OnAgentNotification() do rejestrowania programów obsługi
AgentNotificationActivity: opakowuje działanie z silnie typinymi danymi powiadomień. Właściwości takie jak EmailNotification i WpxCommentNotification zawierają metadane specyficzne dla powiadomień (identyfikatory, szczegóły konwersacji, odwołania do dokumentów)
NotificationTypeEnum: Wyliczenie obsługiwanych typów powiadomień (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
ITurnContext: interfejs reprezentujący kontekst obrotu bieżącej konwersacji
ITurnState: interfejs do zarządzania stanem konwersacji

Rejestrowanie procedur obsługi powiadomień w agencie

Dodaj programy obsługi powiadomień do inicjowania agenta:

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

Implementowanie określonych procedur obsługi powiadomień

Dodaj metody obsługi dla każdego typu powiadomienia:

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
}

Wyspecjalizowane programy obsługi powiadomień

Po skonfigurowaniu podstawowego routingu powiadomień użyj wyspecjalizowanych metod obsługi w celu uzyskania bardziej szczegółowej kontroli. Te metody umożliwiają:

Rejestrowanie wielu procedur obsługi dla tego samego typu powiadomienia
Ustawianie priorytetu programu obsługi z klasyfikacją
Konfigurowanie automatycznego uwierzytelniania na procedurę obsługi

Notatka

W większości przypadków użycia wzorzec obsługi ogólnej jest wystarczający. Użyj tych wyspecjalizowanych procedur obsługi, jeśli potrzebujesz zaawansowanego routingu lub wielu procedur obsługi dla tego samego typu powiadomień.

Wyspecjalizowana procedura obsługi dla wszystkich powiadomień

Zarejestruj więcej procedur obsługi, które przetwarzają wszystkie typy powiadomień:

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

Wyspecjalizowana procedura obsługi powiadomień e-mail

Zarejestruj więcej procedur obsługi specjalnie na potrzeby powiadomień e-mail:

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

Wyspecjalizowane programy obsługi komentarzy do dokumentów

Zarejestruj więcej procedur obsługi powiadomień o komentarzach programów Word, Excel i 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
        );
    }
}

Wyspecjalizowane programy obsługi dla zdarzeń cyklu życia

Zarejestruj więcej procedur obsługi zdarzeń cyklu życia agenta, takich jak tworzenie tożsamości użytkownika, dołączanie obciążenia i usuwanie użytkowników:

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

Konfiguracja zaawansowana

W tej sekcji opisano zaawansowane opcje konfiguracji dostrajania procedur obsługi powiadomień. Te konfiguracje umożliwiają kontrolowanie kolejności wykonywania programu obsługi, zarządzanie wymaganiami uwierzytelniania i optymalizowanie przetwarzania powiadomień w złożonych scenariuszach.

Priorytet i klasyfikacja programu obsługi

W przypadku korzystania z wielu wyspecjalizowanych procedur obsługi można określić kolejność priorytetu przy użyciu wartości rangi. Niższe wartości wskazują wyższy priorytet.

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

Programy obsługi uwierzytelniania

Skonfiguruj programy obsługi automatycznego logowania dla powiadomień wymagających uwierzytelniania:

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

Testowanie i monitorowanie

Testowanie agenta przy użyciu powiadomień

Po zaimplementowaniu procedur obsługi powiadomień przetestuj agenta, aby upewnić się, że prawidłowo odbiera i przetwarza różne typy powiadomień. Postępuj zgodnie z przewodnikiem testowania, aby skonfigurować środowisko, a następnie skoncentruj się przede wszystkim na sekcji Testowanie przy użyciu działań powiadomień, aby zweryfikować powiadomienia przy użyciu uwierzytelniania agenta.

Monitorowanie obsługi powiadomień

Monitoruj obsługę powiadomień agenta, dodając możliwości wglądu. Śledzenie przetwarzania powiadomień, czasów odpowiedzi i współczynników błędów w celu zrozumienia wydajności agenta. Dowiedz się więcej o implementowaniu śledzenia i monitorowania

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-12-02