@microsoft/agents-hosting 0.4.1 → 0.5.1-g2e246ff274

package/src/app/adaptiveCards/adaptiveCardsActions.ts

@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Activity, ActivityTypes } from '@microsoft/agents-activity'
+import { AdaptiveCardInvokeResponse, AgentApplication, CardFactory, INVOKE_RESPONSE_KEY, InvokeResponse, MessageFactory, RouteSelector, TurnContext, TurnState } from '../../'
+import { AdaptiveCardActionExecuteResponseType } from './adaptiveCardActionExecuteResponseType'
+import { parseAdaptiveCardInvokeAction, parseValueActionExecuteSelector, parseValueDataset, parseValueSearchQuery } from './activityValueParsers'
+import { AdaptiveCardsSearchParams } from './adaptiveCardsSearchParams'
+import { AdaptiveCard } from '../../cards/adaptiveCard'
+import { Query } from './query'
+
+export const ACTION_INVOKE_NAME = 'adaptiveCard/action'
+const ACTION_EXECUTE_TYPE = 'Action.Execute'
+const DEFAULT_ACTION_SUBMIT_FILTER = 'verb'
+const SEARCH_INVOKE_NAME = 'application/search'
+
+enum AdaptiveCardInvokeResponseType {
+  /**
+   * Indicates a response containing an Adaptive Card.
+   */
+  ADAPTIVE = 'application/vnd.microsoft.card.adaptive',
+
+  /**
+   * Indicates a response containing a message activity.
+   */
+  MESSAGE = 'application/vnd.microsoft.activity.message',
+
+  /**
+   * Indicates a response containing a search result.
+   */
+  SEARCH = 'application/vnd.microsoft.search.searchResponse'
+}
+
+export interface AdaptiveCardSearchResult {
+  /**
+   * The title of the search result.
+   */
+  title: string;
+
+  /**
+   * The value associated with the search result.
+   */
+  value: string;
+}
+
+/**
+ * A class to handle Adaptive Card actions such as executing actions, submitting actions, and performing searches.
+ * @template TState - The type of the TurnState used in the application.
+ */
+export class AdaptiveCardsActions<TState extends TurnState> {
+  /**
+   * The Teams application instance associated with this class.
+   */
+  private readonly _app: AgentApplication<TState>
+
+  /**
+   * Constructs an instance of AdaptiveCardsActions.
+   * @param app - The Teams application instance.
+   */
+  public constructor (app: AgentApplication<TState>) {
+    this._app = app
+  }
+
+  /**
+   * Registers a handler for the Action.Execute event.
+   * @template TData - The type of the data passed to the handler.
+   * @param verb - A string, RegExp, RouteSelector, or an array of these to match the action verb.
+   * @param handler - A function to handle the action execution.
+   * @returns The Teams application instance.
+   */
+  public actionExecute<TData = Record<string, any>>(
+    verb: string | RegExp | RouteSelector | (string | RegExp | RouteSelector)[],
+    handler: (context: TurnContext, state: TState, data: TData) => Promise<AdaptiveCard | string>
+  ): AgentApplication<TState> {
+    let actionExecuteResponseType = this._app.options.adaptiveCardsOptions?.actionExecuteResponseType ?? AdaptiveCardActionExecuteResponseType.REPLACE_FOR_INTERACTOR;
+    (Array.isArray(verb) ? verb : [verb]).forEach((v) => {
+      const selector = createActionExecuteSelector(v)
+      this._app.addRoute(
+        selector,
+        async (context, state) => {
+          const a = context?.activity
+          const invokeAction = parseValueActionExecuteSelector(a.value)
+          if (
+            a?.type !== ActivityTypes.Invoke ||
+                        a?.name !== ACTION_INVOKE_NAME ||
+                        (invokeAction?.action.type !== ACTION_EXECUTE_TYPE)
+          ) {
+            throw new Error(`Unexpected AdaptiveCards.actionExecute() triggered for activity type: ${invokeAction?.action.type}`
+            )
+          }
+
+          if (invokeAction.action.verb !== v) {
+            // TODO: add logger to this class
+            console.log(`AdaptiveCards.actionExecute() triggered for verb: ${invokeAction.action.verb} does not match expected verb: ${v}`)
+          }
+
+          // TODO: review any, and check verb
+          const result = await handler(context, state, ((a.value as any).action as TData) ?? {} as TData)
+          if (!context.turnState.get(INVOKE_RESPONSE_KEY)) {
+            let response: AdaptiveCardInvokeResponse
+            if (typeof result === 'string') {
+              response = {
+                statusCode: 200,
+                type: AdaptiveCardInvokeResponseType.MESSAGE,
+                value: result as any
+              }
+              await sendInvokeResponse(context, response)
+            } else {
+              if (
+                result.refresh &&
+                                actionExecuteResponseType !== AdaptiveCardActionExecuteResponseType.NEW_MESSAGE_FOR_ALL
+              ) {
+                actionExecuteResponseType = AdaptiveCardActionExecuteResponseType.REPLACE_FOR_ALL
+              }
+
+              const activity = MessageFactory.attachment(CardFactory.adaptiveCard(result))
+              response = {
+                statusCode: 200,
+                type: AdaptiveCardInvokeResponseType.ADAPTIVE,
+                value: result
+              }
+              if (
+                actionExecuteResponseType === AdaptiveCardActionExecuteResponseType.NEW_MESSAGE_FOR_ALL
+              ) {
+                await sendInvokeResponse(context, {
+                  statusCode: 200,
+                  type: AdaptiveCardInvokeResponseType.MESSAGE,
+                  value: 'Your response was sent to the app' as any
+                })
+                await context.sendActivity(activity)
+              } else if (
+                actionExecuteResponseType === AdaptiveCardActionExecuteResponseType.REPLACE_FOR_ALL
+              ) {
+                activity.id = context.activity.replyToId
+                await context.updateActivity(activity)
+                await sendInvokeResponse(context, response)
+              } else {
+                await sendInvokeResponse(context, response)
+              }
+            }
+          }
+        },
+        true
+      )
+    })
+    return this._app
+  }
+
+  /**
+   * Registers a handler for the Action.Submit event.
+   * @template TData - The type of the data passed to the handler.
+   * @param verb - A string, RegExp, RouteSelector, or an array of these to match the action verb.
+   * @param handler - A function to handle the action submission.
+   * @returns The Teams application instance.
+   */
+  public actionSubmit<TData = Record<string, any>>(
+    verb: string | RegExp | RouteSelector | (string | RegExp | RouteSelector)[],
+    handler: (context: TurnContext, state: TState, data: TData) => Promise<void>
+  ): AgentApplication<TState> {
+    const filter = this._app.options.adaptiveCardsOptions?.actionSubmitFilter ?? DEFAULT_ACTION_SUBMIT_FILTER;
+    (Array.isArray(verb) ? verb : [verb]).forEach((v) => {
+      const selector = createActionSubmitSelector(v, filter)
+      this._app.addRoute(selector, async (context, state) => {
+        const a = context?.activity
+        if (a?.type !== ActivityTypes.Message || a?.text || typeof a?.value !== 'object') {
+          throw new Error(`Unexpected AdaptiveCards.actionSubmit() triggered for activity type: ${a?.type}`)
+        }
+
+        await handler(context, state as TState, (parseAdaptiveCardInvokeAction(a.value)) as TData ?? {} as TData)
+      })
+    })
+    return this._app
+  }
+
+  /**
+   * Registers a handler for the search event.
+   * @param dataset - A string, RegExp, RouteSelector, or an array of these to match the dataset.
+   * @param handler - A function to handle the search query.
+   * @returns The Teams application instance.
+   */
+  public search (
+    dataset: string | RegExp | RouteSelector | (string | RegExp | RouteSelector)[],
+    handler: (
+      context: TurnContext,
+      state: TState,
+      query: Query<AdaptiveCardsSearchParams>
+    ) => Promise<AdaptiveCardSearchResult[]>
+  ): AgentApplication<TState> {
+    (Array.isArray(dataset) ? dataset : [dataset]).forEach((ds) => {
+      const selector = createSearchSelector(ds)
+      this._app.addRoute(
+        selector,
+        async (context, state) => {
+          const a = context?.activity
+          if (a?.type !== 'invoke' || a?.name !== SEARCH_INVOKE_NAME) {
+            throw new Error(`Unexpected AdaptiveCards.search() triggered for activity type: ${a?.type}`)
+          }
+
+          const parsedQuery = parseValueSearchQuery(a.value)
+          const query: Query<AdaptiveCardsSearchParams> = {
+            count: parsedQuery.queryOptions?.top ?? 25,
+            skip: parsedQuery.queryOptions?.skip ?? 0,
+
+            parameters: {
+              queryText: parsedQuery.queryText ?? '',
+              dataset: parsedQuery.dataset ?? ''
+
+            }
+          }
+
+          const results = await handler(context, state, query)
+          if (!context.turnState.get(INVOKE_RESPONSE_KEY)) {
+            const response = {
+              type: AdaptiveCardInvokeResponseType.SEARCH,
+              value: {
+                results
+              }
+            }
+
+            await context.sendActivity({
+              value: { body: response, status: 200 } as InvokeResponse,
+              type: ActivityTypes.InvokeResponse
+            } as Activity)
+          }
+        },
+        true
+      )
+    })
+    return this._app
+  }
+}
+
+function createActionExecuteSelector (verb: string | RegExp | RouteSelector): RouteSelector {
+  if (typeof verb === 'function') {
+    return verb
+  } else if (verb instanceof RegExp) {
+    return (context: TurnContext) => {
+      const a = context?.activity
+      const valueAction = parseValueActionExecuteSelector(a.value)
+      const isInvoke =
+                a?.type === ActivityTypes.Invoke &&
+                a?.name === ACTION_INVOKE_NAME &&
+                valueAction?.action?.type === ACTION_EXECUTE_TYPE
+      if (isInvoke && typeof valueAction.action.verb === 'string') {
+        return Promise.resolve(verb.test(valueAction.action.verb))
+      } else {
+        return Promise.resolve(false)
+      }
+    }
+  } else {
+    return (context: TurnContext) => {
+      const a = context?.activity
+      const valueAction = parseValueActionExecuteSelector(a.value)
+      const isInvoke =
+                a?.type === ActivityTypes.Invoke &&
+                a?.name === ACTION_INVOKE_NAME &&
+                valueAction?.action?.type === ACTION_EXECUTE_TYPE
+      if (isInvoke && valueAction.action?.verb === verb) {
+        return Promise.resolve(true)
+      } else {
+        return Promise.resolve(false)
+      }
+    }
+  }
+}
+
+function createActionSubmitSelector (verb: string | RegExp | RouteSelector, filter: string): RouteSelector {
+  if (typeof verb === 'function') {
+    return verb
+  } else if (verb instanceof RegExp) {
+    return (context: TurnContext) => {
+      const a = context?.activity
+      const isSubmit = a?.type === ActivityTypes.Message && !a?.text && typeof a?.value === 'object'
+      if (isSubmit && typeof (a?.value as any)[filter] === 'string') {
+        return Promise.resolve(verb.test((a.value as any)[filter]))
+      } else {
+        return Promise.resolve(false)
+      }
+    }
+  } else {
+    return (context: TurnContext) => {
+      const a = context?.activity
+      const isSubmit = a?.type === ActivityTypes.Message && !a?.text && typeof a?.value === 'object'
+      return Promise.resolve(isSubmit && (a?.value as any)[filter] === verb)
+    }
+  }
+}
+
+function createSearchSelector (dataset: string | RegExp | RouteSelector): RouteSelector {
+  if (typeof dataset === 'function') {
+    return dataset
+  } else if (dataset instanceof RegExp) {
+    return (context: TurnContext) => {
+      const a = context?.activity
+      const valueDataset = parseValueDataset(a.value)
+      const isSearch = a?.type === ActivityTypes.Invoke && a?.name === SEARCH_INVOKE_NAME
+      if (isSearch && typeof valueDataset?.dataset === 'string') {
+        return Promise.resolve(dataset.test(valueDataset?.dataset))
+      } else {
+        return Promise.resolve(false)
+      }
+    }
+  } else {
+    return (context: TurnContext) => {
+      const a = context?.activity
+      // const valueDataset = parseAdaptiveCardInvokeAction(a.value)
+      const isSearch = a?.type === ActivityTypes.Invoke && a?.name === SEARCH_INVOKE_NAME
+      return Promise.resolve(isSearch)
+    }
+  }
+}
+
+async function sendInvokeResponse (context: TurnContext, response: AdaptiveCardInvokeResponse) {
+  await context.sendActivity({
+    value: { body: response, status: 200 } as InvokeResponse,
+    type: ActivityTypes.InvokeResponse
+  } as Activity)
+}

