Implementowanie umiejętności

DOTYCZY: SDK w wersji 4

Możesz użyć umiejętności, aby rozszerzyć innego bota. Umiejętność to bot, który może wykonywać zestaw zadań dla innego bota.

• Manifest opisuje interfejs umiejętności. Deweloperzy, którzy nie mają dostępu do kodu źródłowego umiejętności, mogą używać informacji w manifeście, aby zaprojektować swojego konsumenta umiejętności.
• Umiejętność może używać weryfikacji oświadczeń do zarządzania dostępem botów lub użytkowników do niej.

W tym artykule pokazano, jak zaimplementować umiejętność, która odzwierciedla dane wejściowe użytkownika.

Niektóre typy konsumentów umiejętności nie mogą używać niektórych typów botów umiejętności. W poniższej tabeli opisano, które kombinacje są obsługiwane.

	Obsługa wielu najemców	Umiejętność dedykowana jednemu najemcy	Umiejętność związana z tożsamością zarządzaną nadaną przez użytkownika
Użytkownik z wieloma dzierżawami	Obsługiwane	Niewspierane	Nieobsługiwane
Jednodzierżawowy użytkownik	Niewspierane	Obsługiwane, jeśli obie aplikacje należą do tego samego dzierżawcy	Obsługiwane, jeśli obie aplikacje należą do tego samego dzierżawcy
Odbiorca zarządzanej tożsamości przypisanej przez użytkownika	Nieobsługiwane	Obsługiwane, jeśli obie aplikacje należą do tego samego dzierżawcy	Obsługiwane, jeśli obie aplikacje należą do tego samego klienta.

Uwaga

Zestawy SDK języka JavaScript, C# i Python platformy Bot Framework będą nadal obsługiwane, jednak zestaw SDK języka Java jest wycofywany z ostatecznym długoterminowym wsparciem kończącym się w listopadzie 2023 r.

Istniejące boty utworzone za pomocą zestawu JAVA SDK będą nadal działać.

W przypadku tworzenia nowych botów, rozważ użycie programu Microsoft Copilot Studio i przeczytaj o wyborze odpowiedniego rozwiązania dla Copilota.

Aby uzyskać więcej informacji, zobacz Przyszłość tworzenia botów.

Wymagania wstępne

• Znajomość podstaw bota i umiejętności.
• Subskrypcja platformy Azure (w celu wdrożenia umiejętności). Jeśli nie masz subskrypcji, przed rozpoczęciem utwórz bezpłatne konto.
• Kopia prostego przykładu bota do bota w języku C#, JavaScript, Java lub Python.

Uwaga

Począwszy od wersji 4.11, nie potrzebujesz identyfikatora aplikacji i hasła, aby przetestować umiejętności lokalnie w emulatorze bot framework. Subskrypcja platformy Azure jest nadal wymagana do wdrożenia umiejętności na platformie Azure.

Informacje o tym przykładzie

Przykład prostych umiejętności do komunikacji między botami obejmuje projekty dla dwóch botów:

• Bot echo skill, który implementuje tę umiejętność.
• Prosty root bot, który implementuje bota głównego wykorzystującego umiejętności.

Ten artykuł koncentruje się na umiejętności, która obejmuje logikę obsługi w jego bocie i adapterze.

C#

JavaScript

Java

Python

Aby uzyskać informacje na temat prostego bota podstawowego, zobacz, jak zaimplementować konsumenta umiejętności.

Zasoby

W przypadku wdrożonych botów uwierzytelnianie bot-to-bot wymaga, aby każdy uczestniczący bot miał prawidłowe informacje o tożsamości. Możesz jednak przetestować wielodostępne umiejętności i umiejętności konsumentów lokalnie za pomocą emulatora bez identyfikatora aplikacji i hasła.

Aby udostępnić umiejętności botom dostępnym dla użytkowników, zarejestruj umiejętności na platformie Azure. Aby uzyskać więcej informacji, zobacz jak zarejestrować bota w usłudze Azure AI Bot Service.

Konfiguracja aplikacji

Opcjonalnie dodaj informacje o tożsamości umiejętności do pliku konfiguracji. Jeśli albo umiejętność, albo jej użytkownik dostarcza informacje o tożsamości, oboje muszą to zrobić.

Tablica dozwolonych rozmówców może ograniczyć, którzy konsumenci umiejętności mogą uzyskiwać do niej dostęp. Aby zaakceptować wywołania od dowolnego użytkownika zasobu, dodaj element "*".

Uwaga

