Erstellen einer Agent-Konfigurationsumgebung in Teams

Mit einer Agent-Konfigurationsoberfläche können Benutzer die Einstellungen ihrer Agents direkt innerhalb des Kanal- oder Gruppenchatbereichs nach der Installation einrichten und neu konfigurieren. Dies erhöht die betriebsbezogene Effizienz des Agents von Anfang an. Bei der Agent-Konfiguration sind keine wiederholten Benutzereingriffe erforderlich, die zuvor die rechtzeitigen Vorteile von Apps beeinträchtigt haben und sich auf die Benutzerfreundlichkeit auswirken.

Mit der Agentkonfigurationserfahrung können Sie die fortlaufende Relevanz und den Wert des Agents sicherstellen, da Benutzer:

• Passen Sie den Agent während der Installation an seine spezifischen Workflows und Präferenzen an.
• Konfigurieren Sie die Einstellungen neu, um sie nach der Installation an sich ändernde Anforderungen anzupassen.

Beispielsweise kann ein Agent, der Nachrichtenthemen nachverfolgt und teilt oder GitHub-Repositorys überwacht, anfänglich so eingerichtet werden, dass er mit Benutzerworkflows übereinstimmt. Später kann sie ganz einfach neu konfiguriert werden, um direkt aus dem Gruppenchat auf neue Themen oder Repositorys zu reagieren und die Inhaltsverwaltung und Interaktion zu optimieren, ohne die Teams-Umgebung zu verlassen. Diese flexible Konfigurationserfahrung verbessert die Benutzerfreundlichkeit und Produktivität erheblich, indem Agents nahtlos in den täglichen Betrieb integriert werden.

Hier sehen Sie ein Beispiel, in dem ein Benutzer den Agent zu einem Gruppenchat hinzufügt und dann so konfiguriert, dass er seinen spezifischen Anforderungen entspricht. Der Benutzer konfiguriert dann den Agent neu, um die status zu ändern.

Konfigurieren

Konfigurieren

Informationen zum Konfigurieren des Agents als Standardzielfunktion für eine App, die Bot- und Registerkartenfunktionen unterstützt, finden Sie unter Konfigurieren der Standardzielfunktion.

Benutzeroberfläche für die Konfiguration des Build-Agents

Wenn Sie die Agent-Konfigurationsoberfläche erstellen, müssen Sie sicherstellen, dass der Benutzer in der Lage sein muss, einen Agent bei der ersten Installation zu konfigurieren und ihn jederzeit neu zu konfigurieren.

Führen Sie die folgenden Schritte aus, um die Agent-Konfiguration zu erstellen:

1. Aktualisieren des App-Manifests

2. Konfigurieren Ihres Bots

Aktualisieren des App-Manifests

Aktualisieren Sie in der App-Manifestdatei (früher Teams-App-Manifest genannt) die fetchTask -Eigenschaft unter dem bots.configuration -Objekt wie folgt:

"bots": [
    {
      "botId": "${{AAD_APP_CLIENT_ID}}",
     "needsChannelSelector": false,
      "scopes": [
        "personal",
        "team",
        "groupChat"
      ],
      "configuration":{
        "groupChat":{
          "fetchTask": true
        },
        "team":{
          "fetchTask": true
        }
      },
      "isNotificationOnly": false
    }
  ],

Weitere Informationen finden Sie unter App-Manifestschema.

Konfigurieren Ihres Agents

Wenn ein Benutzer den Agent im Kanal- oder Gruppenchat installiert, initiiert die fetchTask -Eigenschaft in der App-Manifestdatei entweder config.fetch oder config.submit.

Wenn Sie die fetchTask -Eigenschaft im App-Manifest auf Folgendes festlegen:

• false: Der Agent ruft keinen Dialog oder eine adaptive Karte ab. Stattdessen muss der Agent ein statisches Dialogfeld oder Karte bereitstellen, das beim Aufrufen des Agents verwendet wird. Weitere Informationen finden Sie unter Dialoge.