package/src/app/adaptiveCards/adaptiveCardsOptions.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AdaptiveCardActionExecuteResponseType } from './adaptiveCardActionExecuteResponseType'
+
+/**
+ * Configuration options for Adaptive Cards.
+ */
+export interface AdaptiveCardsOptions {
+  /**
+   * Specifies the filter key used for Action.Submit events.
+   * If not provided, a default filter key will be used.
+   */
+  actionSubmitFilter?: string;
+
+  /**
+   * Specifies the response type for Action.Execute events.
+   * Determines how the response is handled after an action is executed.
+   */
+  actionExecuteResponseType?: AdaptiveCardActionExecuteResponseType;
+}

package/src/app/adaptiveCards/adaptiveCardsSearchParams.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { z } from 'zod'
+
+/**
+ * Interface representing the search parameters for adaptive cards.
+ */
+export interface AdaptiveCardsSearchParams {
+  /**
+   * The text query for the search.
+   */
+  queryText: string;
+  /**
+   * The dataset to search within.
+   */
+  dataset: string;
+}
+
+/**
+ * Zod schema for validating AdaptiveCardsSearchParams.
+ */
+export const adaptiveCardsSearchParamsZodSchema = z.object({
+  queryText: z.string(),
+  dataset: z.string(),
+})