Jeśli testujesz umiejętności lokalnie bez informacji o tożsamości bota, ani umiejętności, ani użytkownik umiejętności nie uruchamia kodu w celu przeprowadzenia weryfikacji oświadczeń.

C#

EchoSkillBot\appsettings.json

Opcjonalnie dodaj informacje o tożsamości umiejętności do pliku 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

Opcjonalnie dodaj informacje o tożsamości umiejętności do pliku env.

MicrosoftAppType=
MicrosoftAppId=
MicrosoftAppPassword=
MicrosoftAppTenantId=
AllowedCallers=*

Java

DialogSkillBot\resources\application.properties

Opcjonalnie dodaj identyfikator aplikacji i hasło umiejętności do pliku application.properties.

Ostrzeżenie

Wygląda na to, że przykład, którego szukasz, został przeniesiony! Bądź pewien, że pracujemy nad rozwiązaniem tego problemu.

Python

Opcjonalnie dodaj identyfikator aplikacji i hasło umiejętności do pliku 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.

Logika obsługi działań

Aby zaakceptować parametry wejściowe

Użytkownik umiejętności może wysyłać informacje do umiejętności. Jednym ze sposobów akceptowania takich informacji jest akceptowanie ich za pośrednictwem właściwości value w komunikatach przychodzących. Innym sposobem jest obsługa zdarzeń i wywoływanie działań.

Umiejętność w tym przykładzie nie akceptuje parametrów wejściowych.

Aby kontynuować lub ukończyć konwersację

Gdy umiejętność wysyła działanie, odbiorca umiejętności powinien przekazać działanie użytkownikowi.

Jednak musisz wysłać endOfConversation działanie po zakończeniu umiejętności. W przeciwnym razie użytkownik umiejętności nadal przekazuje działania użytkownika do umiejętności. Opcjonalnie użyj właściwości value działania, aby uwzględnić wartość zwracaną, i użyj właściwości code działania, aby wskazać, dlaczego umiejętność się kończy.

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

Ostrzeżenie

Wygląda na to, że przykład, którego szukasz, został przeniesiony! Bądź pewien, że pracujemy nad rozwiązaniem tego problemu.

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.'
            )
        )

Aby anulować umiejętność

W przypadku umiejętności obejmujących wiele kolei możesz również zaakceptować endOfConversation działania od konsumenta umiejętności, aby umożliwić konsumentowi anulowanie bieżącej konwersacji.

Logika tej umiejętności nie zmienia się z tury na turę. Jeśli zaimplementujesz umiejętność przydzielającą zasoby konwersacji, dodaj kod oczyszczania zasobów do procedury obsługi zakończenia konwersacji.

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 Użyj metody , aby dodać logikę końca konwersacji. W procedurze obsługi sprawdź, czy nierozpoznane działanie jest type równe 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

Ostrzeżenie

Wygląda na to, że przykład, którego szukasz, został przeniesiony! Bądź pewien, że pracujemy nad rozwiązaniem tego problemu.

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

Moduł sprawdzania poprawności oświadczeń

W tym przykładzie użyto listy dozwolonych wywołań na potrzeby weryfikacji oświadczeń. Plik konfiguracji umiejętności definiuje listę. Następnie obiekt modułu sprawdzania poprawności odczytuje listę.

Do konfiguracji uwierzytelniania należy dodać moduł sprawdzania poprawności oświadczeń. Oświadczenia są oceniane po nagłówku uwierzytelniania. Kod weryfikacji powinien zgłosić błąd lub wyjątek, aby odrzucić żądanie. Istnieje wiele powodów, dla których można odrzucić w inny sposób uwierzytelnione żądanie. Na przykład:

• Umiejętność jest częścią płatnej usługi. Użytkownik, który nie znajduje się w bazie danych, nie powinien mieć dostępu.
• Umiejętność jest własnością. Tylko niektórzy użytkownicy umiejętności mogą korzystać z umiejętności.

Ważne

Jeśli nie podasz walidatora roszczeń, twój bot wygeneruje błąd lub wyjątek po otrzymaniu aktywności od konsumenta umiejętności.

C#

Zestaw SDK udostępnia klasę AllowedCallersClaimsValidator , która dodaje autoryzację na poziomie aplikacji na podstawie prostej listy identyfikatorów aplikacji, które mogą wywoływać umiejętności. Jeśli lista zawiera gwiazdkę (*), wszystkie osoby wywołujące są dozwolone. Moduł sprawdzania poprawności oświadczeń jest skonfigurowany w Startup.cs.

JavaScript

