@microsoft/teamsfx package

Sso execution dialog, use to handle sso command

A card action bot to respond to adaptive card universal actions.

A NotificationTarget that represents a team channel.

A command bot for receiving commands and sending responses in Teams.

Provide utilities for bot conversation, including:

• handle command and response.
• send notification to varies targets (e.g., member, group, channel).

Example

For command and response, you can register your commands through the constructor, or use the registerCommand and registerCommands API to add commands later.

import { BotBuilderCloudAdapter } from "@microsoft/teamsfx";
import ConversationBot = BotBuilderCloudAdapter.ConversationBot;

// register through constructor
const conversationBot = new ConversationBot({
  command: {
    enabled: true,
    commands: [ new HelloWorldCommandHandler() ],
  },
});

// register through `register*` API
conversationBot.command.registerCommand(new HelpCommandHandler());

For notification, you can enable notification at initialization, then send notifications at any time.

import { BotBuilderCloudAdapter } from "@microsoft/teamsfx";
import ConversationBot = BotBuilderCloudAdapter.ConversationBot;

// enable through constructor
const conversationBot = new ConversationBot({
  notification: {
    enabled: true,
  },
});

// get all bot installations and send message
for (const target of await conversationBot.notification.installations()) {
  await target.sendMessage("Hello Notification");
}

// alternative - send message to all members
for (const target of await conversationBot.notification.installations()) {
  for (const member of await target.members()) {
    await member.sendMessage("Hello Notification");
  }
}

A NotificationTarget that represents a team member.

Provide utilities to send notification to varies targets (e.g., member, group, channel).

A NotificationTarget that represents a bot installation. Teams Bot could be installed into

• Personal chat
• Group chat
• Team (by default the General channel)

Provider that handles API Key authentication

Represent Microsoft 365 tenant identity, and it is usually used when user is not involved like time-triggered automation job.

Example

loadConfiguration(); // load configuration from environment variables
const credential = new AppCredential();

Provider that handles Basic authentication

Provider that handles Bearer Token authentication

Sso execution dialog, use to handle sso command

Provider that handles Certificate authentication

A NotificationTarget that represents a team channel.

Error class with code and message thrown by the SDK.

Provides methods for formatting various invoke responses a bot can send to respond to an invoke request.

A NotificationTarget that represents a team member.

Provides utility method to build bot message with cards that supported in Teams.

Microsoft Graph auth provider for Teams Framework

Represent on-behalf-of flow to get user identity, and it is designed to be used in server side.

Example

const credential = new OnBehalfOfUserCredential(ssoToken);

Creates a new prompt that leverage Teams Single Sign On (SSO) support for bot to automatically sign in user and help receive oauth token, asks the user to consent if needed.

Example

When used with your bots DialogSet you can simply add a new instance of the prompt as a named dialog using DialogSet.add(). You can then start the prompt from a waterfall step using either DialogContext.beginDialog() or DialogContext.prompt(). The user will be prompted to sign in as needed and their access token will be passed as an argument to the callers next waterfall step:

const { ConversationState, MemoryStorage } = require('botbuilder');
const { DialogSet, WaterfallDialog } = require('botbuilder-dialogs');
const { TeamsBotSsoPrompt } = require('@microsoft/teamsfx');

const convoState = new ConversationState(new MemoryStorage());
const dialogState = convoState.createProperty('dialogState');
const dialogs = new DialogSet(dialogState);

dialogs.add(new TeamsBotSsoPrompt('TeamsBotSsoPrompt', {
   scopes: ["User.Read"],
}));

dialogs.add(new WaterfallDialog('taskNeedingLogin', [
     async (step) => {
         return await step.beginDialog('TeamsBotSsoPrompt');
     },
     async (step) => {
         const token = step.result;
         if (token) {

             // ... continue with task needing access token ...

         } else {
             await step.context.sendActivity(`Sorry... We couldn't log you in. Try again later.`);
             return await step.endDialog();
         }
     }
]));

A class providing credential and configuration.

Represent Teams current user's identity, and it is used within Teams client applications.

Options to initialize ConversationBot

Options to initialize NotificationBot.

Defines method that injects authentication info to http requests

Authentication related configuration.

Interface for SSO configuration for Bot SSO

Interface for user to customize SSO execution activity handler

Options to initialize CardActionBot.

Interface for a command message that can handled in a command handler.

Options to initialize CommandBot.

Options to initialize ConversationBot

A store to persist notification target references.

Options to add a conversation reference to the store.

Interface for customized logger.

Token response provided by Teams Bot SSO prompt

Options to initialize NotificationBot.

Represent a notification target.

Interface for a storage provider that stores and retrieves notification target references.

Represents a page of data.

Settings used to configure an TeamsBotSsoPrompt instance.