package/src/app/adaptiveCards/index.ts

@@ -0,0 +1,3 @@
+export * from './adaptiveCardsActions'
+export * from './adaptiveCardsOptions'
+export * from './adaptiveCardActionExecuteResponseType'

package/src/app/adaptiveCards/query.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Represents a query with pagination and parameters.
+ * @template TParams - The type of the query parameters.
+ */
+export interface Query<TParams extends Record<string, any>> {
+  /**
+   * The number of items to retrieve.
+   */
+  count: number;
+
+  /**
+   * The number of items to skip.
+   */
+  skip: number;
+
+  /**
+   * The parameters for the query.
+   */
+  parameters: TParams;
+}

package/src/app/agentApplication.ts

@@ -4,18 +4,20 @@
  */
 
 import { Activity, ActivityTypes, ConversationReference } from '@microsoft/agents-activity'
-import { TurnState } from './turnState'
 import { BaseAdapter } from '../baseAdapter'
-import { AgentApplicationOptions } from './agentApplicationOptions'
-import { RouteSelector } from './routeSelector'
-import { RouteHandler } from './routeHandler'
-import { ConversationUpdateEvents } from './conversationUpdateEvents'
-import { TurnEvents } from './turnEvents'
-import { AppRoute } from './appRoute'
-import { TurnContext } from '../turnContext'
 import { ResourceResponse } from '../connector-client'
 import { debug } from '../logger'