Zestaw SDK udostępnia klasę allowedCallersClaimsValidator , która dodaje autoryzację na poziomie aplikacji na podstawie prostej listy identyfikatorów aplikacji, które mogą wywoływać umiejętności. Jeśli lista zawiera gwiazdkę (*), wszystkie osoby wywołujące są dozwolone. Moduł sprawdzania poprawności oświadczeń jest skonfigurowany w index.js.

Java

Zestaw SDK udostępnia klasę AllowedCallersClaimsValidator , która dodaje autoryzację na poziomie aplikacji na podstawie prostej listy identyfikatorów aplikacji, które mogą wywoływać umiejętności. Jeśli lista zawiera gwiazdkę (*), wszystkie osoby wywołujące są dozwolone. Moduł sprawdzania poprawności oświadczeń jest skonfigurowany w Application.java.

Python

Zdefiniuj metodę weryfikacji oświadczeń, która zgłasza błąd w celu odrzucenia żądania przychodzącego.

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

Adapter umiejętności

W przypadku wystąpienia błędu adapter umiejętności powinien wyczyścić stan konwersacji dla umiejętności i powinien również wysłać endOfConversation działanie do konsumenta umiejętności. Aby zasygnalizować, że umiejętności zakończyły się z powodu błędu, użyj właściwości kodu działania.

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

Ostrzeżenie

Wygląda na to, że przykład, którego szukasz, został przeniesiony! Bądź pewien, że pracujemy nad rozwiązaniem tego problemu.

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

Rejestracja usługi

Adapter Bot Framework używa obiektu konfiguracji uwierzytelniania (ustawionego podczas tworzenia adaptera) do weryfikacji nagłówka uwierzytelniania w przychodzących żądaniach.

Ten przykład dodaje weryfikację roszczeń do konfiguracji uwierzytelniania i używa adaptera umiejętności z obsługą błędów opisanego w poprzedniej sekcji.

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

Ostrzeżenie

Wygląda na to, że przykład, którego szukasz, został przeniesiony! Bądź pewien, że pracujemy nad rozwiązaniem tego problemu.

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)

Manifest umiejętności

Manifest umiejętności to plik JSON opisujący działania, które mogą wykonywać umiejętności, jego parametry wejściowe i wyjściowe oraz punkty końcowe umiejętności. Manifest zawiera informacje potrzebne do uzyskania dostępu do umiejętności innego bota. Najnowsza wersja schematu to wersja 2.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

Ostrzeżenie

Wygląda na to, że przykład, którego szukasz, został przeniesiony! Bądź pewien, że pracujemy nad rozwiązaniem tego problemu.

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 manifestu umiejętności to plik JSON opisujący schemat manifestu umiejętności. Bieżąca wersja schematu to 2.1.0.

Testowanie umiejętności

W tym momencie możesz przetestować umiejętności w emulatorze tak, jakby był to normalny bot. Jednak aby przetestować go jako umiejętność, musisz zaimplementować konsumenta umiejętności.

Pobierz i zainstaluj najnowszą wersję emulatora platformy Bot Framework

1. Uruchom lokalnie na swoim komputerze bota umiejętności "echo". Jeśli potrzebujesz instrukcji, zapoznaj się z plikiem README przykładowym języka C#, JavaScript, Java lub Python .
2. Użyj emulatora, aby przetestować bota. Po wysłaniu komunikatu "end" lub "stop" do funkcji, wysyłana jest aktywność endOfConversation oraz wiadomość odpowiedzi. Umiejętność wysyła działanie endOfConversation, aby wskazać, że umiejętność jest zakończona.

Więcej informacji o debugowaniu

Ponieważ ruch między umiejętnościami i użytkownikami umiejętności jest uwierzytelniany, podczas debugowania takich botów są wykonywane dodatkowe kroki.

• Konsument umiejętności i wszystkie umiejętności, które wykorzystuje, bezpośrednio lub pośrednio, muszą działać.
• Jeśli boty działają lokalnie i jeśli którykolwiek z botów ma identyfikator aplikacji i hasło, wszystkie boty muszą mieć prawidłowe identyfikatory i hasła.
• Jeśli wszystkie boty są wdrożone, zobacz, jak debugować bota z dowolnego kanału przy użyciu metodyki devtunnel.
• Jeśli niektóre boty działają lokalnie, a niektóre są wdrażane, zobacz, jak debugować umiejętności lub umiejętności użytkownika.

W przeciwnym razie możesz debugować konsumenta umiejętności lub umiejętność w znany sposób, jak w przypadku debugowania innych botów. Aby uzyskać więcej informacji, zobacz Debugowanie bota i Debugowanie za pomocą emulatora platformy Bot Framework.

Następne kroki

Implementowanie umiejętności dla programu Copilot Studio