Implementera en färdighet

GÄLLER FÖR: SDK v4

Du kan använda kunskaper för att utöka en annan robot. En färdighet är en robot som kan utföra en uppsättning uppgifter för en annan robot.

• Ett manifest beskriver en färdighets gränssnitt. Utvecklare som inte har åtkomst till kompetensens källkod kan använda informationen i manifestet för att utforma sin kompetenskonsument.
• En färdighet kan använda anspråksverifiering för att hantera vilka robotar eller användare som kan komma åt den.

Den här artikeln visar hur du implementerar en färdighet som repeterar användarens indata.

Vissa typer av kunskapskonsumenter kan inte använda vissa typer av kunskapsrobotar. I följande tabell beskrivs vilka kombinationer som stöds.

	Kompetens för flera klientorganisationer	Kompetens för enskild klientorganisation	Användartilldelad kompetens för hanterad identitet
Konsument för flera hyresgäster	Stöds	Stöds inte	Stöds inte
Enskild hyresgäst	Stöds inte	Stöds om båda apparna tillhör samma klientorganisation	Stöds om båda apparna tillhör samma klientorganisation
Hanterad användartilldelad identitet för konsument	Stöds inte	Stöds om båda apparna tillhör samma klientorganisation	Stöds om båda apparna tillhör samma klientorganisation

Kommentar

Bot Framework JavaScript-, C#- och Python-SDK:erna fortsätter att stödjas, men Java SDK dras tillbaka med slutligt långsiktigt stöd som slutar i november 2023.

Befintliga robotar som skapats med Java SDK fortsätter att fungera.

Om du vill skapa en ny robot kan du använda Microsoft Copilot Studio och läsa om hur du väljer rätt copilot-lösning.

Mer information finns i Framtiden för robotbygge.

Förutsättningar

• Kunskaper om grunderna och färdigheterna i robotar.
• En Azure-prenumeration (för att distribuera dina kunskaper). Om du inte har ett konto kan du skapa ett kostnadsfritt konto innan du börjar.
• En kopia av färdigheters enkel bot-till-bot-exempel i C#, JavaScript, Java, eller Python.

Kommentar

Från och med version 4.11 behöver du inget app-ID och lösenord för att testa en färdighet lokalt i Bot Framework-emulatorn. En Azure-prenumeration krävs fortfarande för att distribuera dina kunskaper till Azure.

Om det här exemplet

Det enkla exemplet för robot-till-robot innehåller projekt för två robotar:

• Den echo-färdighetsbot som implementerar färdigheten.
• Den enkla rotroboten, som utnyttjar en rotrobot som använder färdigheten.

Den här artikeln fokuserar på kunskapen, som innehåller supportlogik i roboten och adaptern.

C#

JavaScript

Java

Python

Information om den enkla rotroboten finns i Implementera en kunskapskonsument.

Resurser

För distribuerade robotar kräver robot-till-robot-autentisering att varje deltagande robot har giltig identitetsinformation. Du kan dock testa multitenante färdigheter och färdighetskonsumenter lokalt med emulatorn utan ett app-ID och lösenord.

Om du vill göra kunskapen tillgänglig för användarriktade robotar registrerar du kunskapen med Azure. Mer information finns i registrera en robot med Azure AI Bot Service.

Tillämpningskonfiguration

Du kan också lägga till kunskapens identitetsinformation i konfigurationsfilen. Om antingen färdigheten eller färdighetsanvändaren tillhandahåller identitetsinformation, måste båda göra det.

Den tillåtna uppringarens matris kan begränsa vilka kompetenskonsumenter som kan komma åt färdigheten. Om du vill acceptera anrop från alla kunskapskonsumenter lägger du till ett "*"-element.

Kommentar

Om du testar din färdighet lokalt utan botidentitetsinformation, kör varken färdigheten eller färdighetskonsumenten koden för att utföra anspråksverifiering.

C#

EchoSkillBot\appsettings.json

Du kan också lägga till kunskapens identitetsinformation i filen appsettings.json.

{
  "MicrosoftAppType": "",
  "MicrosoftAppId": "",
  "MicrosoftAppPassword": "",
  "MicrosoftAppTenantId": "",

  // This is a comma separate list with the App IDs that will have access to the skill.
  // This setting is used in AllowedCallersClaimsValidator.
  // Examples: 
  //    [ "*" ] allows all callers.
  //    [ "AppId1", "AppId2" ] only allows access to parent bots with "AppId1" and "AppId2".
  "AllowedCallers": [ "*" ]
}