• true: Der Agent initiiert entweder config.fetch oder config.submit wie definiert. Wenn der Agent aufgerufen wird, können Sie eine adaptive Karte oder ein Dialogfeld zurückgeben, abhängig vom Kontext, der in channelData und userdata bereitgestellt wird.

In der folgenden Tabelle ist der Antworttyp aufgeführt, der den Aufrufanforderungen zugeordnet ist:

• type: "continue": type: "continue" wird verwendet, um eine Fortsetzung eines Dialogfelds oder einer adaptiven Karte innerhalb einer Agent-Konfiguration zu definieren. Wenn der Typ auf continuefestgelegt ist, gibt dies an, dass der Agent eine weitere Interaktion vom Benutzer erwartet, um mit dem Konfigurationsprozess fortzufahren.

  Wenn der Benutzer die Konfiguration übermittelt, wird der config.submit Aufruf ausgelöst. Es liest die Eingabe des Benutzers und gibt eine andere adaptive Karte zurück. Sie können auch die Agent-Konfiguration aktualisieren, um ein Dialogfeld zurückzugeben.

app.OnConfigFetch(async (context) =>
{
 var card = new AdaptiveCard
 {
     Body = new List<CardElement>
     {
         new TextBlock("Configure your agent")
         {
             Weight = TextWeight.Bolder
         }
     },
     Actions = new List<Action>
     {
         new SubmitAction
         {
             Title = "Submit"
         }
     }
 };
 var taskInfo = new TaskInfo
 {
     Title = "test card",
     Width = new Union<int, Size>(600),
     Height = new Union<int, Size>(500),
     Card = new Attachment
     {
         ContentType = new ContentType("application/vnd.microsoft.card.adaptive"),
         Content = card
     }
 };
 return new ConfigTaskResponse(
     new ContinueTask(taskInfo)
 );
});

app.on('config.fetch', async ({ activity }) => {
const card = new AdaptiveCard(
 {
   type: 'TextBlock',
   text: 'Configure your agent',
   weight: 'Bolder',
 }
).withActions(
 new SubmitAction().withTitle('Submit')
);
return {
 config: {
   type: 'continue',
   value: {
     card: cardAttachment('adaptive', card),
     height: 500,
     width: 600,
     title: 'test card',
   },
 },
};
});

@app.on_config_open
async def handle_config_open(
 ctx: ActivityContext[ConfigFetchInvokeActivity]
) -> ConfigInvokeResponse:
 card = AdaptiveCard(
     body=[
         TextBlock(text="Configure your agent", weight="Bolder")
     ],
     actions=[
         SubmitAction(title="Submit")
     ]
 )

 return ConfigResponse(
     config=TaskModuleContinueResponse(
         value=CardTaskModuleTaskInfo(
             card=card_attachment(AdaptiveCardAttachment(content=card)),
             height=500,
             width=600,
             title="test card",
         )
     )
 )

• type: "auth": Sie können den Benutzer auch auffordern, sich als Antwort auf die Anforderung zu config.fetch authentifizieren. Die type: "auth" Konfiguration fordert den Benutzer auf, sich über eine angegebene URL anzumelden, die mit einer gültigen Authentifizierungsseite verknüpft sein muss, die in einem Browser geöffnet werden kann. Die Authentifizierung ist für Szenarien unerlässlich, in denen der Agent die Authentifizierung des Benutzers erfordert. Es stellt sicher, dass die Identität des Benutzers überprüft wird, und die Sicherheit und personalisierte Erfahrungen innerhalb der Funktionalität des Agents aufrechterhalten werden.

  Hinweis

  Nur type: "auth" für Drittanbieter wird die Authentifizierung unterstützt. Einmaliges Anmelden (Single Sign-On, SSO) wird nicht unterstützt. Weitere Informationen zur Authentifizierung von Drittanbietern finden Sie unter Hinzufügen der Authentifizierung.

