botbuilder

constructor

constructor(settings?: Partial<BotFrameworkAdapterSettings>);

• Creates a new instance of the [BotFrameworkAdapter](xref:botbuilder.BotFrameworkAdapter) class.

  Parameter settings

  Optional. The settings to use for this adapter instance.

  Remarks

  If the settings parameter does not include [channelService](xref:botbuilder.BotFrameworkAdapterSettings.channelService) or [openIdMetadata](xref:botbuilder.BotFrameworkAdapterSettings.openIdMetadata) values, the constructor checks the process' environment variables for these values. These values may be set when a bot is provisioned on Azure and if so are required for the bot to work properly in the global cloud or in a national cloud.

  The [BotFrameworkAdapterSettings](xref:botbuilder.BotFrameworkAdapterSettings) class defines the available adapter settings.

property credentials

protected readonly credentials: AppCredentials;

property credentialsProvider

protected readonly credentialsProvider: SimpleCredentialProvider;

property isStreamingConnectionOpen

readonly isStreamingConnectionOpen: boolean;

• Used in streaming contexts to check if the streaming connection is still open for the bot to send activities.

  Returns

  True if the streaming connection is open, otherwise false.

property settings

protected readonly settings: BotFrameworkAdapterSettings;

property TokenApiClientCredentialsKey

readonly TokenApiClientCredentialsKey: Symbol;

method authenticateRequest

protected authenticateRequest: (
    request: Activity,
    authHeader: string
) => Promise<void>;

• Allows for the overriding of authentication in unit tests.

  Parameter request

  Received request.

  Parameter authHeader

  Received authentication header.

method buildCredentials

protected buildCredentials: (
    appId: string,
    oAuthScope?: string
) => Promise<AppCredentials>;

• Parameter appId

  The application id.

  Parameter oAuthScope

  The optional OAuth scope.

  Returns

  The app credentials to be used to acquire tokens.

  Remarks

  When building credentials for bot-to-bot communication, oAuthScope must be passed in.

method checkEmulatingOAuthCards

protected checkEmulatingOAuthCards: (context: TurnContext) => void;

• Checks the environment and can set a flag to emulate OAuth cards.

  Parameter context

  The context object for the turn.

  Remarks

  Override this in a derived class to control how OAuth cards are emulated for unit testing.

method continueConversation