JavaScript

echo-skill-bot/.env

Du kan också lägga till kunskapens identitetsinformation i .env-filen.

MicrosoftAppType=
MicrosoftAppId=
MicrosoftAppPassword=
MicrosoftAppTenantId=
AllowedCallers=*

Java

DialogSkillBot\resources\application.properties

Du kan också lägga till färdighetens app-ID och lösenord i filen application.properties.

Varning

Det verkar som om exemplet du letar efter har flyttats! Var säker på att vi arbetar med att lösa detta.

Python

Du kan också lägga till färdighetens app-ID och lösenord i filen config.py.

config.py

APP_ID = os.environ.get("MicrosoftAppId", "")
APP_PASSWORD = os.environ.get("MicrosoftAppPassword", "")
APP_TYPE = os.environ.get("MicrosoftAppType", "MultiTenant")
APP_TENANTID = os.environ.get("MicrosoftAppTenantId", "")

# Callers to only those specified, '*' allows any caller.

Logik för aktivitetshanterare

Så här accepterar du indataparametrar

Färdighetskonsumenten kan skicka information till färdigheten. Ett sätt att acceptera sådan information är att acceptera dem via värdeegenskapen för inkommande meddelanden. Ett annat sätt är att hantera händelser och anropa aktiviteter.

Färdigheten i det här exemplet accepterar inte indataparametrar.

Så här fortsätter eller slutför du en konversation

När färdigheten skickar en aktivitet ska kunskapskonsumenten vidarebefordra aktiviteten till användaren.

Du måste dock skicka en endOfConversation aktivitet när färdigheten är klar. Annars fortsätter kunskapskonsumenten att vidarebefordra användaraktiviteter till färdigheten. Du kan också använda aktivitetens värdeegenskap för att inkludera ett returvärde och använda aktivitetens kodegenskap för att ange varför färdigheten slutar.

C#

EchoSkillBot\Bots\EchoBot.cs

protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    if (turnContext.Activity.Text.Contains("end") || turnContext.Activity.Text.Contains("stop"))
    {
        // Send End of conversation at the end.
        var messageText = $"ending conversation from the skill...";
        await turnContext.SendActivityAsync(MessageFactory.Text(messageText, messageText, InputHints.IgnoringInput), cancellationToken);
        var endOfConversation = Activity.CreateEndOfConversationActivity();
        endOfConversation.Code = EndOfConversationCodes.CompletedSuccessfully;
        await turnContext.SendActivityAsync(endOfConversation, cancellationToken);
    }
    else
    {
        var messageText = $"Echo: {turnContext.Activity.Text}";
        await turnContext.SendActivityAsync(MessageFactory.Text(messageText, messageText, InputHints.IgnoringInput), cancellationToken);
        messageText = "Say \"end\" or \"stop\" and I'll end the conversation and back to the parent.";
        await turnContext.SendActivityAsync(MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput), cancellationToken);
    }
}

JavaScript

echo-skill-bot/bot.js

this.onMessage(async (context, next) => {
    switch (context.activity.text.toLowerCase()) {
    case 'end':
    case 'stop':
        await context.sendActivity({
            type: ActivityTypes.EndOfConversation,
            code: EndOfConversationCodes.CompletedSuccessfully
        });
        break;
    default:
        await context.sendActivity(`Echo (JS) : '${ context.activity.text }'`);
        await context.sendActivity('Say "end" or "stop" and I\'ll end the conversation and back to the parent.');
    }

    // By calling next() you ensure that the next BotHandler is run.
    await next();
});

Java

echoSkillBot\EchoBot.java

Varning

Det verkar som om exemplet du letar efter har flyttats! Var säker på att vi arbetar med att lösa detta.

Python

echo-skill-bot/bots/echo_bot.py

async def on_message_activity(self, turn_context: TurnContext):
    if "end" in turn_context.activity.text or "stop" in turn_context.activity.text:
        # Send End of conversation at the end.
        await turn_context.send_activity(
            MessageFactory.text("Ending conversation from the skill...")
        )

        end_of_conversation = Activity(type=ActivityTypes.end_of_conversation)
        end_of_conversation.code = EndOfConversationCodes.completed_successfully
        await turn_context.send_activity(end_of_conversation)
    else:
        await turn_context.send_activity(
            MessageFactory.text(f"Echo (python): {turn_context.activity.text}")
        )
        await turn_context.send_activity(
            MessageFactory.text(
                f'Say "end" or "stop" and I\'ll end the conversation and back to the parent.'
            )
        )

