Ügynökök értesítése

Fontos

A Microsoft Agent 365-höz való korai hozzáféréshez a Frontier előzetes verziójának részeként kell lennie. A Frontier közvetlenül összekapcsolja Önt a Microsoft legújabb AI-innovációival. Gyakorlati ismereteket szerezhet az úttörő funkciókról, megoszthatja észrevételeit a termékcsapatokkal, és segíthet a mesterséges intelligencia jövőjének alakításában. A Frontier előzetesekre az ügyfélszerződések meglévő előzetes feltételei vonatkoznak. Mivel ezek a funkciók még fejlesztés alatt állnak, rendelkezésre állásuk és képességeik idővel változhatnak."

Az Értesítések modul lehetővé teszi a fejlesztők számára, hogy olyan ügynököket építsenek ki, amelyek képesek reagálni a Microsoft 365-alkalmazások eseményeire és értesítéseire. Az értesítések támogatásával az ügynökök riasztásokat kaphatnak és dolgozhatnak fel, amikor a felhasználók e-mailben, dokumentum-megjegyzésekben vagy más együttműködési forgatókönyvekben kommunikálnak velük.

Értesítések munkafolyamata

Kövesse ezt a munkafolyamatot az AI-ügynökalkalmazás értesítéseinek engedélyezéséhez:

1. Telepítse az értesítési csomagokat.

2. Értesítési összetevők importálása

   • Értesítési osztályok és kezelők importálása
   • Tevékenységtípusok és csatornaazonosítók importálása

3. Értesítéskezelők regisztrálása

   • Útvonalak regisztrálása értesítéskezelő metódusokkal
   • Kezelők konfigurálása adott értesítéstípusokhoz (például e-mail, Word, Excel, PowerPoint)

4. Értesítések feldolgozása ügynökkódban

   • Az ügynök értesítéseket kap a Microsoft 365-alkalmazásoktól
   • Bejövő értesítések kezelése és megfelelő válaszadás

Értesítéstípusok

Az Agents 365 SDK a következő értesítési típusokat támogatja:

Értesítés típusa	Description	Sub-Channel azonosító
E-mail	Az ügynök kap egy e-mailt, amelyben megemlítik vagy címezve vannak	email
Szó	Az ügynök egy Word-dokumentumban lévő megjegyzésben szerepel	word
Excel	Az ügynök szerepel egy Megjegyzésben egy Excel-dokumentumban	excel
PowerPoint	Az ügynök szerepel egy Megjegyzésben egy PowerPoint-dokumentumban	powerpoint
Életciklus-események	Ügynökéletciklus-értesítések (felhasználói identitás létrehozása, számítási feladatok előkészítése, felhasználó által törölt)	N/A

Ügynök életciklus-eseményei

Az ügynök életciklus-eseményei lehetővé teszik, hogy az ügynök reagáljon a felhasználói identitás kezeléshez kapcsolódó konkrét rendszereseményekre. Az SDK jelenleg három életciklus eseményt támogat:

Esemény típusa	Eseményazonosító	Description
Létrehozott felhasználói identitás	agenticUserIdentityCreated	Ügynöki felhasználói identitás létrehozásakor aktiválódik
A számítási feladatok előkészítése frissítve	agenticUserWorkloadOnboardingUpdated	Az ügynöki felhasználó számítási feladatainak előkészítési állapotának frissítésekor aktiválódik
Felhasználó törölve	agenticUserDeleted	Ügynöki felhasználói identitás törlésekor aktiválódik

Ezek az események lehetővé teszik az ügynökök számára, hogy inicializálási feladatokat, törlési műveleteket vagy állapotkezelést hajtsanak végre a felhasználói életciklus változásaira válaszul.

Értesítések hozzáadása az ügynökhöz

A meglévő ügynök értesítéskezelésének engedélyezéséhez kövesse az alábbi lépéseket:

Értesítési összetevők importálása

Adja hozzá ezeket az importálásokat az ügynökfájlhoz:

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: Alaposztály Ügynök365-alkalmazások létrehozásához; alapvető funkciókat biztosít az útválasztási tevékenységekhez, az állapotkezeléshez és a kérelmek feldolgozásához
• AgentNotification: Az értesítéskezelők dekorálási metódusokkal történő regisztrálásának osztálya. Biztosít on_agent_notification(), on_email(), on_word() és egyéb kényelmi dekorátorok
• AgentNotificationActivity: A beírt tulajdonságokkal email_notificationwpx_comment_notification rendelkező és értesítésspecifikus metaadatokat (azonosítókat, beszélgetés részleteit, dokumentumhivatkozásokat) tartalmazó, elemzéssel ellátott értesítési adatokat tartalmazó burkoló
• NotificationTypes: Támogatott értesítéstípusok száma (EMAIL_NOTIFICATION, WPX_COMMENT, AGENT_LIFECYCLE)
• ChannelId: Értesítési csatornák megadására szolgál (pl. ChannelId(channel="agents", sub_channel="*"))
• Engedélyezés: Engedélyezési környezet az értesítések feldolgozásához
• TurnContext: Az aktuális beszélgetés kontextusa az Ügynökök SDK-ból