app.OnConfigFetch(async (context) =>
{
 return new ConfigAuthResponse(
     new ConfigAuth
     {
         SuggestedActions = new SuggestedActions
         {
             Actions = new List<CardAction>
             {
                 new CardAction
                 {
                     Type = "openUrl",
                     Value = "https://example.com/auth",
                     Title = "Sign in to this app"
                 }
             }
         }
     }
 );
});

app.on('config.fetch', async ({ activity }) => {
return {
 config: {
   type: 'auth',
   suggestedActions: {
     actions: [
       {
         type: 'openUrl',
         value: 'https://example.com/auth',
         title: 'Sign in to this app',
       },
     ],
   },
 },
};
});

@app.on_config_open
async def handle_config_open(
 ctx: ActivityContext[ConfigFetchInvokeActivity]
) -> ConfigInvokeResponse:
 return ConfigResponse(
     config=ConfigAuth(
         suggested_actions=SuggestedActions(
             to=[],
             actions=[
                 CardAction(
                     type="openUrl",
                     value="https://example.com/auth",
                     title="Sign in to this app",
                 )
             ],
         )
     )
 )

• type="message": Wenn der Typ auf message festgelegt ist, gibt dies an, dass der Agent eine einfache Nachricht zurück an den Benutzer sendet, die das Ende der Interaktion angibt oder Informationen bereitstellt, ohne dass weitere Eingaben erforderlich sind.

app.OnConfigSubmit(async (context) =>
{
 return new ConfigTaskResponse(
     new MessageTask("You have chosen to finish setting up agent")
 );
});

app.on('config.submit', async ({ activity, send }) => {
return {
 config: {
   type: 'message',
   value: 'You have chosen to finish setting up agent',
 },
};
});

@app.on_config_submit
async def handle_config_submit(
 ctx: ActivityContext[ConfigSubmitInvokeActivity]
) -> ConfigInvokeResponse:
 return ConfigResponse(
     config=TaskModuleMessageResponse(
         value="You have chosen to finish setting up agent",
     )
 )

Wenn ein Benutzer den Agent neu konfiguriert, wird die fetchTask -Eigenschaft in der App-Manifestdatei in der Agent-Logik initiiert config.fetch . Der Benutzer kann die Agent-Einstellungen nach der Installation auf zwei Arten neu konfigurieren:

• @mention der Agent im Nachrichtenerstellungsbereich. Wählen Sie die Option Einstellungen aus, die über dem Bereich zum Verfassen von Nachrichten angezeigt wird. Ein Dialogfeld wird angezeigt, aktualisiert oder ändert die Konfigurationseinstellungen des Agents im Dialogfeld.

  

• Zeigen Sie mit dem Mauszeiger auf den Agent, und das Agentprofil wird Karte angezeigt. Um die Konfigurationseinstellungen des Agents zu aktualisieren oder zu ändern, wählen Sie das Einstellungssymbol im Agentprofil Karte aus.

  

Bewährte Methoden

• Wenn Sie eine individuelle Konfiguration ihres Agents auf Kanalebene wünschen, stellen Sie sicher, dass Sie die Konfiguration gemäß dem Kanal nachverfolgen. Konfigurationsdaten werden nicht gespeichert, und die Aufrufnutzlast enthält die ausreichenden channelData-Daten.

• Stellen Sie ein klares und benutzerfreundliches Dialogfeld bereit, in dem der Benutzer aufgefordert wird, die erforderlichen Informationen einzugeben, damit der Agent ordnungsgemäß funktioniert, z. B. eine URL, einen Bereichspfad oder einen Dashboard Link.

• Vermeiden Sie das Senden mehrerer Benachrichtigungen oder Konfigurationsanforderungen nach der Installation, da dies die Benutzer verwirren kann.

Codebeispiel

Siehe auch

• Erstellen von Agents für Teams
• Adaptive Karten