continueConversation: {
    (
        reference: ConversationReference,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
    (
        reference: ConversationReference,
        oAuthScope: string,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
};

• Asynchronously resumes a conversation with a user, possibly after some time has gone by.

  Parameter reference

  A reference to the conversation to continue.

  Parameter oAuthScope

  The intended recipient of any sent activities.

  Parameter logic

  The asynchronous method to call after the adapter middleware runs.

  Remarks

  This is often referred to as a _proactive notification_, the bot can proactively send a message to a conversation or user without waiting for an incoming message. For example, a bot can use this method to send notifications or coupons to a user.

  To send a proactive message: 1. Save a copy of a [ConversationReference](xref:botframework-schema.ConversationReference) from an incoming activity. For example, you can store the conversation reference in a database. 1. Call this method to resume the conversation at a later time. Use the saved reference to access the conversation. 1. On success, the adapter generates a [TurnContext](xref:botbuilder-core.TurnContext) object and calls the logic function handler. Use the logic function to send the proactive message.

  To copy the reference from any incoming activity in the conversation, use the [TurnContext.getConversationReference](xref:botbuilder-core.TurnContext.getConversationReference) method.

  This method is similar to the [processActivity](xref:botbuilder.BotFrameworkAdapter.processActivity) method. The adapter creates a [TurnContext](xref:botbuilder-core.TurnContext) and routes it through its middleware before calling the logic handler. The created activity will have a [type](xref:botframework-schema.Activity.type) of 'event' and a [name](xref:botframework-schema.Activity.name) of 'continueConversation'.

  For example:

  server.post('/api/notifyUser', async (req, res) => {
     // Lookup previously saved conversation reference.
     const reference = await findReference(req.body.refId);
  
     // Proactively notify the user.
     if (reference) {
        await adapter.continueConversation(reference, async (context) => {
           await context.sendActivity(req.body.message);
        });
        res.send(200);
     } else {
        res.send(404);
     }
  });

• Asynchronously resumes a conversation with a user, possibly after some time has gone by.

  Parameter reference

  [ConversationReference](xref:botframework-schema.ConversationReference) of the conversation to continue.

  Parameter oAuthScope

  The intended recipient of any sent activities or the function to call to continue the conversation.

  Parameter logic

  Optional. The asynchronous method to call after the adapter middleware runs.

method createConnectorClient

createConnectorClient: (serviceUrl: string) => ConnectorClient;

• Creates a connector client.

  Parameter serviceUrl

  The client's service URL.

  Returns

  The [ConnectorClient](xref:botbuilder-connector.ConnectorClient) instance.

  Remarks

  Override this in a derived class to create a mock connector client for unit testing.

method createConnectorClientWithIdentity

createConnectorClientWithIdentity: {
    (serviceUrl: string, identity: ClaimsIdentity): Promise<ConnectorClient>;
    (
        serviceUrl: string,
        identity: ClaimsIdentity,
        audience: string
    ): Promise<ConnectorClient>;
};

• Create a ConnectorClient with a ClaimsIdentity.

  Parameter serviceUrl

  The client's service URL.

  Parameter identity

  ClaimsIdentity

  Remarks

  If the ClaimsIdentity contains the claims for a Skills request, create a ConnectorClient for use with Skills. Derives the correct audience from the ClaimsIdentity, or the instance's credentials property.

• Create a ConnectorClient with a ClaimsIdentity and an explicit audience.

  Parameter serviceUrl

  The client's service URL.

  Parameter identity

  ClaimsIdentity

  Parameter audience

  The recipient of the ConnectorClient's messages. Normally the Bot Framework Channel Service or the AppId of another bot.

  Remarks

  If the trimmed audience is not a non-zero length string, the audience will be derived from the ClaimsIdentity or the instance's credentials property.

method createContext

protected createContext: (request: Activity) => TurnContext;

• Creates a turn context.

  Parameter request

  An incoming request body.

  Returns

  A new [TurnContext](xref:botbuilder-core.TurnContext) instance.

  Remarks

  Override this in a derived class to modify how the adapter creates a turn context.

method createConversation

createConversation: {
    (
        reference: ConversationReference,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
    (
        reference: ConversationReference,
        parameters: ConversationParameters,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
};

• Asynchronously creates and starts a conversation with a user on a channel.

  Parameter reference

  A reference for the conversation to create.

  Parameter logic

  The asynchronous method to call after the adapter middleware runs.

  Returns

  {Promise} a promise representing the asynchronous operation

  To use this method, you need both the bot's and the user's account information on a channel. The Bot Connector service supports the creating of group conversations; however, this method and most channels only support initiating a direct message (non-group) conversation.

  To create and start a new conversation: 1. Get a copy of a [ConversationReference](xref:botframework-schema.ConversationReference) from an incoming activity. 1. Set the [user](xref:botframework-schema.ConversationReference.user) property to the [ChannelAccount](xref:botframework-schema.ChannelAccount) value for the intended recipient. 1. Call this method to request that the channel create a new conversation with the specified user. 1. On success, the adapter generates a turn context and calls the logic function handler.

  To get the initial reference, use the [TurnContext.getConversationReference](xref:botbuilder-core.TurnContext.getConversationReference) method on any incoming activity in the conversation.

  If the channel establishes the conversation, the generated event activity's [conversation](xref:botframework-schema.Activity.conversation) property will contain the ID of the new conversation.

  This method is similar to the [processActivity](xref:botbuilder.BotFrameworkAdapter.processActivity) method. The adapter creates a [TurnContext](xref:botbuilder-core.TurnContext) and routes it through middleware before calling the logic handler. The created activity will have a [type](xref:botframework-schema.Activity.type) of 'event' and a [name](xref:botframework-schema.Activity.name) of 'createConversation'.

  For example:

  // Get group members conversation reference
  const reference = TurnContext.getConversationReference(context.activity);
  
  // ...
  // Start a new conversation with the user
  await adapter.createConversation(reference, async (ctx) => {
     await ctx.sendActivity(`Hi (in private)`);
  });

• Asynchronously creates and starts a conversation with a user on a channel.

  Parameter reference

  A reference for the conversation to create.

  Parameter parameters

  Parameters used when creating the conversation

  Parameter logic

  The asynchronous method to call after the adapter middleware runs.

  Returns

  {Promise} a promise representing the asynchronous operation

method createTokenApiClient

protected createTokenApiClient: (
    serviceUrl: string,
    oAuthAppCredentials?: CoreAppCredentials
) => TokenApiClient;

• Creates an OAuth API client.

  Parameter serviceUrl

  The client's service URL.

  Parameter oAuthAppCredentials

  AppCredentials for OAuth.

  Remarks

  Override this in a derived class to create a mock OAuth API client for unit testing.

method deleteActivity

deleteActivity: (
    context: TurnContext,
    reference: ConversationReference
) => Promise<void>;

• Asynchronously deletes an existing activity.

  This interface supports the framework and is not intended to be called directly for your code. Use [TurnContext.deleteActivity](xref:botbuilder-core.TurnContext.deleteActivity) to delete an activity from your bot code.

  Parameter context

  The context object for the turn.

  Parameter reference

  Conversation reference information for the activity to delete.

  Remarks

  Not all channels support this operation. For channels that don't, this call may throw an exception.

method deleteConversationMember

deleteConversationMember: (
    context: TurnContext,
    memberId: string
) => Promise<void>;

• Asynchronously removes a member from the current conversation.

  Parameter context

  The context object for the turn.

  Parameter memberId

  The ID of the member to remove from the conversation.

  Remarks

  Remove a member's identity information from the conversation.

  Not all channels support this operation. For channels that don't, this call may throw an exception.

method emulateOAuthCards

emulateOAuthCards: (
    contextOrServiceUrl: TurnContext | string,
    emulate: boolean
) => Promise<void>;

• Asynchronously sends an emulated OAuth card for a channel.

  This method supports the framework and is not intended to be called directly for your code.

  Parameter contextOrServiceUrl

  The URL of the emulator.

  Parameter emulate

  true to send an emulated OAuth card to the emulator; or false to not send the card.

  Remarks

  When testing a bot in the Bot Framework Emulator, this method can emulate the OAuth card interaction.

method exchangeToken

exchangeToken: (
    context: TurnContext,
    connectionName: string,
    userId: string,
    tokenExchangeRequest: TokenExchangeRequest,
    appCredentials?: CoreAppCredentials
) => Promise<TokenResponse>;

• Asynchronously Performs a token exchange operation such as for single sign-on.

  Parameter context

  Context for the current turn of conversation with the user.

  Parameter connectionName

  Name of the auth connection to use.

  Parameter userId

  The user id that will be associated with the token.

  Parameter tokenExchangeRequest

  The exchange request details, either a token to exchange or a uri to exchange.

  Parameter appCredentials

  Optional. The CoreAppCredentials for OAuth.

method getAadTokens

getAadTokens: {
    (
        context: TurnContext,
        connectionName: string,
        resourceUrls: string[]
    ): Promise<{ [propertyName: string]: TokenResponse }>;
    (
        context: TurnContext,
        connectionName: string,
        resourceUrls: string[],
        oAuthAppCredentials?: CoreAppCredentials
    ): Promise<{ [propertyName: string]: TokenResponse }>;
};

• Asynchronously signs out the user from the token server.

  Parameter context

  The context object for the turn.

  Parameter connectionName

  The name of the auth connection to use.

  Parameter resourceUrls

  The list of resource URLs to retrieve tokens for.

  Parameter oAuthAppCredentials

  AppCredentials for OAuth.

  Returns

  A map of the [TokenResponse](xref:botframework-schema.TokenResponse) objects by resource URL.

method getActivityMembers

getActivityMembers: (
    context: TurnContext,
    activityId?: string
) => Promise<ChannelAccount[]>;

• Asynchronously lists the members of a given activity.

  Parameter context

  The context object for the turn.

  Parameter activityId

  Optional. The ID of the activity to get the members of. If not specified, the current activity ID is used.

  Returns

  An array of [ChannelAccount](xref:botframework-schema.ChannelAccount) objects for the users involved in a given activity.

  Remarks

  Returns an array of [ChannelAccount](xref:botframework-schema.ChannelAccount) objects for the users involved in a given activity.

  This is different from [getConversationMembers](xref:botbuilder.BotFrameworkAdapter.getConversationMembers) in that it will return only those users directly involved in the activity, not all members of the conversation.

method getConversationMembers

getConversationMembers: (context: TurnContext) => Promise<ChannelAccount[]>;

• Asynchronously lists the members of the current conversation.

  Parameter context

  The context object for the turn.

  Returns

  An array of [ChannelAccount](xref:botframework-schema.ChannelAccount) objects for all users currently involved in a conversation.

  Remarks

  Returns an array of [ChannelAccount](xref:botframework-schema.ChannelAccount) objects for all users currently involved in a conversation.

  This is different from [getActivityMembers](xref:botbuilder.BotFrameworkAdapter.getActivityMembers) in that it will return all members of the conversation, not just those directly involved in a specific activity.

method getConversations

getConversations: (
    contextOrServiceUrl: TurnContext | string,
    continuationToken?: string
) => Promise<ConversationsResult>;

• For the specified channel, asynchronously gets a page of the conversations in which this bot has participated.

  Parameter contextOrServiceUrl

  The URL of the channel server to query or a [TurnContext](xref:botbuilder-core.TurnContext) object from a conversation on the channel.

  Parameter continuationToken

  Optional. The continuation token from the previous page of results. Omit this parameter or use undefined to retrieve the first page of results.

  Returns

  A [ConversationsResult](xref:botframework-schema.ConversationsResult) object containing a page of results and a continuation token.

  Remarks

  The the return value's [conversations](xref:botframework-schema.ConversationsResult.conversations) property contains a page of [ConversationMembers](xref:botframework-schema.ConversationMembers) objects. Each object's [id](xref:botframework-schema.ConversationMembers.id) is the ID of a conversation in which the bot has participated on this channel. This method can be called from outside the context of a conversation, as only the bot's service URL and credentials are required.

  The channel batches results in pages. If the result's [continuationToken](xref:botframework-schema.ConversationsResult.continuationToken) property is not empty, then there are more pages to get. Use the returned token to get the next page of results. If the contextOrServiceUrl parameter is a [TurnContext](xref:botbuilder-core.TurnContext), the URL of the channel server is retrieved from contextOrServiceUrl.[activity](xref:botbuilder-core.TurnContext.activity).[serviceUrl](xref:botframework-schema.Activity.serviceUrl).

method getSignInLink

getSignInLink: {
    (
        context: TurnContext,
        connectionName: string,
        oAuthAppCredentials?: AppCredentials,
        userId?: string,
        finalRedirect?: string
    ): Promise<string>;
    (
        context: TurnContext,
        connectionName: string,
        oAuthAppCredentials?: CoreAppCredentials,
        userId?: string,
        finalRedirect?: string
    ): Promise<string>;
};

• Asynchronously gets a sign-in link from the token server that can be sent as part of a [SigninCard](xref:botframework-schema.SigninCard).

  Parameter context

  The context object for the turn.

  Parameter connectionName

  The name of the auth connection to use.

  Parameter oAuthAppCredentials

  AppCredentials for OAuth.

  Parameter userId

  The user id that will be associated with the token.

  Parameter finalRedirect

  The final URL that the OAuth flow will redirect to.

method getSignInResource

getSignInResource: (
    context: TurnContext,
    connectionName: string,
    userId?: string,
    finalRedirect?: string,
    appCredentials?: CoreAppCredentials
) => Promise<SignInUrlResponse>;

• Asynchronously Get the raw signin resource to be sent to the user for signin.

  Parameter context

  The context object for the turn.

  Parameter connectionName

  The name of the auth connection to use.

  Parameter userId

  The user id that will be associated with the token.

  Parameter finalRedirect

  The final URL that the OAuth flow will redirect to.

  Parameter appCredentials

  Optional. The CoreAppCredentials for OAuth.

  Returns

  The [BotSignInGetSignInResourceResponse](xref:botframework-connector.BotSignInGetSignInResourceResponse) object.

method getTokenStatus

getTokenStatus: {
    (context: TurnContext, userId?: string, includeFilter?: string): Promise<
        TokenStatus[]
    >;
    (
        context: TurnContext,
        userId?: string,
        includeFilter?: string,
        oAuthAppCredentials?: CoreAppCredentials
    ): Promise<TokenStatus[]>;
};

• Asynchronously retrieves the token status for each configured connection for the given user.

  Parameter context

  The context object for the turn.

  Parameter userId

  Optional. If present, the ID of the user to retrieve the token status for. Otherwise, the ID of the user who sent the current activity is used.

  Parameter includeFilter

  Optional. A comma-separated list of connection's to include. If present, the includeFilter parameter limits the tokens this method returns.

  Parameter oAuthAppCredentials

  AppCredentials for OAuth.

  Returns

  The [TokenStatus](xref:botframework-connector.TokenStatus) objects retrieved.

method getUserToken

getUserToken: {
    (
        context: TurnContext,
        connectionName: string,
        magicCode?: string
    ): Promise<TokenResponse>;
    (
        context: TurnContext,
        connectionName: string,
        magicCode?: string,
        oAuthAppCredentials?: CoreAppCredentials
    ): Promise<TokenResponse>;
};

• Asynchronously attempts to retrieve the token for a user that's in a login flow.

  Parameter context

  The context object for the turn.

  Parameter connectionName

  The name of the auth connection to use.

  Parameter magicCode

  Optional. The validation code the user entered.

  Parameter oAuthAppCredentials

  AppCredentials for OAuth.

  Returns

  A [TokenResponse](xref:botframework-schema.TokenResponse) object that contains the user token.

method oauthApiUrl

protected oauthApiUrl: (contextOrServiceUrl: TurnContext | string) => string;

• Gets the OAuth API endpoint.

  Parameter contextOrServiceUrl

  The URL of the channel server to query or a [TurnContext](xref:botbuilder-core.TurnContext). For a turn context, the context's [activity](xref:botbuilder-core.TurnContext.activity).[serviceUrl](xref:botframework-schema.Activity.serviceUrl) is used for the URL.

  Returns

  The endpoint used for the API requests.

  Remarks

  Override this in a derived class to create a mock OAuth API endpoint for unit testing.

method process

process: {
    (
        req: Request,
        res: Response,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
    (
        req: Request<Record<string, unknown>, Record<string, string | string[]>>,
        socket: INodeSocket,
        head: INodeBuffer,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
};

• Process a web request by applying a logic function.

  Parameter req

  An incoming HTTP [Request](xref:botbuilder.Request)

  Parameter res

  The corresponding HTTP [Response](xref:botbuilder.Response)

  Parameter logic

  The logic function to apply

  Returns

  a promise representing the asynchronous operation.

• Handle a web socket connection by applying a logic function to each streaming request.

  Parameter req

  An incoming HTTP [Request](xref:botbuilder.Request)

  Parameter socket

  The corresponding [INodeSocket](xref:botframework-streaming.INodeSocket)

  Parameter head

  The corresponding [INodeBuffer](xref:botframework-streaming.INodeBuffer)

  Parameter logic

  The logic function to apply

  Returns

  a promise representing the asynchronous operation.

method processActivity

processActivity: (
    req: WebRequest,
    res: WebResponse,
    logic: (context: TurnContext) => Promise<any>
) => Promise<void>;

• Asynchronously creates a turn context and runs the middleware pipeline for an incoming activity.

  Parameter req

  An Express or Restify style request object.

  Parameter res

  An Express or Restify style response object.

  Parameter logic

  The function to call at the end of the middleware pipeline.

  Remarks

  This is the main way a bot receives incoming messages and defines a turn in the conversation. This method:

  1. Parses and authenticates an incoming request. - The activity is read from the body of the incoming request. An error will be returned if the activity can't be parsed. - The identity of the sender is authenticated as either the Emulator or a valid Microsoft server, using the bot's appId and appPassword. The request is rejected if the sender's identity is not verified. 1. Creates a [TurnContext](xref:botbuilder-core.TurnContext) object for the received activity. - This object is wrapped with a [revocable proxy](https://www.ecma-international.org/ecma-262/6.0/#sec-proxy.revocable). - When this method completes, the proxy is revoked. 1. Sends the turn context through the adapter's middleware pipeline. 1. Sends the turn context to the logic function. - The bot may perform additional routing or processing at this time. Returning a promise (or providing an async handler) will cause the adapter to wait for any asynchronous operations to complete. - After the logic function completes, the promise chain set up by the middleware is resolved.

  > [!TIP] > If you see the error TypeError: Cannot perform 'set' on a proxy that has been revoked > in your bot's console output, the likely cause is that an async function was used > without using the await keyword. Make sure all async functions use await!

  Middleware can _short circuit_ a turn. When this happens, subsequent middleware and the logic function is not called; however, all middleware prior to this point still run to completion. For more information about the middleware pipeline, see the [how bots work](https://docs.microsoft.com/azure/bot-service/bot-builder-basics) and [middleware](https://docs.microsoft.com/azure/bot-service/bot-builder-concept-middleware) articles. Use the adapter's [use](xref:botbuilder-core.BotAdapter.use) method to add middleware to the adapter.

  For example:

  server.post('/api/messages', (req, res) => {
     // Route received request to adapter for processing
     adapter.processActivity(req, res, async (context) => {
         // Process any messages received
         if (context.activity.type === ActivityTypes.Message) {
             await context.sendActivity(`Hello World`);
         }
     });
  });

method processActivityDirect

processActivityDirect: (
    activity: Activity,
    logic: (context: TurnContext) => Promise<any>
) => Promise<void>;

• Asynchronously creates a turn context and runs the middleware pipeline for an incoming activity.

  Use [CloudAdapter.processActivityDirect] instead.

  Parameter activity

  The activity to process.

  Parameter logic

  The function to call at the end of the middleware pipeline.

  Remarks

  This is the main way a bot receives incoming messages and defines a turn in the conversation. This method:

  1. Creates a [TurnContext](xref:botbuilder-core.TurnContext) object for the received activity. - This object is wrapped with a [revocable proxy](https://www.ecma-international.org/ecma-262/6.0/#sec-proxy.revocable). - When this method completes, the proxy is revoked. 1. Sends the turn context through the adapter's middleware pipeline. 1. Sends the turn context to the logic function. - The bot may perform additional routing or processing at this time. Returning a promise (or providing an async handler) will cause the adapter to wait for any asynchronous operations to complete. - After the logic function completes, the promise chain set up by the middleware is resolved.

  Middleware can _short circuit_ a turn. When this happens, subsequent middleware and the logic function is not called; however, all middleware prior to this point still run to completion. For more information about the middleware pipeline, see the [how bots work](https://docs.microsoft.com/azure/bot-service/bot-builder-basics) and [middleware](https://docs.microsoft.com/azure/bot-service/bot-builder-concept-middleware) articles. Use the adapter's [use](xref:botbuilder-core.BotAdapter.use) method to add middleware to the adapter.

method processRequest

processRequest: (request: IReceiveRequest) => Promise<StreamingResponse>;

• Checks the validity of the request and attempts to map it the correct virtual endpoint, then generates and returns a response if appropriate.

  Parameter request

  A ReceiveRequest from the connected channel.

  Returns

  A response created by the BotAdapter to be sent to the client that originated the request.

method sendActivities

sendActivities: (
    context: TurnContext,
    activities: Partial<Activity>[]
) => Promise<ResourceResponse[]>;

• Asynchronously sends a set of outgoing activities to a channel server.

  This method supports the framework and is not intended to be called directly for your code. Use the turn context's [sendActivity](xref:botbuilder-core.TurnContext.sendActivity) or [sendActivities](xref:botbuilder-core.TurnContext.sendActivities) method from your bot code.

  Parameter context

  The context object for the turn.

  Parameter activities

  The activities to send.

  Returns

  An array of [ResourceResponse](xref:)

  Remarks

  The activities will be sent one after another in the order in which they're received. A response object will be returned for each sent activity. For message activities this will contain the ID of the delivered message.

method signOutUser

signOutUser: {
    (
        context: TurnContext,
        connectionName?: string,
        userId?: string
    ): Promise<void>;
    (
        context: TurnContext,
        connectionName?: string,
        userId?: string,
        oAuthAppCredentials?: CoreAppCredentials
    ): Promise<void>;
};

• Asynchronously signs out the user from the token server.

  Parameter context

  The context object for the turn.

  Parameter connectionName

  The name of the auth connection to use.

  Parameter userId

  The ID of user to sign out.

  Parameter oAuthAppCredentials

  AppCredentials for OAuth.

method updateActivity

updateActivity: (
    context: TurnContext,
    activity: Activity
) => Promise<ResourceResponse | void>;

• Asynchronously replaces a previous activity with an updated version.

  This interface supports the framework and is not intended to be called directly for your code. Use [TurnContext.updateActivity](xref:botbuilder-core.TurnContext.updateActivity) to update an activity from your bot code.

  Parameter context

  The context object for the turn.

  Parameter activity

  The updated version of the activity to replace.

  Returns

  A Promise representing the [ResourceResponse](xref:botframework-schema.ResourceResponse) for the operation.

  Remarks

  Not all channels support this operation. For channels that don't, this call may throw an exception.

method useNamedPipe

useNamedPipe: (
    logic: (context: TurnContext) => Promise<any>,
    pipeName?: string,
    retryCount?: number,
    onListen?: () => void
) => Promise<void>;

• Connects the handler to a Named Pipe server and begins listening for incoming requests.

  Parameter logic

  The logic that will handle incoming requests.

  Parameter pipeName

  The name of the named pipe to use when creating the server.

  Parameter retryCount

  Number of times to attempt to bind incoming and outgoing pipe

  Parameter onListen

  Optional callback that fires once when server is listening on both incoming and outgoing pipe

method useWebSocket

useWebSocket: (
    req: WebRequest,
    socket: INodeSocket,
    head: INodeBuffer,
    logic: (context: TurnContext) => Promise<any>
) => Promise<void>;

• Process the initial request to establish a long lived connection via a streaming server.

  Parameter req

  The connection request.

  Parameter socket

  The raw socket connection between the bot (server) and channel/caller (client).

  Parameter head

  The first packet of the upgraded stream.

  Parameter logic

  The logic that handles incoming streaming requests for the lifetime of the WebSocket connection.

constructor

constructor(credentialProvider: ICredentialProvider, channelService?: string);

• Creates a new instance of the [BotFrameworkHttpClient](xref:botbuilder.BotFrameworkHttpClient) class

  Parameter credentialProvider

  An instance of [ICredentialProvider](xref:botframework-connector.ICredentialProvider).

  Parameter channelService

  Optional. The channel service.

property channelService

protected readonly channelService: string;

method buildCredentials

protected buildCredentials: (
    appId: string,
    oAuthScope?: string
) => Promise<AppCredentials>;

• Logic to build an [AppCredentials](xref:botframework-connector.AppCredentials) to be used to acquire tokens for this HttpClient.

  Parameter appId

  The application id.

  Parameter oAuthScope

  Optional. The OAuth scope.

  Returns

  The app credentials to be used to acquire tokens.

method postActivity

postActivity: <T = any>(
    fromBotId: string,
    toBotId: string,
    toUrl: string,
    serviceUrl: string,
    conversationId: string,
    activity: Activity
) => Promise<InvokeResponse<T>>;

• Forwards an activity to another bot.

  Parameter fromBotId

  The MicrosoftAppId of the bot sending the activity.

  Parameter toBotId

  The MicrosoftAppId of the bot receiving the activity.

  Parameter toUrl

  The URL of the bot receiving the activity.

  Parameter serviceUrl

  The callback Url for the skill host.

  Parameter conversationId

  A conversation ID to use for the conversation with the skill.

  Parameter activity

  Activity to forward.

  Returns

  {Promise<InvokeResponse>} A promise representing the asynchronous operation.

  Remarks

  T The type of body in the InvokeResponse.

constructor

constructor(
    credentialProvider: ICredentialProvider,
    authConfig: AuthenticationConfiguration,
    channelService?: string
);

• Initializes a new instance of the ChannelServiceHandler class, using a credential provider.

  Parameter credentialProvider

  The credential provider.

  Parameter authConfig

  The authentication configuration.

  Parameter channelService

  A string representing the channel provider.

property channelService

protected readonly channelService: string;

method authenticate

protected authenticate: (authHeader: string) => Promise<ClaimsIdentity>;

method authenticate

protected abstract authenticate: (authHeader: string) => Promise<ClaimsIdentity>;

• Helper to authenticate the header token and extract the claims.

  Parameter authHeader

  HTTP authorization header

  Returns

  a promise resolving to the authorization header claims

method handleCreateConversation

handleCreateConversation: (
    authHeader: string,
    parameters: ConversationParameters
) => Promise<ConversationResourceResponse>;

• Creates a new Conversation.

  Parameter authHeader

  The authentication header.

  Parameter parameters

  [ConversationParameters](xref:botbuilder-core.ConversationParameters) to create the conversation from.

  Returns

  A Promise representation for the operation.

method handleDeleteActivity

handleDeleteActivity: (
    authHeader: string,
    conversationId: string,
    activityId: string
) => Promise<void>;

• Deletes an existing [Activity](xref:botframework-schema.Activity).

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter activityId

  The activity Id to delete.

method handleDeleteConversationMember

handleDeleteConversationMember: (
    authHeader: string,
    conversationId: string,
    memberId: string
) => Promise<void>;

• Deletes a member from a conversation.

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter memberId

  Id of the member to delete from this conversation.

method handleGetActivityMembers

handleGetActivityMembers: (
    authHeader: string,
    conversationId: string,
    activityId: string
) => Promise<ChannelAccount[]>;

• Enumerates the members of an [Activity](xref:botframework-schema.Activity).

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter activityId

  The activity Id.

  Returns

  The enumerated [ChannelAccount](xref:botframework-schema.ChannelAccount) list.

method handleGetConversationMember

handleGetConversationMember: (
    authHeader: string,
    userId: string,
    conversationId: string
) => Promise<ChannelAccount>;

• Gets the account of a single conversation member.

  Parameter authHeader

  The authentication header.

  Parameter userId

  The user Id.

  Parameter conversationId

  The conversation Id.

  Returns

  The [ChannelAccount](xref:botframework-schema.ChannelAccount) for the provided user id.

method handleGetConversationMembers

handleGetConversationMembers: (
    authHeader: string,
    conversationId: string
) => Promise<ChannelAccount[]>;

• Enumerates the members of a conversation.

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Returns

  The enumerated [ChannelAccount](xref:botframework-schema.ChannelAccount) list.

method handleGetConversationPagedMembers

handleGetConversationPagedMembers: (
    authHeader: string,
    conversationId: string,
    pageSize?: number,
    continuationToken?: string
) => Promise<PagedMembersResult>;

• Enumerates the members of a conversation one page at a time.

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter pageSize

  Suggested page size.

  Parameter continuationToken

  A continuation token.

  Returns

  A Promise representing the [PagedMembersResult](xref:botframework-schema.PagedMembersResult) for the operation.

method handleGetConversations

handleGetConversations: (
    authHeader: string,
    conversationId: string,
    continuationToken?: string
) => Promise<ConversationsResult>;

• Lists the Conversations in which the bot has participated.

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter continuationToken

  A skip or continuation token.

  Returns

  A Promise representation for the operation.

method handleReplyToActivity

handleReplyToActivity: (
    authHeader: string,
    conversationId: string,
    activityId: string,
    activity: Activity
) => Promise<ResourceResponse>;

• Sends a reply to an [Activity](xref:botframework-schema.Activity).

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter activityId

  The activity Id the reply is to.

  Parameter activity

  The [Activity](xref:botframework-schema.Activity) to send.

  Returns

  A Promise representing the [ResourceResponse](xref:botframework-schema.ResourceResponse) for the operation.

method handleSendConversationHistory

handleSendConversationHistory: (
    authHeader: string,
    conversationId: string,
    transcript: Transcript
) => Promise<ResourceResponse>;

• Uploads the historic activities of the conversation.

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter transcript

  [Transcript](xref:botframework-schema.Transcript) of activities.

  Returns

  A Promise representing the [ResourceResponse](xref:botframework-schema.ResourceResponse) for the operation.

method handleSendToConversation

handleSendToConversation: (
    authHeader: string,
    conversationId: string,
    activity: Activity
) => Promise<ResourceResponse>;

• Sends an [Activity](xref:botframework-schema.Activity) to the end of a conversation.

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter activity

  The [Activity](xref:botframework-schema.Activity) to send.

  Returns

  A Promise representing the [ResourceResponse](xref:botframework-schema.ResourceResponse) for the operation.

method handleUpdateActivity

handleUpdateActivity: (
    authHeader: string,
    conversationId: string,
    activityId: string,
    activity: Activity
) => Promise<ResourceResponse>;

• Edits a previously sent existing [Activity](xref:botframework-schema.Activity).

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter activityId

  The activity Id to update.

  Parameter activity

  The replacement [Activity](xref:botframework-schema.Activity).

  Returns

  A Promise representing the [ResourceResponse](xref:botframework-schema.ResourceResponse) for the operation.

method handleUploadAttachment

handleUploadAttachment: (
    authHeader: string,
    conversationId: string,
    attachmentUpload: AttachmentData
) => Promise<ResourceResponse>;

• Stores data in a compliant store when dealing with enterprises.

  Parameter authHeader

  The authentication header.

  Parameter conversationId

  The conversation Id.

  Parameter attachmentUpload

  [AttachmentData](xref:botframework-schema.AttachmentData).

  Returns

  A Promise representing the [ResourceResponse](xref:botframework-schema.ResourceResponse) for the operation.

method onCreateConversation

protected onCreateConversation: (
    _claimsIdentity: ClaimsIdentity,
    _parameters: ConversationParameters
) => Promise<ConversationResourceResponse>;

• CreateConversation() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _parameters

  Parameters to create the conversation from.

  Remarks

  Create a new Conversation.

  POST to this method with a * Bot being the bot creating the conversation * IsGroup set to true if this is not a direct message (default is false) * Array containing the members to include in the conversation

  The return value is a ResourceResponse which contains a conversation id which is suitable for use in the message payload and REST API uris.

  Most channels only support the semantics of bots initiating a direct message conversation.

method onDeleteActivity

protected onDeleteActivity: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _activityId: string
) => Promise<void>;

• DeleteActivity() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _activityId

  activityId to delete.

  Remarks

  Delete an existing activity.

  Some channels allow you to delete an existing activity, and if successful this method will remove the specified activity.

method onDeleteConversationMember

protected onDeleteConversationMember: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _memberId: string
) => Promise<void>;

• DeleteConversationMember() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _memberId

  ID of the member to delete from this conversation.

  Remarks

  Deletes a member from a conversation.

  This REST API takes a ConversationId and a memberId (of type string) and removes that member from the conversation. If that member was the last member of the conversation, the conversation will also be deleted.

method onGetActivityMembers

protected onGetActivityMembers: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _activityId: string
) => Promise<ChannelAccount[]>;

• GetActivityMembers() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _activityId

  Activity ID.

  Remarks

  Enumerate the members of an activity.

  This REST API takes a ConversationId and a ActivityId, returning an array of ChannelAccount objects representing the members of the particular activity in the conversation.

method onGetConversationMember

protected onGetConversationMember: (
    _claimsIdentity: ClaimsIdentity,
    _userId: string,
    _conversationId: string
) => Promise<ChannelAccount>;

• getConversationMember() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _userId

  User ID.

  Parameter _conversationId

  Conversation ID.

  Remarks

  Get the account of a single conversation member.

  This REST API takes a ConversationId and UserId and returns the ChannelAccount object representing the member of the conversation.

method onGetConversationMembers

protected onGetConversationMembers: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string
) => Promise<ChannelAccount[]>;

• getConversationMembers() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Remarks

  Enumerate the members of a conversation.

  This REST API takes a ConversationId and returns an array of ChannelAccount objects representing the members of the conversation.

method onGetConversationPagedMembers

protected onGetConversationPagedMembers: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _pageSize?: number,
    _continuationToken?: string
) => Promise<PagedMembersResult>;

• getConversationPagedMembers() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _pageSize

  Suggested page size.

  Parameter _continuationToken

  Continuation Token.

  Remarks

  Enumerate the members of a conversation one page at a time.

  This REST API takes a ConversationId. Optionally a pageSize and/or continuationToken can be provided. It returns a PagedMembersResult, which contains an array of ChannelAccounts representing the members of the conversation and a continuation token that can be used to get more values.

  One page of ChannelAccounts records are returned with each call. The number of records in a page may vary between channels and calls. The pageSize parameter can be used as a suggestion. If there are no additional results the response will not contain a continuation token. If there are no members in the conversation the Members will be empty or not present in the response.

  A response to a request that has a continuation token from a prior request may rarely return members from a previous request.

method onGetConversations

protected onGetConversations: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _continuationToken?: string
) => Promise<ConversationsResult>;

• onGetConversations() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _continuationToken

  Skip or continuation token.

  Remarks

  List the Conversations in which this bot has participated.

  GET from this method with a skip token

  The return value is a ConversationsResult, which contains an array of ConversationMembers and a skip token. If the skip token is not empty, then there are further values to be returned. Call this method again with the returned token to get more values.

  Each ConversationMembers object contains the ID of the conversation and an array of ChannelAccounts that describe the members of the conversation.

method onReplyToActivity

protected onReplyToActivity: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _activityId: string,
    _activity: Activity
) => Promise<ResourceResponse>;

• ReplyToActivity() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _activityId

  activityId the reply is to (OPTIONAL).

  Parameter _activity

  Activity to send.

  Remarks

  This method allows you to reply to an activity.

  This is slightly different from SendToConversation(). * SendToConversation(conversationId) - will append the activity to the end of the conversation according to the timestamp or semantics of the channel. * ReplyToActivity(conversationId,ActivityId) - adds the activity as a reply to another activity, if the channel supports it. If the channel does not support nested replies, ReplyToActivity falls back to SendToConversation.

  Use ReplyToActivity when replying to a specific activity in the conversation.

  Use SendToConversation in all other cases.

method onSendConversationHistory

protected onSendConversationHistory: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _transcript: Transcript
) => Promise<ResourceResponse>;

• SendConversationHistory() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _transcript

  Transcript of activities.

  Remarks

  This method allows you to upload the historic activities to the conversation.

  Sender must ensure that the historic activities have unique ids and appropriate timestamps. The ids are used by the client to deal with duplicate activities and the timestamps are used by the client to render the activities in the right order.

method onSendToConversation

protected onSendToConversation: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _activity: Activity
) => Promise<ResourceResponse>;