Så här avbryter du färdigheten

För färdigheter med flera interaktioner accepterar du också endOfConversation aktiviteter från en användare av färdigheten, så att användaren kan avbryta den aktuella konversationen.

Logiken för den här färdigheten ändras inte från tur till tur. Om du implementerar en färdighet som allokerar konversationsresurser lägger du till kod för resursrensning i hanteraren för konversationsslut.

C#

EchoSkillBot\Bots\EchoBot.cs

protected override Task OnEndOfConversationActivityAsync(ITurnContext<IEndOfConversationActivity> turnContext, CancellationToken cancellationToken)
{
    // This will be called if the root bot is ending the conversation.  Sending additional messages should be
    // avoided as the conversation may have been deleted.
    // Perform cleanup of resources if needed.
    return Task.CompletedTask;
}

JavaScript

echo-skill-bot/bot.js

onUnrecognizedActivityType Använd metoden för att lägga till en slutkonversationslogik. I hanteraren kontrollerar du om den okända aktivitetens type är lika med endOfConversation.

this.onEndOfConversation(async (context, next) => {
    // This will be called if the root bot is ending the conversation.  Sending additional messages should be
    // avoided as the conversation may have been deleted.
    // Perform cleanup of resources if needed.

    // By calling next() you ensure that the next BotHandler is run.
    await next();
});

Java

echoSkillBot\EchoBot.java

Varning

Det verkar som om exemplet du letar efter har flyttats! Var säker på att vi arbetar med att lösa detta.

Python

echo-skill-bot/bots/echo_bot.py

async def on_end_of_conversation_activity(self, turn_context: TurnContext):
    # This will be called if the root bot is ending the conversation.  Sending additional messages should be
    # avoided as the conversation may have been deleted.
    # Perform cleanup of resources if needed.
    pass

Anspråksverifierare

I det här exemplet används en lista över tillåtna anropare för anspråksverifiering. Kunskapens konfigurationsfil definierar listan. Validatorobjektet läser sedan listan.

Du måste lägga till en anspråksverifiering i autentiseringskonfigurationen. Anspråken utvärderas efter autentiseringshuvudet. Verifieringskoden bör utlösa ett fel eller ett undantag för att avvisa begäran. Det finns många orsaker till att du kanske vill avvisa en annars autentiserad begäran. Till exempel:

• Färdigheten är en del av en betald tjänst. Användare som inte finns i databasen ska inte ha åtkomst.
• Skickligheten är proprietär. Endast vissa användare av kompetensen kan anropa färdigheten.

Viktigt!

Om du inte anger en verifierare av anspråk genererar boten ett fel eller undantag när den tar emot en aktivitet från färdighetskonsumenten.

C#

SDK:t tillhandahåller en AllowedCallersClaimsValidator klass som lägger till auktorisering på programnivå baserat på en enkel lista över ID:er för de program som tillåts anropa kunskapen. Om listan innehåller en asterisk (*) tillåts alla anropare. Anspråksverifieraren har konfigurerats i Startup.cs.

JavaScript

SDK:t tillhandahåller en allowedCallersClaimsValidator klass som lägger till auktorisering på programnivå baserat på en enkel lista över ID:er för de program som tillåts anropa kunskapen. Om listan innehåller en asterisk (*) tillåts alla anropare. Anspråksverifieraren konfigureras i index.js.

Java

SDK:t tillhandahåller en AllowedCallersClaimsValidator klass som lägger till auktorisering på programnivå baserat på en enkel lista över ID:er för de program som tillåts anropa kunskapen. Om listan innehåller en asterisk (*) tillåts alla anropare. Anspråksverifieraren konfigureras i Application.java.

Python

Definiera en verifieringsmetod för anspråk som utlöser ett fel för att avvisa en inkommande begäran.

echo-skill-bot/authentication/allowed_callers_claims_validator.py

