@microsoft/agents-hosting 0.1.49 → 0.2.7-gd7a3e9ef95

package/src/app/agentApplication.ts

@@ -3,10 +3,10 @@
  * Licensed under the MIT License.
  */
 
+import { Activity, ActivityTypes, ConversationReference } from '@microsoft/agents-activity'
 import { TurnState } from './turnState'
 import { BaseAdapter } from '../baseAdapter'
-import { Activity, ActivityTypes, ConversationReference } from '@microsoft/agents-activity'
-import { ApplicationOptions } from './applicationOptions'
+import { AgentApplicationOptions } from './agentApplicationOptions'
 import { RouteSelector } from './routeSelector'
 import { RouteHandler } from './routeHandler'
 import { ConversationUpdateEvents } from './conversationUpdateEvents'
@@ -15,7 +15,7 @@ import { AppRoute } from './appRoute'
 import { TurnContext } from '../turnContext'
 import { ResourceResponse } from '../connector-client'
 import { debug } from '../logger'
-import { WebChatOAuthFlowAppStyle } from './oauth/webChatOAuthFlowAppStyle'
+import { UserIdentity } from './oauth/userIdentity'
 import { MemoryStorage } from '../storage'
 
 const logger = debug('agents:agent-application')
@@ -24,15 +24,15 @@ const TYPING_TIMER_DELAY = 1000
 type ApplicationEventHandler<TState extends TurnState> = (context: TurnContext, state: TState) => Promise<boolean>
 
 export class AgentApplication<TState extends TurnState> {
-  protected readonly _options: ApplicationOptions<TState>
+  protected readonly _options: AgentApplicationOptions<TState>
   protected readonly _routes: AppRoute<TState>[] = []
   protected readonly _beforeTurn: ApplicationEventHandler<TState>[] = []
   protected readonly _afterTurn: ApplicationEventHandler<TState>[] = []
   private readonly _adapter?: BaseAdapter
   private _typingTimer: any
-  private readonly _authManager?: WebChatOAuthFlowAppStyle
+  private readonly _userIdentity?: UserIdentity
 
-  public constructor (options?: Partial<ApplicationOptions<TState>>) {
+  public constructor (options?: Partial<AgentApplicationOptions<TState>>) {
     this._options = {
       ...options,
       turnStateFactory: options?.turnStateFactory || (() => new TurnState() as TState),
@@ -44,8 +44,8 @@ export class AgentApplication<TState extends TurnState> {
       this._adapter = this._options.adapter
     }
 
-    if (this._options.authentication && this._options.authentication.enableSSO) {
-      this._authManager = new WebChatOAuthFlowAppStyle(this._options.storage ?? new MemoryStorage())
+    if (this._options.authentication && this._options.authentication.enableSSO && this._options.authentication.ssoConnectionName) {
+      this._userIdentity = new UserIdentity(this._options.storage ?? new MemoryStorage(), this._options.authentication.ssoConnectionName)
     }
 
     if (this._options.longRunningMessages && !this._adapter && !this._options.agentAppId) {
@@ -65,17 +65,17 @@ export class AgentApplication<TState extends TurnState> {
     return this._adapter
   }
 
-  public get authManager (): WebChatOAuthFlowAppStyle {
-    if (!this._authManager) {
+  public get userIdentity (): UserIdentity {
+    if (!this._userIdentity) {
       throw new Error(
         'The Application.authentication property is unavailable because no authentication options were configured.'
       )
     }
 
-    return this._authManager
+    return this._userIdentity
   }
 
-  public get options (): ApplicationOptions<TState> {
+  public get options (): AgentApplicationOptions<TState> {
     return this._options
   }
 
@@ -129,9 +129,7 @@ export class AgentApplication<TState extends TurnState> {
     }
 
     if (!this.options.agentAppId) {
-      console.warn(
-        "Calling Application.continueConversationAsync() without a configured 'agentAppId'. In production environments, a 'agentAppId' is required."
-      )
+      logger.warn("Calling Application.continueConversationAsync() without a configured 'agentAppId'. In production environments, a 'agentAppId' is required.")
     }
 
     let reference: ConversationReference
@@ -156,6 +154,17 @@ export class AgentApplication<TState extends TurnState> {
     return this
   }
 
+  public onSignInSuccess (handler: (context: TurnContext, state: TurnState) => void): this {
+    if (this._userIdentity) {
+      this._userIdentity.onSignInSuccess(handler)
+    } else {
+      throw new Error(
+        'The Application.authentication property is unavailable because no authentication options were configured.'
+      )
+    }
+    return this
+  }
+
   public async run (turnContext: TurnContext): Promise<boolean> {
     return await this.startLongRunningCall(turnContext, async (context) => {
       this.startTypingTimer(context)

package/src/app/{applicationBuilder.ts → agentApplicationBuilder.ts}

@@ -4,13 +4,13 @@
  */
 
 import { AgentApplication } from './agentApplication'
-import { ApplicationOptions } from './applicationOptions'
+import { AgentApplicationOptions } from './agentApplicationOptions'
 import { TurnState } from './turnState'
 import { Storage } from '../storage'
-import { AuthenticationOptions } from './oauth/authenticationOptions'
+import { UserIdentityOptions } from './oauth/userIdentity'
 
-export class ApplicationBuilder<TState extends TurnState = TurnState> {
-  protected _options: Partial<ApplicationOptions<TState>> = {}
+export class AgentApplicationBuilder<TState extends TurnState = TurnState> {
+  protected _options: Partial<AgentApplicationOptions<TState>> = {}
 
   protected get options () {
     return this._options
@@ -31,7 +31,7 @@ export class ApplicationBuilder<TState extends TurnState = TurnState> {
     return this
   }
 
-  public withAuthentication (authenticationOptions: AuthenticationOptions): this {
+  public withAuthentication (authenticationOptions: UserIdentityOptions): this {
     this._options.authentication = authenticationOptions
     return this
   }

package/src/app/{applicationOptions.ts → agentApplicationOptions.ts}

@@ -7,9 +7,9 @@ import { CloudAdapter } from '../cloudAdapter'
 import { InputFileDownloader } from './inputFileDownloader'
 import { TurnState } from './turnState'
 import { Storage } from '../storage'
-import { AuthenticationOptions } from './oauth/authenticationOptions'
+import { UserIdentityOptions } from './oauth/userIdentity'
 
-export interface ApplicationOptions<TState extends TurnState> {
+export interface AgentApplicationOptions<TState extends TurnState> {
   adapter?: CloudAdapter;
   agentAppId?: string;
   storage?: Storage;
@@ -17,5 +17,5 @@ export interface ApplicationOptions<TState extends TurnState> {
   longRunningMessages: boolean;
   turnStateFactory: () => TState;
   fileDownloaders?: InputFileDownloader<TState>[];
-  authentication?: AuthenticationOptions;
+  authentication?: UserIdentityOptions;
 }

package/src/app/index.ts

@@ -1,10 +1,11 @@
 export * from './agentApplication'
-export * from './applicationBuilder'
-export * from './applicationOptions'
+export * from './agentApplicationBuilder'
+export * from './agentApplicationOptions'
 export * from './appRoute'
 export * from './attachmentDownloader'
-export * from './oauth/webChatOAuthFlowAppStyle'
+export * from './oauth/userIdentity'
 export * from './conversationUpdateEvents'
 export * from './routeHandler'
 export * from './routeSelector'
 export * from './turnState'
+export * from './inputFileDownloader'

package/src/app/oauth/userIdentity.ts

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { TurnContext } from '../../turnContext'
+// import { debug } from '../../logger'
+import { TurnState } from '../turnState'
+import { Storage } from '../../storage'
+import { OAuthFlow, TokenRequestStatus, TokenResponse } from '../../oauth'
+import { UserState } from '../../state'
+
+// const logger = debug('agents:user-identity')
+
+/**
+ * Options for configuring user identity.
+ * Contains settings related to Single Sign-On (SSO) authentication.
+ */
+export interface UserIdentityOptions {
+  /**
+   * Determines whether Single Sign-On (SSO) is enabled for user authentication.
+   */
+  enableSSO: boolean;
+
+  /**
+   * The name of the SSO connection to use when SSO is enabled.
+   * Only applicable when enableSSO is set to true.
+   */
+  ssoConnectionName?: string;
+}
+
+export class UserIdentity {
+  oAuthFlow: OAuthFlow
+
+  /**
+   * Creates a new instance of UserAuthorization.
+   * @param {Storage} storage - The storage system to use for state management.
+   */
+  constructor (storage: Storage, connectionName: string) {
+    const userState = new UserState(storage)
+    this.oAuthFlow = new OAuthFlow(userState, connectionName)
+  }
+
+  public async getToken (context: TurnContext): Promise<TokenResponse> {
+    return await this.oAuthFlow.getUserToken(context)
+  }
+
+  public async authenticate (context: TurnContext, state: TurnState) : Promise<TokenResponse> {
+    let tokenResponse: TokenResponse
+    if (this.oAuthFlow.state?.flowStarted === false) {
+      tokenResponse = await this.oAuthFlow.beginFlow(context)
+    } else {
+      tokenResponse = await this.oAuthFlow.continueFlow(context)
+      if (tokenResponse.status === TokenRequestStatus.Success) {
+        if (this._signInHandler) {
+          await this._signInHandler(context, state)
+        }
+      }
+    }
+    return tokenResponse
+  }
+
+  /**
+   * Signs out the current user.
+   * This method clears the user's token and resets the SSO state.
+   *
+   * @param {TurnContext} context - The context object for the current turn.
+   * @param {TurnState} state - The state object for the current turn.
+   */
+  async signOut (context: TurnContext, state: TurnState) {
+    await this.oAuthFlow.signOut(context)
+  }
+
+  _signInHandler: ((context: TurnContext, state: TurnState) => void) | null = null
+  public onSignInSuccess (handler: (context: TurnContext, state: TurnState) => void) {
+    this._signInHandler = handler
+  }
+}

package/src/app/turnState.ts

@@ -198,8 +198,8 @@ export class TurnState<
     scope.value[name] = value
   }
 
-  public load (context: TurnContext, storage?: Storage): Promise<boolean> {
-    if (this._isLoaded) {
+  public load (context: TurnContext, storage?: Storage, force: boolean = false): Promise<boolean> {
+    if (this._isLoaded && !force) {
       return Promise.resolve(false)
     }
 

package/src/app/turnStateProperty.ts

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { TurnContext } from '../turnContext'
+import { StatePropertyAccessor } from '../state'
+import { TurnStateEntry } from './turnStateEntry'
+import { TurnState } from './turnState'
+
+/**
+ * Maps an application's Turn State property to a State property.
+ * @template T Optional. Type of the property being mapped. Defaults to any.
+ */
+export class TurnStateProperty<T = any> implements StatePropertyAccessor<T> {
+  private readonly _state: TurnStateEntry
+  private readonly _propertyName: string
+
+  /**
+     * Creates a new instance of the `TurnStateProperty` class.
+     * @param {TurnState} state Current application turn state.
+     * @param {string} scopeName Name of properties the memory scope to use.
+     * @param {string} propertyName Name of the property to use.
+     */
+  public constructor (state: TurnState, scopeName: string, propertyName: string) {
+    this._propertyName = propertyName
+
+    const scope = state.getScope(scopeName)
+    if (!scope) {
+      throw new Error(`TurnStateProperty: TurnState missing state scope named "${scope}".`)
+    }
+
+    this._state = scope
+    if (!this._state) {
+      throw new Error(`TurnStateProperty: TurnState missing state scope named "${scope}".`)
+    }
+  }
+
+  /**
+     * Deletes the state property.
+     * @returns {Promise<void>} A promise that represents the work queued to execute.
+     */
+  public delete (): Promise<void> {
+    this._state.value[this._propertyName] = undefined
+    return Promise.resolve()
+  }
+
+  /**
+     * Returns the state property value.
+     */
+  public get (context: TurnContext): Promise<T | undefined>
+  public get (context: TurnContext, defaultValue: T): Promise<T>
+  public get (defaultValue?: unknown): Promise<T | undefined> | Promise<T> {
+    if (this._state.value[this._propertyName] === undefined) {
+      this._state.value[this._propertyName] = defaultValue
+    }
+
+    return Promise.resolve(this._state.value[this._propertyName] as T)
+  }
+
+  /**
+     * Replace's the state property value.
+     * @template T
+     * @param {TurnContext} context The context object for the turn.
+     * @param {T} value The value to assign to the state property.
+     * @returns {Promise<void>} A promise that represents the work queued to execute.
+     */
+  public set (context: TurnContext, value: T): Promise<void> {
+    this._state.value[this._propertyName] = value
+    return Promise.resolve()
+  }
+}

package/src/auth/authConfiguration.ts

@@ -19,6 +19,20 @@ export interface AuthConfiguration {
 
 /**
  * Loads the authentication configuration from environment variables.
+ * ```
+ * tenantId=your-tenant-id
+ * clientId=your-client-id
+ * clientSecret=your-client-secret
+ *
+ * certPemFile=your-cert-pem-file
+ * certKeyFile=your-cert-key-file
+ *
+ * FICClientId=your-FIC-client-id
+ *
+ * connectionName=your-connection-name
+ * ```
+ * @remarks
+ * - `clientId` is required
  * @returns The authentication configuration.
  * @throws Will throw an error if clientId is not provided in production.
  */
@@ -43,11 +57,16 @@ export const loadAuthConfigFromEnv: () => AuthConfiguration = () => {
 }
 
 /**
- * Loads the agent authentication configuration from environment variables.
+ * Loads the agent authentication configuration from previous version environment variables.
+ * ```
+ * MicrosoftAppId=your-client-id
+ * MicrosoftAppPassword=your-client-secret
+ * MicrosoftAppTenantId=your-tenant-id
+ * ```
  * @returns The agent authentication configuration.
  * @throws Will throw an error if MicrosoftAppId is not provided in production.
  */
-export const loadBotAuthConfigFromEnv: () => AuthConfiguration = () => {
+export const loadPrevAuthConfigFromEnv: () => AuthConfiguration = () => {
   if (process.env.MicrosoftAppId === undefined && process.env.NODE_ENV === 'production') {
     throw new Error('ClientId required in production')
   }
@@ -61,8 +80,8 @@ export const loadBotAuthConfigFromEnv: () => AuthConfiguration = () => {
     FICClientId: process.env.MicrosoftAppClientId,
     issuers: [
       'https://api.botframework.com',
-        `https://sts.windows.net/${process.env.MicrosoftAppTenantId}/`,
-        `https://login.microsoftonline.com/${process.env.MicrosoftAppTenantId}/v2.0`
+      `https://sts.windows.net/${process.env.MicrosoftAppTenantId}/`,
+      `https://login.microsoftonline.com/${process.env.MicrosoftAppTenantId}/v2.0`
     ]
   }
 }

package/src/auth/jwt-middleware.ts

@@ -46,7 +46,8 @@ const verifyToken = async (raw: string, config: AuthConfiguration): Promise<JwtP
       issuer: config.issuers,
       audience: [config.clientId!, 'https://api.botframework.com'],
       ignoreExpiration: false,
-      algorithms: ['RS256']
+      algorithms: ['RS256'],
+      clockTolerance: 300
     }
 
     jwt.verify(raw, getKey, verifyOptions, (err, user) => {

package/src/auth/msalTokenProvider.ts

@@ -13,7 +13,7 @@ import fs from 'fs'
 import crypto from 'crypto'
 
 const audience = 'api://AzureADTokenExchange'
-const logger = debug('agents:msal-token-provider')
+const logger = debug('agents:msal')
 
 /**
  * Provides tokens using MSAL.

package/src/cards/cardFactory.ts

@@ -13,8 +13,9 @@ import { O365ConnectorCard } from './o365ConnectorCard'
 import { ThumbnailCard } from './thumbnailCard'
 import { VideoCard } from './videoCard'
 import { CardImage } from './cardImage'
-import { OAuthCard } from '../oauth/oauthCard'
+import { OAuthCard } from '../oauth/oAuthCard'
 import { SigningResource } from '../oauth/signingResource'
+import { SigninCard } from './signinCard'
 
 /**
  * Factory class for creating various types of cards.
@@ -216,7 +217,12 @@ export class CardFactory {
    */
   static oauthCard (connectionName: string, title: string, text: string, signingResource: SigningResource) : Attachment {
     const card: Partial<OAuthCard> = {
-      buttons: [{ type: ActionTypes.Signin, title, value: signingResource.singingLink, channelData: undefined }],
+      buttons: [{
+        type: ActionTypes.Signin,
+        title,
+        value: signingResource.signInLink,
+        channelData: undefined
+      }],
       connectionName,
       tokenExchangeResource: signingResource.tokenExchangeResource,
       tokenPostResource: signingResource.tokenPostResource,
@@ -228,6 +234,24 @@ export class CardFactory {
     return { contentType: CardFactory.contentTypes.oauthCard, content: card }
   }
 
+  /**
+   * Creates a sign-in card attachment.
+   * @param title The title of the card.
+   * @param url The URL for the sign-in button.
+   * @param text The optional text for the card.
+   * @returns The sign-in card attachment.
+   */
+  static signinCard (title: string, url: string, text?: string): Attachment {
+    const card: SigninCard = {
+      buttons: [{ type: ActionTypes.Signin, title, value: url, channelData: undefined }],
+    }
+    if (text) {
+      card.text = text
+    }
+
+    return { contentType: CardFactory.contentTypes.signinCard, content: card }
+  }
+
   /**
    * Converts an array of media URLs or objects to an array of MediaUrl objects.
    * @param links The media URLs or objects.

package/src/cloudAdapter.ts

@@ -11,16 +11,16 @@ import { Request } from './auth/request'
 import { ConnectorClient } from './connector-client/connectorClient'
 import { AuthConfiguration } from './auth/authConfiguration'
 import { AuthProvider } from './auth/authProvider'
-import { Activity, ActivityEventNames, ActivityTypes, Channels, ConversationReference, DeliveryModes } from '@microsoft/agents-activity'
+import { Activity, ActivityEventNames, ActivityTypes, Channels, ConversationReference, DeliveryModes, ConversationParameters } from '@microsoft/agents-activity'
 import { ResourceResponse } from './connector-client/resourceResponse'
 import { MsalTokenProvider } from './auth/msalTokenProvider'
-import { ConversationParameters } from './connector-client/conversationParameters'
 import * as uuid from 'uuid'
 import { debug } from './logger'
 import { StatusCodes } from './statusCodes'
 import { InvokeResponse } from './invoke/invokeResponse'
 import { AttachmentInfo } from './connector-client/attachmentInfo'
 import { AttachmentData } from './connector-client/attachmentData'
+import { normalizeIncomingActivity } from './activityWireCompat'
 
 const logger = debug('agents:cloud-adapter')
 
@@ -164,8 +164,10 @@ export class CloudAdapter extends BaseAdapter {
       }
       res.end()
     }
+    const incoming = normalizeIncomingActivity(request.body!)
+    const activity = Activity.fromObject(incoming)
+    logger.info(`--> Processing incoming activity, type:${activity.type} channel:${activity.channelId}`)
 
-    const activity = Activity.fromObject(request.body!)
     if (!this.isValidChannelActivity(activity)) {
       return end(StatusCodes.BAD_REQUEST)
     }
@@ -180,6 +182,7 @@ export class CloudAdapter extends BaseAdapter {
       const context = this.createTurnContext(activity, logic)
       await this.runMiddleware(context, logic)
       const invokeResponse = this.processTurnResults(context)
+      logger.debug('Activity Response (invoke/expect replies): ', invokeResponse)
       return end(invokeResponse?.status ?? StatusCodes.OK, JSON.stringify(invokeResponse?.body), true)
     }
 
@@ -286,6 +289,7 @@ export class CloudAdapter extends BaseAdapter {
  * @returns The InvokeResponse if applicable, otherwise undefined.
  */
   protected processTurnResults (context: TurnContext): InvokeResponse | undefined {
+    logger.info('<--Sending back turn results')
     // Handle ExpectedReplies scenarios where all activities have been buffered and sent back at once in an invoke response.
     if (context.activity.deliveryMode === DeliveryModes.ExpectReplies) {
       return {
@@ -339,7 +343,7 @@ export class CloudAdapter extends BaseAdapter {
       tenantId: conversationParameters.tenantId,
     }
     activity.channelData = conversationParameters.channelData
-    activity.recipient = conversationParameters.bot
+    activity.recipient = conversationParameters.agent
 
     return activity
   }

package/src/connector-client/connectorClient.ts

@@ -3,16 +3,18 @@ import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'
 import { AuthConfiguration } from '../auth/authConfiguration'
 import { AuthProvider } from '../auth/authProvider'
 import { debug } from '../logger'
-import { Activity } from '@microsoft/agents-activity'
+import { Activity, ConversationParameters } from '@microsoft/agents-activity'
 import { ConversationsResult } from './conversationsResult'
-import { ConversationParameters } from './conversationParameters'
 import { ConversationResourceResponse } from './conversationResourceResponse'
 import { ResourceResponse } from './resourceResponse'
 import { AttachmentInfo } from './attachmentInfo'
 import { AttachmentData } from './attachmentData'
-
+import { normalizeOutgoingActivity } from '../activityWireCompat'
+import { getProductInfo } from '../getProductInfo'
 const logger = debug('agents:connector-client')
 
+export { getProductInfo }
+
 /**
  * ConnectorClient is a client for interacting with the Microsoft Connector API.
  */
@@ -71,8 +73,13 @@ export class ConnectorClient {
     const axiosInstance = axios.create({
       baseURL,
       headers: {
-        Accept: 'application/json'
-      }
+        Accept: 'application/json',
+        'User-Agent': getProductInfo(),
+      },
+      transformRequest: [
+        (data, headers) => {
+          return JSON.stringify(normalizeOutgoingActivity(data))
+        }]
     })
 
     const token = await authProvider.getAccessToken(authConfig, scope)
@@ -103,6 +110,7 @@ export class ConnectorClient {
    * @returns The conversation resource response.
    */
   public async createConversationAsync (body: ConversationParameters): Promise<ConversationResourceResponse> {
+    // const payload = normalizeOutgoingConvoParams(body)
     const config: AxiosRequestConfig = {
       method: 'post',
       url: '/v3/conversations',
@@ -127,6 +135,7 @@ export class ConnectorClient {
     activityId: string,
     body: Activity
   ): Promise<ResourceResponse> {
+    logger.debug(`Replying to activity: ${activityId} in conversation: ${conversationId}`)
     if (!conversationId || !activityId) {
       throw new Error('conversationId and activityId are required')
     }
@@ -153,6 +162,7 @@ export class ConnectorClient {
     conversationId: string,
     body: Activity
   ): Promise<ResourceResponse> {
+    logger.debug(`Send to conversation: ${conversationId} activity: ${body.id}`)
     if (!conversationId) {
       throw new Error('conversationId is required')
     }

package/src/connector-client/index.ts

@@ -3,7 +3,6 @@ export * from './attachmentInfo'
 export * from './attachmentView'
 export * from './connectorClient'
 export * from './conversationMembers'
-export * from './conversationParameters'
 export * from './conversationResourceResponse'
 export * from './conversationsResult'
 export * from './resourceResponse'

package/src/getProductInfo.ts

@@ -0,0 +1,3 @@
+import pjson from '@microsoft/agents-hosting/package.json'
+import os from 'os'
+export const getProductInfo = () : string => `agents-sdk-js/${pjson.version} nodejs/${process.version} ${os.platform()}-${os.arch()}/${os.release()}`

package/src/index.ts

@@ -16,7 +16,9 @@ export * from './storage'
 export * from './transcript'
 
 export * from './activityHandler'
+export * from './baseAdapter'
 export * from './cloudAdapter'
+export * from './middlewareSet'
 export * from './claimsIdentity'
 export * from './logger'
 export * from './messageFactory'
@@ -27,5 +29,3 @@ export * from './logger'
 export * from './storage/storage'
 
 export * from './agent-client'
-
-export * from '@microsoft/agents-activity'

package/src/oauth/index.ts

@@ -1,7 +1,6 @@
-export * from './oauthCard'
+export * from './oAuthCard'
 export * from './signingResource'
-export * from './tokenExchangeResource'
-export * from './tokenPostResource'
 export * from './userTokenClient'
-export * from './webChatOAuthFlow'
 export * from './tokenExchangeRequest'
+export * from './oAuthFlow'
+export * from './tokenResponse'

package/src/oauth/{oauthCard.ts → oAuthCard.ts}

@@ -2,9 +2,7 @@
 // Licensed under the MIT License.
 
 import { CardAction } from '@microsoft/agents-activity'
-import { TokenExchangeResource } from './tokenExchangeResource'
-import { TokenPostResource } from './tokenPostResource'
-
+import { TokenExchangeResource, TokenPostResource } from './signingResource'
 /**
  * Represents an OAuth card.
  */