• SendToConversation() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation identifier

  Parameter _activity

  Activity to send

  Remarks

  This method allows you to send an activity to the end of a conversation. This is slightly different from ReplyToActivity(). * SendToConversation(conversationId) - will append the activity to the end of the conversation according to the timestamp or semantics of the channel. * ReplyToActivity(conversationId,ActivityId) - adds the activity as a reply to another activity, if the channel supports it. If the channel does not support nested replies, ReplyToActivity falls back to SendToConversation.

  Use ReplyToActivity when replying to a specific activity in the conversation.

  Use SendToConversation in all other cases.

method onUpdateActivity

protected onUpdateActivity: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _activityId: string,
    _activity: Activity
) => Promise<ResourceResponse>;

• UpdateActivity() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _activityId

  activityId to update.

  Parameter _activity

  replacement Activity.

  Remarks

  Edit an existing activity.

  Some channels allow you to edit an existing activity to reflect the new state of a bot conversation.

  For example, you can remove buttons after someone has clicked "Approve" button.

method onUploadAttachment

protected onUploadAttachment: (
    _claimsIdentity: ClaimsIdentity,
    _conversationId: string,
    _attachmentUpload: AttachmentData
) => Promise<ResourceResponse>;

• UploadAttachment() API for Skill.

  Parameter _claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter _conversationId

  Conversation ID.

  Parameter _attachmentUpload

  Attachment data.

  Remarks

  Upload an attachment directly into a channel's blob storage.

  This is useful because it allows you to store data in a compliant store when dealing with enterprises.

  The response is a ResourceResponse which contains an AttachmentId which is suitable for using with the attachments API.