class AllowedCallersClaimsValidator:

    config_key = "ALLOWED_CALLERS"

    def __init__(self, config: DefaultConfig):
        if not config:
            raise TypeError(
                "AllowedCallersClaimsValidator: config object cannot be None."
            )

        # ALLOWED_CALLERS is the setting in config.py file
        # that consists of the list of parent bot ids that are allowed to access the skill
        # to add a new parent bot simply go to the AllowedCallers and add
        # the parent bot's microsoft app id to the list
        caller_list = getattr(config, self.config_key)
        if caller_list is None:
            raise TypeError(f'"{self.config_key}" not found in configuration.')
        self._allowed_callers = frozenset(caller_list)

    @property
    def claims_validator(self) -> Callable[[List[Dict]], Awaitable]:
        async def allow_callers_claims_validator(claims: Dict[str, object]):
            # if allowed_callers is None we allow all calls
            if "*" not in self._allowed_callers and SkillValidation.is_skill_claim(
                claims
            ):
                # Check that the appId claim in the skill request is in the list of skills configured for this bot.
                app_id = JwtTokenValidation.get_app_id_from_claims(claims)
                if app_id not in self._allowed_callers:
                    raise PermissionError(
                        f'Received a request from a bot with an app ID of "{app_id}".'
                        f" To enable requests from this caller, add the app ID to your configuration file."
                    )

            return

        return allow_callers_claims_validator

Färdighetsadapter

När ett fel inträffar bör färdighetens adapter rensa konversationstillståndet för färdigheten, och det bör också skicka en endOfConversation aktivitet till färdighetskonsumenten. Om du vill signalera att färdigheten har upphört på grund av ett fel använder du aktivitetens kodegenskap .

C#

EchoSkillBot\SkillAdapterWithErrorHandler.cs

private async Task HandleTurnError(ITurnContext turnContext, Exception exception)
{
    // Log any leaked exception from the application.
    _logger.LogError(exception, $"[OnTurnError] unhandled error : {exception.Message}");

    await SendErrorMessageAsync(turnContext, exception);
    await SendEoCToParentAsync(turnContext, exception);
}

private async Task SendErrorMessageAsync(ITurnContext turnContext, Exception exception)
{
    try
    {
        // Send a message to the user.
        var errorMessageText = "The skill encountered an error or bug.";
        var errorMessage = MessageFactory.Text(errorMessageText, errorMessageText, InputHints.IgnoringInput);
        await turnContext.SendActivityAsync(errorMessage);

        errorMessageText = "To continue to run this bot, please fix the bot source code.";
        errorMessage = MessageFactory.Text(errorMessageText, errorMessageText, InputHints.ExpectingInput);
        await turnContext.SendActivityAsync(errorMessage);

        // Send a trace activity, which will be displayed in the Bot Framework Emulator.
        // Note: we return the entire exception in the value property to help the developer;
        // this should not be done in production.
        await turnContext.TraceActivityAsync("OnTurnError Trace", exception.ToString(), "https://www.botframework.com/schemas/error", "TurnError");
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Exception caught in SendErrorMessageAsync : {ex}");
    }
}

private async Task SendEoCToParentAsync(ITurnContext turnContext, Exception exception)
{
    try
    {
        // Send an EndOfConversation activity to the skill caller with the error to end the conversation,
        // and let the caller decide what to do.
        var endOfConversation = Activity.CreateEndOfConversationActivity();
        endOfConversation.Code = "SkillError";
        endOfConversation.Text = exception.Message;
        await turnContext.SendActivityAsync(endOfConversation);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, $"Exception caught in SendEoCToParentAsync : {ex}");
    }
}

JavaScript

echo-skill-bot/index.js

// Catch-all for errors.
adapter.onTurnError = async (context, error) => {
    // This check writes out errors to the console log, instead of to app insights.
    // NOTE: In a production environment, you should consider logging this to Azure
    //       application insights.
    console.error(`\n [onTurnError] unhandled error: ${ error }`);

    await sendErrorMessage(context, error);
    await sendEoCToParent(context, error);
};

async function sendErrorMessage(context, error) {
    try {
        // Send a message to the user.
        let onTurnErrorMessage = 'The skill encountered an error or bug.';
        await context.sendActivity(onTurnErrorMessage, onTurnErrorMessage, InputHints.ExpectingInput);

        onTurnErrorMessage = 'To continue to run this bot, please fix the bot source code.';
        await context.sendActivity(onTurnErrorMessage, onTurnErrorMessage, InputHints.ExpectingInput);

        // Send a trace activity, which will be displayed in the Bot Framework Emulator.
        // Note: we return the entire exception in the value property to help the developer;
        // this should not be done in production.
        await context.sendTraceActivity('OnTurnError Trace', error.toString(), 'https://www.botframework.com/schemas/error', 'TurnError');
    } catch (err) {
        console.error(`\n [onTurnError] Exception caught in sendErrorMessage: ${ err }`);
    }
}