+import { TurnContext } from '../turnContext'
+import { AdaptiveCardsActions } from './adaptiveCards'
+import { AgentApplicationOptions } from './agentApplicationOptions'
+import { AppRoute } from './appRoute'
+import { ConversationUpdateEvents } from './conversationUpdateEvents'
+import { AgentExtension } from './extensions'
 import { Authorization } from './oauth/authorization'
+import { RouteHandler } from './routeHandler'
+import { RouteSelector } from './routeSelector'
+import { TurnEvents } from './turnEvents'
+import { TurnState } from './turnState'
 
 const logger = debug('agents:agent-application')
 
@@ -46,16 +48,21 @@ export class AgentApplication<TState extends TurnState> {
   protected readonly _afterTurn: ApplicationEventHandler<TState>[] = []
   private readonly _adapter?: BaseAdapter
   private readonly _authorization?: Authorization
-  private _typingTimer: any
+  private _typingTimer: NodeJS.Timeout | undefined
+  protected readonly _extensions: AgentExtension<TState>[] = []
+  private readonly _adaptiveCards: AdaptiveCardsActions<TState>
 
   public constructor (options?: Partial<AgentApplicationOptions<TState>>) {
     this._options = {
       ...options,
       turnStateFactory: options?.turnStateFactory || (() => new TurnState() as TState),
       startTypingTimer: options?.startTypingTimer !== undefined ? options.startTypingTimer : false,
-      longRunningMessages: options?.longRunningMessages !== undefined ? options.longRunningMessages : false
+      longRunningMessages: options?.longRunningMessages !== undefined ? options.longRunningMessages : false,
+      removeRecipientMention: options?.removeRecipientMention !== undefined ? options.removeRecipientMention : true,
     }
 
+    this._adaptiveCards = new AdaptiveCardsActions<TState>(this)
+
     if (this._options.adapter) {
       this._adapter = this._options.adapter
     }
@@ -65,9 +72,7 @@ export class AgentApplication<TState extends TurnState> {
     }
 
     if (this._options.longRunningMessages && !this._adapter && !this._options.agentAppId) {
-      throw new Error(
-        'The Application.longRunningMessages property is unavailable because no adapter or agentAppId was configured.'
-      )
+      throw new Error('The Application.longRunningMessages property is unavailable because no adapter was configured in the app.')
     }
   }
 
@@ -76,13 +81,7 @@ export class AgentApplication<TState extends TurnState> {
    * @throws Error if the adapter is not configured.
    */
   public get adapter (): BaseAdapter {
-    if (!this._adapter) {
-      throw new Error(
-        'The Application.adapter property is unavailable because it was not configured when creating the Application.'
-      )
-    }
-
-    return this._adapter
+    return this._adapter!
   }
 
   /**
@@ -91,11 +90,8 @@ export class AgentApplication<TState extends TurnState> {
    */
   public get authorization (): Authorization {
     if (!this._authorization) {
-      throw new Error(
-        'The Application.authorization property is unavailable because no authentication options were configured.'
-      )
+      throw new Error('The Application.authorization property is unavailable because no authorization options were configured.')
     }
-
     return this._authorization
   }
 
@@ -107,6 +103,10 @@ export class AgentApplication<TState extends TurnState> {
     return this._options
   }
 
+  public get adaptiveCards (): AdaptiveCardsActions<TState> {
+    return this._adaptiveCards
+  }
+
   /**
    * Sets an error handler for the application.
    *
@@ -129,7 +129,6 @@ export class AgentApplication<TState extends TurnState> {
     if (this._adapter) {
       this._adapter.onTurnError = handler
     }
-
     return this
   }
 
@@ -153,8 +152,8 @@ export class AgentApplication<TState extends TurnState> {
    * );
    * ```
    */
-  public addRoute (selector: RouteSelector, handler: RouteHandler<TState>): this {
-    this._routes.push({ selector, handler })
+  public addRoute (selector: RouteSelector, handler: RouteHandler<TState>, isInvokeRoute: boolean = false): this {
+    this._routes.push({ selector, handler, isInvokeRoute })
     return this
   }
 
@@ -316,12 +315,74 @@ export class AgentApplication<TState extends TurnState> {
       this.authorization.onSignInSuccess(handler)
     } else {
       throw new Error(
-        'The Application.authentication property is unavailable because no authentication options were configured.'
+        'The Application.authorization property is unavailable because no authorization options were configured.'
       )
     }
     return this
   }
 
+  /**
+   * Adds a handler for message reaction added events.
+   *
+   * @param handler - The handler function that will be called when a message reaction is added.
+   * @returns The current instance of the application.
+   *
+   * @remarks
+   * This method registers a handler that will be invoked when a user adds a reaction to a message,
+   * such as a like, heart, or other emoji reaction.
+   *
+   * Example usage:
+   * ```typescript
+   * app.onMessageReactionAdded(async (context, state) => {
+   *   const reactionsAdded = context.activity.reactionsAdded;
+   *   if (reactionsAdded && reactionsAdded.length > 0) {
+   *     await context.sendActivity(`Thanks for your ${reactionsAdded[0].type} reaction!`);
+   *   }
+   * });
+   * ```
+   */
+  public onMessageReactionAdded (handler: (context: TurnContext, state: TState) => Promise<void>): this {
+    const selector = async (context: TurnContext): Promise<boolean> => {
+      return context.activity.type === ActivityTypes.MessageReaction &&
+             Array.isArray(context.activity.reactionsAdded) &&
+             context.activity.reactionsAdded.length > 0
+    }
+
+    this.addRoute(selector, handler)
+    return this
+  }
+
+  /**
+   * Adds a handler for message reaction removed events.
+   *
+   * @param handler - The handler function that will be called when a message reaction is removed.
+   * @returns The current instance of the application.
+   *
+   * @remarks
+   * This method registers a handler that will be invoked when a user removes a reaction from a message,
+   * such as unliking or removing an emoji reaction.
+   *
+   * Example usage:
+   * ```typescript
+   * app.onMessageReactionRemoved(async (context, state) => {
+   *   const reactionsRemoved = context.activity.reactionsRemoved;
+   *   if (reactionsRemoved && reactionsRemoved.length > 0) {
+   *     await context.sendActivity(`You removed your ${reactionsRemoved[0].type} reaction.`);
+   *   }
+   * });
+   * ```
+   */
+  public onMessageReactionRemoved (handler: (context: TurnContext, state: TState) => Promise<void>): this {
+    const selector = async (context: TurnContext): Promise<boolean> => {
+      return context.activity.type === ActivityTypes.MessageReaction &&
+             Array.isArray(context.activity.reactionsRemoved) &&
+             context.activity.reactionsRemoved.length > 0
+    }
+
+    this.addRoute(selector, handler)
+    return this
+  }
+
   /**
    * Executes the application logic for a given turn context.
    *
@@ -355,8 +416,19 @@ export class AgentApplication<TState extends TurnState> {
    */
   public async runInternal (turnContext: TurnContext): Promise<boolean> {
     return await this.startLongRunningCall(turnContext, async (context) => {
-      this.startTypingTimer(context)
       try {
+        if (this._options.startTypingTimer) {
+          this.startTypingTimer(context)
+        }
+
+        if (this._options.removeRecipientMention && context.activity.type === ActivityTypes.Message) {
+          context.activity.removeRecipientMention()
+        }
+
+        if (this._options.normalizeMentions && context.activity.type === ActivityTypes.Message) {
+          context.activity.normalizeMentions()
+        }
+
         const { storage, turnStateFactory } = this._options
         const state = turnStateFactory()
         await state.load(context, storage)
@@ -497,6 +569,14 @@ export class AgentApplication<TState extends TurnState> {
     }
   }
 
+  public registerExtension<T extends AgentExtension<TState>> (extension: T, regcb : (ext:T) => void): void {
+    if (this._extensions.includes(extension)) {
+      throw new Error('Extension already registered')
+    }
+    this._extensions.push(extension)
+    regcb(extension)
+  }
+
   /**
    * Stops the typing indicator timer if it's currently running.
    *

package/src/app/agentApplicationBuilder.ts

@@ -3,11 +3,11 @@
  * Licensed under the MIT License.
  */
 
+import { Storage } from '../storage'
 import { AgentApplication } from './agentApplication'
 import { AgentApplicationOptions } from './agentApplicationOptions'
-import { TurnState } from './turnState'
-import { Storage } from '../storage'
 import { AuthorizationHandlers } from './oauth/authorization'
+import { TurnState } from './turnState'
 
 /**
  * Builder class for creating and configuring AgentApplication instances.

package/src/app/agentApplicationOptions.ts

@@ -4,10 +4,11 @@
  */
 
 import { CloudAdapter } from '../cloudAdapter'
-import { InputFileDownloader } from './inputFileDownloader'
-import { TurnState } from './turnState'
 import { Storage } from '../storage'
+import { AdaptiveCardsOptions } from './adaptiveCards'
+import { InputFileDownloader } from './inputFileDownloader'
 import { AuthorizationHandlers } from './oauth/authorization'
+import { TurnState } from './turnState'
 
 export interface AgentApplicationOptions<TState extends TurnState> {
   /**
@@ -49,4 +50,21 @@ export interface AgentApplicationOptions<TState extends TurnState> {
    * Handlers for managing authorization.
    */
   authorization?: AuthorizationHandlers;
+
+  /**
+   * Options for AdaptiveCard actions.
+   */
+  adaptiveCardsOptions?: AdaptiveCardsOptions;
+
+  /**
+   * Optional. If true, the agent will automatically remove mentions of the bot's name from incoming
+   * messages. Defaults to true.
+   */
+  removeRecipientMention?: boolean;
+
+  /**
+   * Optional. If true, the agent will automatically normalize mentions in incoming messages. Defaults to
+   * true.
+   */
+  normalizeMentions?: boolean
 }