constructor

constructor(channelServiceHandler: ChannelServiceHandlerBase);

• Parameter channelServiceHandler

  The channel service handler.

method register

register: (server: WebServer, basePath?: string) => void;

• Registers all Channel Service paths on the provided WebServer.

  Parameter server

  WebServer

  Parameter basePath

  Optional basePath which is appended before the service's REST API is configured on the WebServer.

constructor

constructor(botFrameworkAuthentication?: BotFrameworkAuthentication);

• Initializes a new instance of the [CloudAdapter](xref:botbuilder:CloudAdapter) class.

  Parameter botFrameworkAuthentication

  Optional [BotFrameworkAuthentication](xref:botframework-connector.BotFrameworkAuthentication) instance

method connectNamedPipe

connectNamedPipe: (
    pipeName: string,
    logic: (context: TurnContext) => Promise<void>,
    appId: string,
    audience: string,
    callerId?: string,
    retryCount?: number
) => Promise<void>;

• Used to connect the adapter to a named pipe.

  Parameter pipeName

  Pipe name to connect to (note: yields two named pipe servers by appending ".incoming" and ".outgoing" to this name)

  Parameter logic

  The logic function to call for resulting bot turns.

  Parameter appId

  The Bot application ID

  Parameter audience

  The audience to use for outbound communication. The will vary by cloud environment.

  Parameter callerId

  Optional, the caller ID

  Parameter retryCount

  Optional, the number of times to retry a failed connection (defaults to 7)