async function sendEoCToParent(context, error) {
    try {
        // Send an EndOfConversation activity to the skill caller with the error to end the conversation,
        // and let the caller decide what to do.
        const endOfConversation = {
            type: ActivityTypes.EndOfConversation,
            code: 'SkillError',
            text: error.toString()
        };
        await context.sendActivity(endOfConversation);
    } catch (err) {
        console.error(`\n [onTurnError] Exception caught in sendEoCToParent: ${ err }`);
    }
}

Java

echoSkillBot\SkillAdapterWithErrorHandler.java

Varning

Det verkar som om exemplet du letar efter har flyttats! Var säker på att vi arbetar med att lösa detta.

Python

echo-skill-bot/adapter_with_error_handler.py

    # This check writes out errors to console log
    # NOTE: In production environment, you should consider logging this to Azure
    #       application insights.
    print(f"\n [on_turn_error] unhandled error: {error}", file=sys.stderr)
    traceback.print_exc()
    await self._send_error_message(turn_context, error)
    await self._send_eoc_to_parent(turn_context, error)

async def _send_error_message(self, turn_context: TurnContext, error: Exception):
    try:
        # Send a message to the user.
        error_message_text = "The skill encountered an error or bug."
        error_message = MessageFactory.text(
            error_message_text, error_message_text, InputHints.ignoring_input
        )
        await turn_context.send_activity(error_message)

        error_message_text = (
            "To continue to run this bot, please fix the bot source code."
        )
        error_message = MessageFactory.text(
            error_message_text, error_message_text, InputHints.ignoring_input
        )
        await turn_context.send_activity(error_message)

        # Send a trace activity, which will be displayed in Bot Framework Emulator.
        await turn_context.send_trace_activity(
            label="TurnError",
            name="on_turn_error Trace",
            value=f"{error}",
            value_type="https://www.botframework.com/schemas/error",
        )
    except Exception as exception:
        print(
            f"\n Exception caught on _send_error_message : {exception}",
            file=sys.stderr,
        )
        traceback.print_exc()

async def _send_eoc_to_parent(self, turn_context: TurnContext, error: Exception):
    try:
        # Send an EndOfConversation activity to the skill caller with the error to end the conversation,
        # and let the caller decide what to do.
        end_of_conversation = Activity(type=ActivityTypes.end_of_conversation)
        end_of_conversation.code = "SkillError"
        end_of_conversation.text = str(error)

        await turn_context.send_activity(end_of_conversation)
    except Exception as exception:
        print(
            f"\n Exception caught on _send_eoc_to_parent : {exception}",
            file=sys.stderr,
        )
        traceback.print_exc()

Tjänstregistrering

Bot Framework-adaptern använder ett autentiseringskonfigurationsobjekt (anges när adaptern skapas) för att verifiera autentiseringshuvudet för inkommande begäranden.

Det här exemplet lägger till validering av anspråk i autentiseringskonfigurationen och använder skill adapter med felhanteraren som beskrivs i föregående avsnitt.

C#

EchoSkillBot\Startup.cs

    options.SerializerSettings.MaxDepth = HttpHelper.BotMessageSerializerSettings.MaxDepth;
});

// Register AuthConfiguration to enable custom claim validation.
services.AddSingleton(sp =>
{
    var allowedCallers = new List<string>(sp.GetService<IConfiguration>().GetSection("AllowedCallers").Get<string[]>());

    var claimsValidator = new AllowedCallersClaimsValidator(allowedCallers);

    // If TenantId is specified in config, add the tenant as a valid JWT token issuer for Bot to Skill conversation.
    // The token issuer for MSI and single tenant scenarios will be the tenant where the bot is registered.
    var validTokenIssuers = new List<string>();
    var tenantId = sp.GetService<IConfiguration>().GetSection(MicrosoftAppCredentials.MicrosoftAppTenantIdKey)?.Value;

    if (!string.IsNullOrWhiteSpace(tenantId))
    {
        // For SingleTenant/MSI auth, the JWT tokens will be issued from the bot's home tenant.
        // Therefore, these issuers need to be added to the list of valid token issuers for authenticating activity requests.
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidTokenIssuerUrlTemplateV1, tenantId));
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidTokenIssuerUrlTemplateV2, tenantId));
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV1, tenantId));
        validTokenIssuers.Add(string.Format(CultureInfo.InvariantCulture, AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV2, tenantId));
    }

    return new AuthenticationConfiguration
    {
        ClaimsValidator = claimsValidator,
        ValidTokenIssuers = validTokenIssuers
    };
});