Token response provided by Teams Bot SSO prompt

Interface for adaptive card action handler that can process card action invoke and return a response.

Interface for a command handler that can process command to a TeamsFx bot and return a response.

Interface for a command handler that can process sso command to a TeamsFx bot and return a response.

UserInfo with user displayName, objectId and preferredUserName.

Authentication configuration for AppCredential used in node environment

Log function for customized logging.

Authentication configuration for OnBehalfOfCredential used in node environment

Authentication configuration for TeamsUserCredential used in browser environment

The trigger pattern used to trigger a TeamsFxBotCommandHandler instance.

The search scope when calling findMember and findAllMembers. The search scope is a flagged enum and it can be combined with |. For example, to search from personal chat and group chat, use SearchScope.Person | SearchScope.Group.

Options used to control how the response card will be sent to users.

Define available location for API Key location

Error code to trace the error types.

Identity type to use in authentication.

Status code for an application/vnd.microsoft.error invoke response.

Log level.

The target type where the notification will be sent to.

The search scope when calling findMember and findAllMembers. The search scope is a flagged enum and it can be combined with |. For example, to search from personal chat and group chat, use SearchScope.Person | SearchScope.Group.

Initializes new Axios instance with specific auth provider

Example

const client = createApiClient("https://my-api-endpoint-base-url", new BasicAuthProvider("xxx","xxx"));

Get Microsoft graph client.

Example

Get Microsoft graph client by TokenCredential

// Sso token example (Azure Function)
const ssoToken = "YOUR_TOKEN_STRING";
const options = {"AAD_APP_ID", "AAD_APP_SECRET"};
const credential = new OnBehalfOfAADUserCredential(ssoToken, options);
const graphClient = await createMicrosoftGraphClient(credential);
const profile = await graphClient.api("/me").get();

// TeamsBotSsoPrompt example (Bot Application)
const requiredScopes = ["User.Read"];
const config: Configuration = {
   loginUrl: loginUrl,
   clientId: clientId,
   clientSecret: clientSecret,
   tenantId: tenantId
};
const prompt = new TeamsBotSsoPrompt(dialogId, {
   config: config
   scopes: ["User.Read"],
});
this.addDialog(prompt);

const oboCredential = new OnBehalfOfAADUserCredential(
 getUserId(dialogContext),
 {
   clientId: "AAD_APP_ID",
   clientSecret: "AAD_APP_SECRET"
 });
try {
   const graphClient = await createMicrosoftGraphClient(credential);
   const profile = await graphClient.api("/me").get();
} catch (e) {
   dialogContext.beginDialog(dialogId);
   return Dialog.endOfTurn();
}

Get Microsoft graph client.

Example

Get Microsoft graph client by TokenCredential

// In browser: TeamsUserCredential
const authConfig: TeamsUserCredentialAuthConfig = {
  clientId: "xxx",
initiateLoginEndpoint: "https://xxx/auth-start.html",
};

const credential = new TeamsUserCredential(authConfig);

const scope = "User.Read";
await credential.login(scope);

const client = createMicrosoftGraphClientWithCredential(credential, scope);

// In node: OnBehalfOfUserCredential
const oboAuthConfig: OnBehalfOfCredentialAuthConfig = {
  authorityHost: "xxx",
  clientId: "xxx",
  tenantId: "xxx",
  clientSecret: "xxx",
};

const oboCredential = new OnBehalfOfUserCredential(ssoToken, oboAuthConfig);
const scope = "User.Read";
const client = createMicrosoftGraphClientWithCredential(oboCredential, scope);

// In node: AppCredential
const appAuthConfig: AppCredentialAuthConfig = {
  authorityHost: "xxx",
  clientId: "xxx",
  tenantId: "xxx",
  clientSecret: "xxx",
};
const appCredential = new AppCredential(appAuthConfig);
const scope = "User.Read";
const client = createMicrosoftGraphClientWithCredential(appCredential, scope);

const profile = await client.api("/me").get();

Helper to create SecureContextOptions from PEM format cert

Helper to create SecureContextOptions from PFX format cert

Get log level.

Generate connection configuration consumed by tedious.

Users execute link query in message extension with SSO or access token.

Users execute query in message extension with SSO or access token.

Users execute query in message extension with SSO or access token.

Send an adaptive card message to a notification target.

Send a plain text message to a notification target.

Set custom log function. Use the function if it's set. Priority is lower than setLogger.

Example

setLogFunction((level: LogLevel, message: string) => {
  if (level === LogLevel.Error) {
    console.log(message);
  }
});

Update log level helper.

Set custom logger. Use the output functions if it's set. Priority is higher than setLogFunction.

Example

setLogger({
  verbose: console.debug,
  info: console.info,
  warn: console.warn,
  error: console.error,
});