method process

process: {
    (
        req: Request,
        res: Response,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
    (
        req: Request<Record<string, unknown>, Record<string, string | string[]>>,
        socket: INodeSocket,
        head: INodeBuffer,
        logic: (context: TurnContext) => Promise<void>
    ): Promise<void>;
};

• Process a web request by applying a logic function.

  Parameter req

  An incoming HTTP [Request](xref:botbuilder.Request)

  Parameter req

  The corresponding HTTP [Response](xref:botbuilder.Response)

  Parameter logic

  The logic function to apply

  Returns

  a promise representing the asynchronous operation.

• Handle a web socket connection by applying a logic function to each streaming request.

  Parameter req

  An incoming HTTP [Request](xref:botbuilder.Request)

  Parameter socket

  The corresponding [INodeSocket](xref:botframework-streaming.INodeSocket)

  Parameter head

  The corresponding [INodeBuffer](xref:botframework-streaming.INodeBuffer)

  Parameter logic

  The logic function to apply

  Returns

  a promise representing the asynchronous operation.

method processActivityDirect

processActivityDirect: (
    authorization: string | AuthenticateRequestResult,
    activity: Activity,
    logic: (context: TurnContext) => Promise<void>
) => Promise<void>;

• Asynchronously process an activity running the provided logic function.

  Parameter authorization

  The authorization header in the format: "Bearer [longString]" or the AuthenticateRequestResult for this turn.

  Parameter activity

  The activity to process.

  Parameter logic

  The logic function to apply.

  Returns

  a promise representing the asynchronous operation.

constructor

constructor(
    adapter: BotAdapter,
    logic: (context: TurnContext) => Promise<void>,
    conversationIdFactory: SkillConversationIdFactoryBase,
    auth: BotFrameworkAuthentication
);

• Initializes a new instance of the CloudSkillHandler class.

  Parameter adapter

  An instance of the BotAdapter that will handle the request.

  Parameter logic

  The Bot logic function

  Parameter conversationIdFactory

  A SkillConversationIdFactoryBase to unpack the conversation ID and map it to the calling bot.

  Parameter auth

  Bot Framework Authentication to use

property SkillConversationReferenceKey

readonly SkillConversationReferenceKey: Symbol;

• Used to access the CovnersationReference sent from the Skill to the Parent.

method onDeleteActivity

protected onDeleteActivity: (
    claimsIdentity: ClaimsIdentity,
    conversationId: string,
    activityId: string
) => Promise<void>;

• DeleteActivity() API for Skill.

  Parameter claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter conversationId

  Conversation ID.

  Parameter activityId

  activityId to delete.

  Returns

  a promise representing the async operation

  Remarks

  Delete an existing activity.

  Some channels allow you to delete an existing activity, and if successful this method will remove the specified activity.

method onGetConversationMember

protected onGetConversationMember: (
    claimsIdentity: ClaimsIdentity,
    userId: string,
    conversationId: string
) => Promise<ChannelAccount>;

• getConversationMember() API for Skill.

  Parameter claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter userId

  User ID.

  Parameter conversationId

  Conversation ID.

  Returns

  The ChannelAccount object representing the member of the conversation.

  Remarks

  Get the account of a single conversation member.

  This REST API takes a ConversationId and UserId and returns the ChannelAccount object representing the member of the conversation.

method onReplyToActivity

protected onReplyToActivity: (
    claimsIdentity: ClaimsIdentity,
    conversationId: string,
    activityId: string,
    activity: Activity
) => Promise<ResourceResponse>;

• replyToActivity() API for Skill.

  Parameter claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter conversationId

  Conversation ID.

  Parameter activityId

  activityId the reply is to.

  Parameter activity

  Activity to send.

  Returns

  A Promise with a ResourceResponse.

  Remarks

  This method allows you to reply to an activity.

  This is slightly different from sendToConversation(). * sendToConversation(conversationId) - will append the activity to the end of the conversation according to the timestamp or semantics of the channel. * replyToActivity(conversationId,ActivityId) - adds the activity as a reply to another activity, if the channel supports it. If the channel does not support nested replies, replyToActivity falls back to sendToConversation.

  Use replyToActivity when replying to a specific activity in the conversation.

  Use sendToConversation in all other cases.

method onSendToConversation

protected onSendToConversation: (
    claimsIdentity: ClaimsIdentity,
    conversationId: string,
    activity: Activity
) => Promise<ResourceResponse>;

• sendToConversation() API for Skill.

  Parameter claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter conversationId

  Conversation ID.

  Parameter activity

  Activity to send.

  Returns

  A Promise with a ResourceResponse.

  Remarks

  This method allows you to send an activity to the end of a conversation.

  This is slightly different from replyToActivity(). * sendToConversation(conversationId) - will append the activity to the end of the conversation according to the timestamp or semantics of the channel. * replyToActivity(conversationId,ActivityId) - adds the activity as a reply to another activity, if the channel supports it. If the channel does not support nested replies, replyToActivity falls back to sendToConversation.

  Use replyToActivity when replying to a specific activity in the conversation.

  Use sendToConversation in all other cases.

method onUpdateActivity

protected onUpdateActivity: (
    claimsIdentity: ClaimsIdentity,
    conversationId: string,
    activityId: string,
    activity: Activity
) => Promise<ResourceResponse>;

• UpdateActivity() API for Skill.

  Parameter claimsIdentity

  ClaimsIdentity for the bot, should have AudienceClaim, AppIdClaim and ServiceUrlClaim.

  Parameter conversationId

  Conversation ID.

  Parameter activityId

  activityId to update.

  Parameter activity

  replacement Activity.

  Returns

  a promise resolving to the underlying resource response

  Remarks

  Edit an existing activity.

  Some channels allow you to edit an existing activity to reflect the new state of a bot conversation.

  For example, you can remove buttons after someone has clicked "Approve" button.

method createHandoffInitiation

static createHandoffInitiation: <T = unknown>(
    context: TurnContext,
    handoffContext: T,
    transcript?: Transcript
) => Activity;

• Create handoff initiation event.

  Parameter context

  The context object for the turn.

  Parameter handoffContext

  Agent hub-specific context.

  Parameter transcript

  Transcript of the conversation.

  Returns

  The handoff event activity.

method createHandoffStatus

static createHandoffStatus: (
    conversation: ConversationAccount,
    state: string,
    message?: string
) => Activity;

• Create handoff status event.

  Parameter conversation

  Conversation being handed over.

  Parameter state

  State, possible values are: "accepted", "failed", "completed".

  Parameter message

  Additional message for failed handoff.

  Returns

  The handoff event activity.

constructor

constructor(folder: string);

• Creates an instance of FileTranscriptStore.

  Parameter folder

  Root folder where transcript will be stored.

method deleteTranscript

deleteTranscript: (channelId: string, conversationId: string) => Promise<void>;

• Delete a conversation and all of it's activities.

  Parameter channelId

  Channel Id where conversation took place.

  Parameter conversationId

  Id of the conversation to delete.

  Returns

  {Promise} A promise representing the asynchronous operation.

method getTranscriptActivities

getTranscriptActivities: (
    channelId: string,
    conversationId: string,
    continuationToken?: string,
    startDate?: Date
) => Promise<PagedResult<Activity>>;

• Get all activities associated with a conversation id (aka get the transcript).

  Parameter channelId

  Channel Id.

  Parameter conversationId

  Conversation Id.

  Parameter continuationToken

  (Optional) Continuation token to page through results.

  Parameter startDate

  (Optional) Earliest time to include.

  Returns

  {Promise<PagedResult>} PagedResult of activities.

method listTranscripts

listTranscripts: (
    channelId: string,
    continuationToken?: string
) => Promise<PagedResult<TranscriptInfo>>;

• List all the logged conversations for a given channelId.

  Parameter channelId

  Channel Id.

  Parameter continuationToken

  (Optional) Continuation token to page through results.

  Returns

  {Promise<PagedResult>} PagedResult of transcripts.

method logActivity

logActivity: (activity: Activity) => Promise<void>;

• Log an activity to the transcript.

  Parameter activity

  Activity being logged.

  Returns

  {Promise} a promise representing the asynchronous operation.

property HandoffStatus

static readonly HandoffStatus: string;

property InitiateHandoff

static readonly InitiateHandoff: string;

constructor

constructor(
    inspectionState: InspectionState,
    userState?: UserState,
    conversationState?: ConversationState,
    credentials?: MicrosoftAppCredentials
);

• Create the Inspection middleware for sending trace activities out to an emulator session

  Parameter inspectionState

  A state management object for inspection state.

  Parameter userState

  A state management object for user state.

  Parameter conversationState

  A state management object for conversation state.

  Parameter credentials

  The authentication credentials.

method inbound

protected inbound: (
    turnContext: TurnContext,
    traceActivity: Activity
) => Promise<any>;

• Processes inbound activities.

  Parameter turnContext

  The [TurnContext](xref:botbuilder-core.TurnContext) for this turn.

  Parameter traceActivity

  The trace activity.

  Returns

  {Promise} A promise representing the asynchronous operation.

method outbound

protected outbound: (
    turnContext: TurnContext,
    traceActivities: Partial<Activity>[]
) => Promise<any>;

• Processes outbound activities.

  Parameter turnContext

  The [TurnContext](xref:botbuilder-core.TurnContext) for this turn.

  Parameter traceActivities

  A collection of trace activities.

method processCommand

processCommand: (turnContext: TurnContext) => Promise<any>;

• Indentifies open and attach commands and calls the appropriate method.

  Parameter turnContext

  The [TurnContext](xref:botbuilder-core.TurnContext) for this turn.

  Returns

  True if the command is open or attached, otherwise false.

method traceState

protected traceState: (turnContext: TurnContext) => Promise<any>;

• Processes the state management object.

  Parameter turnContext

  The [TurnContext](xref:botbuilder-core.TurnContext) for this turn.

constructor

constructor(storage: Storage);