// Create the Bot Framework Authentication to be used with the Bot Adapter.
services.AddSingleton<BotFrameworkAuthentication, ConfigurationBotFrameworkAuthentication>();

JavaScript

echo-skill-bot/index.js

const allowedCallers = (process.env.AllowedCallers || '').split(',').filter((val) => val) || [];

const claimsValidators = allowedCallersClaimsValidator(allowedCallers);

// If the MicrosoftAppTenantId is specified in the environment config, add the tenant as a valid JWT token issuer for Bot to Skill conversation.
// The token issuer for MSI and single tenant scenarios will be the tenant where the bot is registered.
let validTokenIssuers = [];
const { MicrosoftAppTenantId } = process.env;

if (MicrosoftAppTenantId) {
    // For SingleTenant/MSI auth, the JWT tokens will be issued from the bot's home tenant.
    // Therefore, these issuers need to be added to the list of valid token issuers for authenticating activity requests.
    validTokenIssuers = [
        `${ AuthenticationConstants.ValidTokenIssuerUrlTemplateV1 }${ MicrosoftAppTenantId }/`,
        `${ AuthenticationConstants.ValidTokenIssuerUrlTemplateV2 }${ MicrosoftAppTenantId }/v2.0/`,
        `${ AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV1 }${ MicrosoftAppTenantId }/`,
        `${ AuthenticationConstants.ValidGovernmentTokenIssuerUrlTemplateV2 }${ MicrosoftAppTenantId }/v2.0/`
    ];
}

// Define our authentication configuration.
const authConfig = new AuthenticationConfiguration([], claimsValidators, validTokenIssuers);

const credentialsFactory = new ConfigurationServiceClientCredentialFactory({
    MicrosoftAppId: process.env.MicrosoftAppId,
    MicrosoftAppPassword: process.env.MicrosoftAppPassword,
    MicrosoftAppType: process.env.MicrosoftAppType,
    MicrosoftAppTenantId: process.env.MicrosoftAppTenantId
});

const botFrameworkAuthentication = new ConfigurationBotFrameworkAuthentication(process.env, credentialsFactory, authConfig);

// Create adapter.
// See https://aka.ms/about-bot-adapter to learn more about how bots work.
const adapter = new CloudAdapter(botFrameworkAuthentication);

Java

echoSkillBot\Application.java

Varning

Det verkar som om exemplet du letar efter har flyttats! Var säker på att vi arbetar med att lösa detta.

Python

echo-skill-bot/app.py

CLAIMS_VALIDATOR = AllowedCallersClaimsValidator(CONFIG)
AUTH_CONFIG = AuthenticationConfiguration(
    claims_validator=CLAIMS_VALIDATOR.claims_validator
)
# Create adapter.
# See https://aka.ms/about-bot-adapter to learn more about how bots work.
SETTINGS = ConfigurationBotFrameworkAuthentication(
    CONFIG,
    auth_configuration=AUTH_CONFIG,
)
ADAPTER = AdapterWithErrorHandler(SETTINGS)

Färdighetsmanifest

Ett kunskapsmanifest är en JSON-fil som beskriver de aktiviteter som färdigheten kan utföra, dess indata- och utdataparametrar och kunskapens slutpunkter. Manifestet innehåller den information du behöver för att komma åt kunskapen från en annan robot. Den senaste schemaversionen är v2.1.

C#

EchoSkillBot\wwwroot\manifest\echoskillbot-manifest-1.0.json

{
  "$schema": "https://schemas.botframework.com/schemas/skills/skill-manifest-2.0.0.json",
  "$id": "EchoSkillBot",
  "name": "Echo Skill bot",
  "version": "1.0",
  "description": "This is a sample echo skill",
  "publisherName": "Microsoft",
  "privacyUrl": "https://echoskillbot.contoso.com/privacy.html",
  "copyright": "Copyright (c) Microsoft Corporation. All rights reserved.",
  "license": "",
  "iconUrl": "https://echoskillbot.contoso.com/icon.png",
  "tags": [
    "sample",
    "echo"
  ],
  "endpoints": [
    {
      "name": "default",
      "protocol": "BotFrameworkV3",
      "description": "Default endpoint for the skill",
      "endpointUrl": "http://echoskillbot.contoso.com/api/messages",
      "msAppId": "00000000-0000-0000-0000-000000000000"
    }
  ]
}