JavaScript

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

• AgentApplication: Alaposztály Ügynök365-alkalmazások létrehozásához; alapvető funkciókat biztosít az útválasztási tevékenységekhez, az állapotkezeléshez és a kérések feldolgozásához. Használja a onAgentNotification() a kezelők regisztrálásához.
• AgentNotificationActivity: Értesítési tevékenység elemzése erősen típusos értesítési adatokkal. A tulajdonságok, mint például emailNotification és wpxCommentNotification, értesítésspecifikus metaadatokat tartalmaznak (azonosítók, beszélgetés részletei, dokumentumhivatkozások)
• NotificationType: Értesítéstípusok számának (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
• TurnContext: Aktuális beszélgetési környezet
• TurnState: Állapotkezelés beszélgetéshez

.NET

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

• AgentApplication: Alaposztály Ügynök365-alkalmazások létrehozásához; alapvető funkciókat biztosít az útválasztási tevékenységekhez, az állapotkezeléshez és a kérések feldolgozásához. Használja a OnAgentNotification() kezelők regisztrálásához
• AgentNotificationActivity: Egy tevékenységet erősen beírt értesítési adatokkal burkol. Az olyan tulajdonságok, mint EmailNotification és WpxCommentNotification, értesítésspecifikus metaadatokat tartalmaznak (azonosítók, beszélgetés részletei, dokumentumhivatkozások).
• NotificationTypeEnum: Támogatott értesítéstípusok számbavétele (Unknown, WpxComment, EmailNotification, AgentLifecycleNotification)
• ITurnContext: Az aktuális beszélgetési környezetet képviselő interfész
• ITurnState: A beszélgetés állapotkezelésének felülete

Értesítéskezelők regisztrálása az ügynöködben

Értesítéskezelők hozzáadása az ügynök inicializálásához:

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

Konkrét értesítéskezelők implementálása

Adjon hozzá kezelő metódusokat az egyes értesítési típusokhoz.

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
}

Speciális értesítéskezelők

Az alapvető értesítési útválasztás beállítása után speciális kezelőmetszeteket használjon a részletesebb vezérléshez. Ezek a módszerek lehetővé teszik a következők használatát:

• Több kezelő regisztrálása ugyanahhoz az értesítéstípushoz
• Kezelő prioritásának beállítása rangsorolással
• Automatikus hitelesítés konfigurálása kezelőnként

Megjegyzés:

A legtöbb használati esetben elegendő az általános kezelőminta. Ezeket a speciális kezelőket akkor használja, ha speciális útválasztásra vagy ugyanazon értesítéstípushoz több kezelőre van szüksége.

Speciális kezelő az összes értesítéshez

Regisztráljon további kezelőket, amelyek az összes értesítéstípust feldolgozzák:

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

Speciális kezelő e-mail-értesítésekhez

További kezelők regisztrálása kifejezetten az e-mail-értesítésekhez:

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

Speciális kezelők a dokumentum megjegyzéseihez

További kezelők regisztrálása Word-, Excel- és PowerPoint-megjegyzésértesítésekhez:

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

Speciális kezelők életciklus-eseményekhez

Regisztráljon további kezelőket az ügynök életciklus-eseményeihez, például a felhasználói identitás létrehozásához, a számítási feladatok előkészítéséhez és a felhasználók törléséhez:

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

Speciális konfiguráció

Ez a szakasz az értesítéskezelők finomhangolásának speciális konfigurációs lehetőségeit ismerteti. Ezek a konfigurációk lehetővé teszik a kezelő végrehajtási sorrendjének szabályozását, a hitelesítési követelmények kezelését és az értesítések feldolgozásának optimalizálását összetett forgatókönyvekhez.

Kezelő prioritása és rangsorolás

Több specializált kezelő használata esetén rangsorértékekkel adhatja meg a prioritási sorrendet. Az alacsonyabb rangértékek magasabb prioritást jeleznek:

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

Hitelesítési kezelők

Automatikus bejelentkezési kezelők konfigurálása hitelesítést igénylő értesítésekhez:

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

Tesztelés és monitorozás

Az ügynök tesztelése értesítések használatával

Az értesítéskezelők implementálása után tesztelje az ügynököt, hogy megfelelően fogadja és feldolgozza a különböző értesítési típusokat. Kövesse a tesztelési útmutatót a környezet beállításához, majd elsősorban a Tesztelés értesítési tevékenységekkel szakaszra összpontosítva ellenőrizze az értesítéseket ügynöki hitelesítéssel.

Értesítéskezelés figyelése

Megfigyelheti az ügynök értesítési kezelését a megfigyelhetőségi képességek hozzáadásával. Nyomon követheti az értesítések feldolgozását, a válaszidőt és a hibaarányokat az ügynök teljesítményének megértéséhez. További információ a nyomkövetés és a monitorozás implementálásáról