@microsoft/agents-copilotstudio-client 1.4.0-beta.6.g725ba9fc33 → 1.4.1

package/src/copilotStudioClient.ts

@@ -5,12 +5,15 @@
 
 import { createEventSource, EventSourceClient } from 'eventsource-client'
 import { ConnectionSettings } from './connectionSettings'
-import { getCopilotStudioConnectionUrl, getTokenAudience } from './powerPlatformEnvironment'
+import { getCopilotStudioConnectionUrl, getCopilotStudioSubscribeUrl } from './powerPlatformEnvironment'
 import { Activity, ActivityTypes, ConversationAccount } from '@microsoft/agents-activity'
 import { ExecuteTurnRequest } from './executeTurnRequest'
 import { debug } from '@microsoft/agents-activity/logger'
-import { version } from '../package.json'
-import os from 'os'
+import { UserAgentHelper } from './userAgentHelper'
+import { ScopeHelper } from './scopeHelper'
+import { StartRequest } from './startRequest'
+import { StartResponse, ExecuteTurnResponse, createStartResponse, createExecuteTurnResponse } from './responses'
+import { SubscribeEvent } from './subscribeEvent'
 
 const logger = debug('copilot-studio:client')
 
@@ -36,8 +39,9 @@ export class CopilotStudioClient {
    * This is used for authentication token audience configuration.
    * @param settings Copilot Studio connection settings.
    * @returns The scope URL for token audience.
+   * @deprecated Use ScopeHelper.getScopeFromSettings instead.
    */
-  static scopeFromSettings: (settings: ConnectionSettings) => string = getTokenAudience
+  static scopeFromSettings: (settings: ConnectionSettings) => string = ScopeHelper.getScopeFromSettings
 
   /**
    * Creates an instance of CopilotStudioClient.
@@ -49,6 +53,17 @@ export class CopilotStudioClient {
     this.token = token
   }
 
+  /**
+   * Logs a diagnostic message if diagnostics are enabled.
+   * @param message The message to log.
+   * @param args Additional arguments to log.
+   */
+  private logDiagnostic (message: string, ...args: any[]): void {
+    if (this.settings.enableDiagnostics) {
+      logger.info(`[DIAGNOSTICS] ${message}`, ...args)
+    }
+  }
+
   /**
    * Streams activities from the Copilot Studio service using eventsource-client.
    * @param url The connection URL for Copilot Studio.
@@ -57,6 +72,10 @@ export class CopilotStudioClient {
    * @returns An async generator yielding the Agent's Activities.
    */
   private async * postRequestAsync (url: string, body?: any, method: string = 'POST'): AsyncGenerator<Activity> {
+    this.logDiagnostic(`Request URL: ${url}`)
+    this.logDiagnostic(`Request Method: ${method}`)
+    this.logDiagnostic('Request Body:', body ? JSON.stringify(body, null, 2) : 'none')
+
     logger.debug(`>>> SEND TO ${url}`)
 
     const streamMap = new Map<string, { text: string, sequence: number }[]>()
@@ -65,7 +84,7 @@ export class CopilotStudioClient {
       url,
       headers: {
         Authorization: `Bearer ${this.token}`,
-        'User-Agent': CopilotStudioClient.getProductInfo(),
+        'User-Agent': UserAgentHelper.getProductInfo(),
         'Content-Type': 'application/json',
         Accept: 'text/event-stream'
       },
@@ -139,26 +158,6 @@ export class CopilotStudioClient {
     }
   }
 
-  /**
-   * Appends this package.json version to the User-Agent header.
-   * - For browser environments, it includes the user agent of the browser.
-   * - For Node.js environments, it includes the Node.js version, platform, architecture, and release.
-   * @returns A string containing the product information, including version and user agent.
-   */
-  private static getProductInfo (): string {
-    const versionString = `CopilotStudioClient.agents-sdk-js/${version}`
-    let userAgent: string
-
-    if (typeof window !== 'undefined' && window.navigator) {
-      userAgent = `${versionString} ${navigator.userAgent}`
-    } else {
-      userAgent = `${versionString} nodejs/${process.version} ${os.platform()}-${os.arch()}/${os.release()}`
-    }
-
-    logger.debug(`User-Agent: ${userAgent}`)
-    return userAgent
-  }
-
   private processResponseHeaders (responseHeaders: Headers): void {
     if (this.settings.useExperimentalEndpoint && !this.settings.directConnectUrl?.trim()) {
       const islandExperimentalUrl = responseHeaders?.get(CopilotStudioClient.islandExperimentalUrlHeaderKey)
@@ -179,19 +178,54 @@ export class CopilotStudioClient {
         sanitizedHeaders.set(key, value)
       }
     })
-    logger.debug('Headers received:', sanitizedHeaders)
+    this.logDiagnostic('Response Headers:', sanitizedHeaders)
   }
 
+  /**
+   * Starts a new conversation with the Copilot Studio service using a StartRequest.
+   * @param request The request parameters for starting the conversation.
+   * @returns An async generator yielding the Agent's Activities.
+   */
+  public startConversationStreaming (request: StartRequest): AsyncGenerator<Activity>
+
   /**
    * Starts a new conversation with the Copilot Studio service.
    * @param emitStartConversationEvent Whether to emit a start conversation event. Defaults to true.
    * @returns An async generator yielding the Agent's Activities.
    */
-  public async * startConversationStreaming (emitStartConversationEvent: boolean = true): AsyncGenerator<Activity> {
-    const uriStart: string = getCopilotStudioConnectionUrl(this.settings)
-    const body = { emitStartConversationEvent }
+  public startConversationStreaming (emitStartConversationEvent?: boolean): AsyncGenerator<Activity>
+
+  /**
+   * Implementation of startConversationStreaming with overloads.
+   */
+  public async * startConversationStreaming (
+    requestOrFlag?: StartRequest | boolean
+  ): AsyncGenerator<Activity> {
+    // Normalize input to StartRequest
+    let request: StartRequest
+
+    if (typeof requestOrFlag === 'boolean' || requestOrFlag === undefined) {
+      // Legacy call: startConversationStreaming(true/false)
+      request = {
+        emitStartConversationEvent: requestOrFlag ?? true
+      }
+    } else {
+      // New call: startConversationStreaming({ locale: 'en-US', ... })
+      request = requestOrFlag
+    }
+
+    const uriStart: string = getCopilotStudioConnectionUrl(this.settings, request.conversationId)
+    const body: any = {
+      emitStartConversationEvent: request.emitStartConversationEvent ?? true
+    }
+
+    // Add locale to body if provided
+    if (request.locale) {
+      body.locale = request.locale
+    }
 
-    logger.info('Starting conversation ...')
+    logger.info('Starting conversation ...', request)
+    this.logDiagnostic('Start conversation request:', body)
 
     yield * this.postRequestAsync(uriStart, body, 'POST')
   }
@@ -211,15 +245,78 @@ export class CopilotStudioClient {
     yield * this.postRequestAsync(uriExecute, qbody, 'POST')
   }
 
+  /**
+   * Executes a turn in an existing conversation by sending an activity.
+   * This method provides explicit control over the conversation ID.
+   * @param activity The activity to send.
+   * @param conversationId The ID of the conversation. Required.
+   * @returns An async generator yielding the Agent's Activities.
+   * @throws Error if conversationId is not provided.
+   */
+  public async * executeStreaming (
+    activity: Activity,
+    conversationId: string
+  ): AsyncGenerator<Activity> {
+    if (!conversationId || !conversationId.trim()) {
+      throw new Error('conversationId is required for executeStreaming')
+    }
+
+    const uriExecute = getCopilotStudioConnectionUrl(this.settings, conversationId)
+    const request: ExecuteTurnRequest = new ExecuteTurnRequest(activity, conversationId)
+
+    logger.info('Executing turn with conversation ID:', conversationId)
+    this.logDiagnostic('Execute turn request:', {
+      conversationId,
+      activityType: activity.type,
+      activityText: activity.text
+    })
+
+    yield * this.postRequestAsync(uriExecute, request, 'POST')
+  }
+
+  /**
+   * Executes a turn in an existing conversation by sending an activity.
+   * @param activity The activity to send.
+   * @param conversationId The ID of the conversation. Required.
+   * @returns A promise yielding an array of activities.
+   * @throws Error if conversationId is not provided.
+   * @deprecated Use executeStreaming instead.
+   */
+  public async execute (
+    activity: Activity,
+    conversationId: string
+  ): Promise<Activity[]> {
+    const result: Activity[] = []
+    for await (const value of this.executeStreaming(activity, conversationId)) {
+      result.push(value)
+    }
+    return result
+  }
+
+  /**
+   * Starts a new conversation with the Copilot Studio service using a StartRequest.
+   * @param request The request parameters for starting the conversation.
+   * @returns A promise yielding an array of activities.
+   * @deprecated Use startConversationStreaming instead.
+   */
+  public async startConversationAsync (request: StartRequest): Promise<Activity[]>
+
   /**
    * Starts a new conversation with the Copilot Studio service.
    * @param emitStartConversationEvent Whether to emit a start conversation event. Defaults to true.
    * @returns A promise yielding an array of activities.
    * @deprecated Use startConversationStreaming instead.
    */
-  public async startConversationAsync (emitStartConversationEvent: boolean = true): Promise<Activity[]> {
+  public async startConversationAsync (emitStartConversationEvent?: boolean): Promise<Activity[]>
+
+  /**
+   * Implementation of startConversationAsync with overloads.
+   */
+  public async startConversationAsync (
+    requestOrFlag?: StartRequest | boolean
+  ): Promise<Activity[]> {
     const result: Activity[] = []
-    for await (const value of this.startConversationStreaming(emitStartConversationEvent)) {
+    for await (const value of this.startConversationStreaming(requestOrFlag as any)) {
       result.push(value)
     }
     return result
@@ -265,4 +362,113 @@ export class CopilotStudioClient {
     }
     return result
   }
+
+  /**
+   * Starts a new conversation and returns a typed response.
+   * @param request The request parameters for starting the conversation.
+   * @returns A promise yielding a StartResponse with activities and conversation metadata.
+   */
+  public async startConversationWithResponse (request?: StartRequest | boolean): Promise<StartResponse> {
+    const activities: Activity[] = []
+    let finalConversationId = ''
+
+    for await (const activity of this.startConversationStreaming(request as any)) {
+      activities.push(activity)
+      if (activity.conversation?.id) {
+        finalConversationId = activity.conversation.id
+      }
+    }
+
+    // Fall back to instance conversationId if not found in activities
+    finalConversationId = finalConversationId || this.conversationId
+
+    return createStartResponse(activities, finalConversationId)
+  }
+
+  /**
+   * Executes a turn and returns a typed response.
+   * @param activity The activity to send.
+   * @param conversationId The conversation ID.
+   * @returns A promise yielding an ExecuteTurnResponse with activities and metadata.
+   */
+  public async executeWithResponse (
+    activity: Activity,
+    conversationId: string
+  ): Promise<ExecuteTurnResponse> {
+    const activities: Activity[] = []
+
+    for await (const value of this.executeStreaming(activity, conversationId)) {
+      activities.push(value)
+    }
+
+    return createExecuteTurnResponse(activities, conversationId)
+  }
+
+  /**
+   * Subscribes to a conversation to receive events via Server-Sent Events (SSE).
+   * This method allows resumption from a specific event ID.
+   * @param conversationId The ID of the conversation to subscribe to.
+   * @param lastReceivedEventId Optional. The last received event ID for resumption.
+   * @returns An async generator yielding SubscribeEvent objects containing activities and event IDs.
+   */
+  public async * subscribeAsync (
+    conversationId: string,
+    lastReceivedEventId?: string
+  ): AsyncGenerator<SubscribeEvent> {
+    if (!conversationId || !conversationId.trim()) {
+      throw new Error('conversationId is required for subscribeAsync')
+    }
+
+    const url = getCopilotStudioSubscribeUrl(this.settings, conversationId)
+
+    logger.info('Subscribing to conversation:', conversationId)
+    this.logDiagnostic('Subscribe request:', { conversationId, lastReceivedEventId, url })
+
+    const eventSource: EventSourceClient = createEventSource({
+      url,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'User-Agent': UserAgentHelper.getProductInfo(),
+        Accept: 'text/event-stream',
+        ...(lastReceivedEventId && { 'Last-Event-ID': lastReceivedEventId })
+      },
+      method: 'GET',
+      fetch: async (url, init) => {
+        const response = await fetch(url, init)
+        this.processResponseHeaders(response.headers)
+        return response
+      }
+    })
+
+    try {
+      for await (const { data, event, id } of eventSource) {
+        if (data && event === 'activity') {
+          try {
+            const activity = Activity.fromJson(data)
+            const subscribeEvent: SubscribeEvent = {
+              activity,
+              eventId: id
+            }
+
+            logger.debug(`Received activity via subscription, event ID: ${id}`)
+            this.logDiagnostic('Subscribe event received:', { eventId: id, activityType: activity.type })
+
+            yield subscribeEvent
+          } catch (error) {
+            logger.error('Failed to parse activity in subscription:', error)
+          }
+        } else if (event === 'end') {
+          logger.debug('Subscription stream complete')
+          break
+        }
+
+        if (eventSource.readyState === 'closed') {
+          logger.debug('Subscription connection closed')
+          break
+        }
+      }
+    } finally {
+      eventSource.close()
+    }
+  }
 }

package/src/copilotStudioConnectionSettings.ts

@@ -36,6 +36,13 @@ export interface CopilotStudioConnectionSettings {
   /** Directs Copilot Studio Client to use the experimental endpoint if available. Default value is false. */
   useExperimentalEndpoint?: boolean
 
+  /**
+   * Enables diagnostic logging for debugging purposes.
+   * When enabled, detailed logs about requests, responses, and connection status will be emitted.
+   * Default value is false.
+   */
+  enableDiagnostics?: boolean
+
   /**
    * The login authority to use for the connection.
    * @deprecated This property will not be supported in future versions. Handle the auth properties in the agent.

package/src/copilotStudioWebChat.ts

@@ -26,6 +26,32 @@ export interface CopilotStudioWebChatSettings {
    * @default false
    */
   showTyping?: boolean;
+
+  /**
+   * An existing conversation ID to resume. When provided, the connection will
+   * send subsequent messages to this conversation instead of starting a new one.
+   *
+   * By default, providing a conversationId will skip the initial
+   * `startConversationStreaming()` call. Override this with the
+   * `startConversation` setting.
+   *
+   * **Note:** The server does not validate conversation IDs. A non-existent
+   * GUID will silently create a new conversation under that ID, while a
+   * non-GUID string may cause the server to return no response. Only pass
+   * IDs that were previously captured from a real conversation.
+   */
+  conversationId?: string;
+
+  /**
+   * Controls whether `startConversationStreaming()` is called when the
+   * connection is first subscribed to.
+   *
+   * - `undefined` (default): starts a new conversation only when no
+   *   `conversationId` is provided (`!conversationId`).
+   * - `true`: always starts a conversation, even when resuming.
+   * - `false`: never starts a conversation, even for new connections.
+   */
+  startConversation?: boolean;
 }
 
 /**
@@ -61,6 +87,13 @@ export interface CopilotStudioWebChatConnection {
    */
   activity$: Observable<Partial<Activity>>;
 
+  /**
+   * The active conversation ID. Set from `CopilotStudioWebChatSettings.conversationId`
+   * when resuming, or captured from the first response activity for new conversations.
+   * Returns `undefined` until a conversation has been established.
+   */
+  readonly conversationId: string | undefined;
+
   /**
    * Posts a user activity to the Copilot Studio service and returns an observable
    * that emits the activity ID once the message is successfully sent.
@@ -224,9 +257,19 @@ export class CopilotStudioWebChat {
     settings?: CopilotStudioWebChatSettings
   ): CopilotStudioWebChatConnection {
     logger.info('--> Creating connection between Copilot Studio and WebChat ...')
+
+    const normalizedConversationId =
+      settings?.conversationId && settings.conversationId.trim() !== ''
+        ? settings.conversationId.trim()
+        : undefined
+    const shouldStart = settings?.startConversation ?? !normalizedConversationId
+
     let sequence = 0
     let activitySubscriber: Subscriber<Partial<Activity>> | undefined
     let conversation: ConversationAccount | undefined
+    let activeConversationId: string | undefined = normalizedConversationId
+    let ended = false
+    let started = false
 
     const connectionStatus$ = new BehaviorSubject(0)
     const activity$ = createObservable<Partial<Activity>>(async (subscriber) => {
@@ -237,22 +280,29 @@ export class CopilotStudioWebChat {
         await Promise.resolve() // Webchat requires an extra tick to process the connection status change
       })
 
+      // When resuming (shouldStart === false), transition straight to connected
+      if (!shouldStart || started) {
+        await handleAcknowledgementOnce()
+        return
+      }
+      started = true
+
       logger.debug('--> Connection established.')
       notifyTyping()
 
-      if (connectionStatus$.value < 2) {
-        for await (const activity of client.startConversationStreaming()) {
-          delete activity.replyToId
-          if (!conversation && activity.conversation) {
-            conversation = activity.conversation
-            await handleAcknowledgementOnce()
-          }
-
-          notifyActivity(activity)
+      for await (const activity of client.startConversationStreaming()) {
+        delete activity.replyToId
+        if (!conversation && activity.conversation) {
+          conversation = activity.conversation
+        }
+        if (activity.conversation?.id) {
+          activeConversationId = activity.conversation.id
         }
-        // If no activities received from bot, we should still acknowledge.
         await handleAcknowledgementOnce()
+        notifyActivity(activity)
       }
+      // If no activities received from bot, we should still acknowledge.
+      await handleAcknowledgementOnce()
     })
 
     const notifyActivity = (activity: Partial<Activity>) => {
@@ -283,6 +333,11 @@ export class CopilotStudioWebChat {
     return {
       connectionStatus$,
       activity$,
+
+      get conversationId () {
+        return activeConversationId
+      },
+
       postActivity (activity: Activity) {
         logger.info('--> Preparing to send activity to Copilot Studio ...')
 
@@ -290,6 +345,10 @@ export class CopilotStudioWebChat {
           throw new Error('Activity cannot be null.')
         }
 
+        if (ended) {
+          throw new Error('Connection has been ended.')
+        }
+
         if (!activitySubscriber) {
           throw new Error('Activity subscriber is not initialized.')
         }
@@ -309,8 +368,11 @@ export class CopilotStudioWebChat {
             // Notify WebChat immediately that the message was sent
             subscriber.next(newActivity.id!)
 
-            // Stream the agent's response, but don't block the UI
-            for await (const responseActivity of client.sendActivityStreaming(newActivity)) {
+            // Stream the agent's response, passing activeConversationId for URL routing
+            for await (const responseActivity of client.sendActivityStreaming(newActivity, activeConversationId)) {
+              if (!activeConversationId && responseActivity.conversation?.id) {
+                activeConversationId = responseActivity.conversation.id
+              }
               notifyActivity(responseActivity)
               logger.info('<-- Activity received correctly from Copilot Studio.')
             }
@@ -325,6 +387,7 @@ export class CopilotStudioWebChat {
 
       end () {
         logger.info('--> Ending connection between Copilot Studio and WebChat ...')
+        ended = true
         connectionStatus$.complete()
         if (activitySubscriber) {
           activitySubscriber.complete()

package/src/executeTurnRequest.ts

@@ -7,17 +7,22 @@ import { Activity } from '@microsoft/agents-activity'
 
 /**
  * Represents a request to execute a turn in a conversation.
- * This class encapsulates the activity to be executed during the turn.
+ * This class encapsulates the activity and optional conversation context.
  */
 export class ExecuteTurnRequest {
   /** The activity to be executed. */
   activity?: Activity
 
+  /** Optional conversation ID for this turn. */
+  conversationId?: string
+
   /**
    * Creates an instance of ExecuteTurnRequest.
    * @param activity The activity to be executed.
+   * @param conversationId Optional conversation ID.
    */
-  constructor (activity?: Activity) {
+  constructor (activity?: Activity, conversationId?: string) {
     this.activity = activity
+    this.conversationId = conversationId
   }
 }

package/src/index.ts

@@ -6,3 +6,8 @@ export * from './copilotStudioWebChat.js'
 export * from './executeTurnRequest.js'
 export * from './powerPlatformCloud.js'
 export * from './powerPlatformEnvironment.js'
+export * from './responses.js'
+export * from './scopeHelper.js'
+export * from './startRequest.js'
+export * from './subscribeEvent.js'
+export * from './userAgentHelper.js'

package/src/powerPlatformEnvironment.ts

@@ -34,13 +34,6 @@ export function getCopilotStudioConnectionUrl (
       throw new Error('directConnectUrl must be a valid URL')
     }
 
-    // FIX for Missing Tenant ID
-    if (settings.directConnectUrl.toLowerCase().includes('tenants/00000000-0000-0000-0000-000000000000')) {
-      logger.warn(`Direct connection cannot be used, forcing default settings flow. Tenant ID is missing in the URL: ${settings.directConnectUrl}`)
-      // Direct connection cannot be used, ejecting and forcing the normal settings flow:
-      return getCopilotStudioConnectionUrl({ ...settings, directConnectUrl: '' }, conversationId)
-    }
-
     return createURL(settings.directConnectUrl, conversationId).href
   }
 
@@ -80,6 +73,32 @@ export function getCopilotStudioConnectionUrl (
   return url
 }
 
+/**
+ * Generates the subscribe URL for Copilot Studio Server-Sent Events (SSE).
+ * @param settings - The connection settings.
+ * @param conversationId - The conversation ID to subscribe to.
+ * @returns The subscribe URL.
+ * @throws Will throw an error if required settings are missing or invalid.
+ */
+export function getCopilotStudioSubscribeUrl (
+  settings: ConnectionSettings,
+  conversationId: string
+): string {
+  if (!conversationId || !conversationId.trim()) {
+    throw new Error('conversationId is required for subscribe URL')
+  }
+
+  const baseUrl = getCopilotStudioConnectionUrl(settings, conversationId)
+  const url = new URL(baseUrl)
+  url.pathname = url.pathname.endsWith('/')
+    ? `${url.pathname}subscribe`
+    : `${url.pathname}/subscribe`
+  const subscribeUrl = url.href
+
+  logger.debug(`Generated Copilot Studio subscribe URL: ${subscribeUrl}`)
+  return subscribeUrl
+}
+
 /**
  * Returns the Power Platform API Audience.
  * @param settings - Configuration Settings to use.

package/src/responses.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Activity } from '@microsoft/agents-activity'
+
+/**
+ * Base interface for all Copilot Studio API responses.
+ */
+export interface ResponseBase {
+  /**
+   * The activities returned by the service.
+   */
+  activities: Activity[]
+
+  /**
+   * The conversation ID associated with this response.
+   */
+  conversationId: string
+}
+
+/**
+ * Response returned when starting a new conversation.
+ */
+export interface StartResponse extends ResponseBase {
+  /**
+   * Indicates whether this is a new conversation.
+   */
+  isNewConversation: boolean
+}
+
+/**
+ * Response returned when executing a turn in an existing conversation.
+ */
+export interface ExecuteTurnResponse extends ResponseBase {
+  /**
+   * The number of activities in this response.
+   */
+  activityCount: number
+}
+
+/**
+ * Creates a StartResponse from an array of activities.
+ * @param activities The activities to include in the response.
+ * @param conversationId The conversation ID.
+ * @returns A new StartResponse object.
+ */
+export function createStartResponse (
+  activities: Activity[],
+  conversationId: string
+): StartResponse {
+  return {
+    activities,
+    conversationId,
+    isNewConversation: true
+  }
+}
+
+/**
+ * Creates an ExecuteTurnResponse from an array of activities.
+ * @param activities The activities to include in the response.
+ * @param conversationId The conversation ID.
+ * @returns A new ExecuteTurnResponse object.
+ */
+export function createExecuteTurnResponse (
+  activities: Activity[],
+  conversationId: string
+): ExecuteTurnResponse {
+  return {
+    activities,
+    conversationId,
+    activityCount: activities.length
+  }
+}

package/src/scopeHelper.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ConnectionSettings } from './connectionSettings'
+import { getTokenAudience } from './powerPlatformEnvironment'
+
+/**
+ * Utility class for generating authentication scope URLs for Copilot Studio.
+ */
+export class ScopeHelper {
+  /**
+   * Returns the scope URL needed to connect to Copilot Studio from the connection settings.
+   * This is used for authentication token audience configuration.
+   * @param settings Copilot Studio connection settings.
+   * @returns The scope URL for token audience (e.g., "https://api.powerplatform.com/.default").
+   */
+  static getScopeFromSettings (settings: ConnectionSettings): string {
+    return getTokenAudience(settings)
+  }
+}