JavaScript

echo-skill-bot/manifest/echoskillbot-manifest-1.0.json

{
  "$schema": "https://schemas.botframework.com/schemas/skills/skill-manifest-2.0.0.json",
  "$id": "EchoSkillBot",
  "name": "Echo Skill bot",
  "version": "1.0",
  "description": "This is a sample echo skill",
  "publisherName": "Microsoft",
  "privacyUrl": "https://echoskillbot.contoso.com/privacy.html",
  "copyright": "Copyright (c) Microsoft Corporation. All rights reserved.",
  "license": "",
  "iconUrl": "https://echoskillbot.contoso.com/icon.png",
  "tags": [
    "sample",
    "echo"
  ],
  "endpoints": [
    {
      "name": "default",
      "protocol": "BotFrameworkV3",
      "description": "Default endpoint for the skill",
      "endpointUrl": "http://echoskillbot.contoso.com/api/messages",
      "msAppId": "00000000-0000-0000-0000-000000000000"
    }
  ]
}

Java

DialogSkillBot\webapp\manifest\echoskillbot-manifest-1.0.json

Varning

Det verkar som om exemplet du letar efter har flyttats! Var säker på att vi arbetar med att lösa detta.

Python

echo_skill_bot/wwwroot/manifest/echoskillbot-manifest-1.0.json

{
    "$schema": "https://schemas.botframework.com/schemas/skills/skill-manifest-2.0.0.json",
    "$id": "EchoSkillBot",
    "name": "Echo Skill bot",
    "version": "1.0",
    "description": "This is a sample echo skill",
    "publisherName": "Microsoft",
    "privacyUrl": "https://echoskillbot.contoso.com/privacy.html",
    "copyright": "Copyright (c) Microsoft Corporation. All rights reserved.",
    "license": "",
    "iconUrl": "https://echoskillbot.contoso.com/icon.png",
    "tags": [
      "sample",
      "echo"
    ],
    "endpoints": [
      {
        "name": "default",
        "protocol": "BotFrameworkV3",
        "description": "Default endpoint for the skill",
        "endpointUrl": "http://echoskillbot.contoso.com/api/messages",
        "msAppId": "00000000-0000-0000-0000-000000000000"
      }
    ]
  }

Schemat för färdighetsmanifestet är en JSON-fil som beskriver schemat för färdighetsmanifestet. Den aktuella schemaversionen är 2.1.0.

Testa färdigheten

Nu kan du testa färdigheten i emulatorn som om det vore en vanlig robot. Men för att testa det som en färdighet skulle du behöva implementera en kunskapskonsument.

Ladda ned och installera den senaste Bot Framework-emulatorn

1. Kör ekofärdighetsroboten lokalt på datorn. Om du behöver instruktioner kan du läsa README filen för exemplet C#, JavaScript, Java eller Python .
2. Använd emulatorn för att testa roboten. När du skickar ett "slut" eller "stopp"-meddelande till färdigheten skickar det en endOfConversation aktivitet utöver svarsmeddelandet. Färdigheten endOfConversation skickar aktiviteten för att indikera att färdigheten är klar.

Mer om felsökning

Eftersom trafiken mellan kompetens och kunskapskonsumenter autentiseras finns det extra steg när du felsöker sådana robotar.

• Kompetenskonsumenten och alla färdigheter som den använder, direkt eller indirekt, måste vara igång.
• Om robotarna körs lokalt och om någon av robotarna har ett app-ID och lösenord måste alla robotar ha giltiga ID:er och lösenord.
• Om alla robotar har distribuerats kan du se hur du felsöker en robot från valfri kanal med devtunnel.
• Om några av robotarna körs lokalt och vissa är distribuerade, kan du läsa om hur du felsöker en färdighet eller färdighetskonsument.

Annars kan du felsöka en användare av en färdighet eller själva färdigheten på samma sätt som du felsöker andra robotar. Mer information finns i Felsöka en robot och felsöka med Bot Framework-emulatorn.

Nästa steg

Implementera en färdighet för Copilot Studio