@microsoft/agents-hosting 1.6.0-beta.9.gce9d8facd2 → 1.6.1

package/src/headerPropagation.ts

@@ -8,10 +8,11 @@
  * It filters the incoming request headers based on the definition provided and loads them into the outgoing headers collection.
  */
 export class HeaderPropagation implements HeaderPropagationCollection {
+  private _keys: string[] = []
   private _incomingRequests: Record<string, string>
   private _outgoingHeaders: Record<string, string> = {}
 
-  private _headersToPropagate = ['x-ms-correlation-id']
+  private _protectedHeaders = ['x-ms-correlation-id']
 
   public get incoming (): Record<string, string> {
     return this._incomingRequests
@@ -27,54 +28,78 @@ export class HeaderPropagation implements HeaderPropagationCollection {
     }
 
     this._incomingRequests = this.normalizeHeaders(headers)
-    this.propagate(this._headersToPropagate)
+
+    // Ensure protected headers are propagated from incoming to outgoing by default without allowing modifications.
+    const protectedHeaders = [...this._protectedHeaders]
+    this._protectedHeaders = [] // Temporarily clear protected headers to allow propagation without restriction
+    this.propagate(protectedHeaders)
+    this._protectedHeaders = protectedHeaders // Restore protected headers list after propagation
   }
 
   propagate (headers: string[]) {
-    for (const key of headers ?? []) {
-      const lowerKey = key.toLowerCase()
-      if (this._incomingRequests[lowerKey] && !this._outgoingHeaders[lowerKey]) {
-        this._outgoingHeaders[lowerKey] = this._incomingRequests[lowerKey]
+    this.process(headers.map(h => [h, '']), key => {
+      if (this._incomingRequests[key] && !this._outgoingHeaders[key]) {
+        this._outgoingHeaders[key] = this._incomingRequests[key]
       }
-    }
+    })
   }
 
   add (headers: Record<string, string>) {
-    for (const [key, value] of Object.entries(headers ?? {})) {
-      const lowerKey = key.toLowerCase()
-      if (!this._incomingRequests[lowerKey] && !this._outgoingHeaders[lowerKey]) {
-        this._outgoingHeaders[lowerKey] = value
+    this.process(Object.entries(headers ?? {}), (key, value) => {
+      if (!this._incomingRequests[key] && !this._outgoingHeaders[key]) {
+        this._outgoingHeaders[key] = value
       }
-    }
+    })
   }
 
   concat (headers: Record<string, string>) {
-    for (const [key, value] of Object.entries(headers ?? {})) {
-      const lowerKey = key.toLowerCase()
-      if (this._incomingRequests[lowerKey] && !this._headersToPropagate.includes(lowerKey)) {
-        this._outgoingHeaders[lowerKey] = `${this._outgoingHeaders[lowerKey] ?? this._incomingRequests[lowerKey]} ${value}`.trim()
+    this.process(Object.entries(headers ?? {}), (key, value) => {
+      if (this._incomingRequests[key] || this._outgoingHeaders[key]) {
+        this._outgoingHeaders[key] = `${this._outgoingHeaders[key] ?? this._incomingRequests[key]} ${value}`.trim()
       }
-    }
+    })
   }
 
   override (headers: Record<string, string>) {
-    for (const [key, value] of Object.entries(headers ?? {})) {
-      const lowerKey = key.toLowerCase()
-      if (!this._headersToPropagate.includes(lowerKey)) {
-        this._outgoingHeaders[lowerKey] = value
+    this.process(Object.entries(headers ?? {}), (key, value) => {
+      this._outgoingHeaders[key] = value
+    })
+  }
+
+  key (key: string) {
+    return this._keys.find(k => k.toLowerCase() === key.toLowerCase())
+  }
+
+  /**
+   * A helper method to process headers based on a provided callback function. It iterates over the headers and applies the callback to each header key and value.
+   * @param headers An array of header key-value pairs to process.
+   * @param callback A function that takes a header key and value, allowing for custom processing logic to be applied to each header.
+   */
+  private process (headers: [string, string][], callback: (key: string, value: string) => void) {
+    for (const [key, value] of headers) {
+      const savedKey = this.key(key)
+      const realKey = savedKey ?? key
+      if (!savedKey) {
+        this._keys.push(realKey)
+      }
+      if (!this._protectedHeaders.includes(key.toLowerCase())) {
+        callback(realKey, value)
       }
     }
   }
 
   /**
-   * Normalizes the headers by lowercasing the keys and ensuring the values are strings.
+   * Normalizes the headers by ensuring the values are strings.
    * @param headers The headers to normalize.
    * @returns A new object with normalized headers.
    */
   private normalizeHeaders (headers: Record<string, string | string[] | undefined>) {
     return Object.entries(headers).reduce((acc, [key, value]) => {
       if (value) {
-        acc[key.toLowerCase()] = Array.isArray(value) ? value.join(' ') : value
+        acc[key] = Array.isArray(value) ? value.join(' ') : value
+        if (!this._keys.includes(key)) {
+          this._keys.push(key) // Store the original casing of the header keys
+        }
       }
       return acc
     }, {} as Record<string, string>)
@@ -138,4 +163,11 @@ export interface HeaderPropagationCollection {
    * If the header does not exist in the incoming headers, it will be added to the outgoing collection.
    */
   override(headers: Record<string, string>): void
+  /**
+   * Resolves the actual header key in a case-insensitive manner.
+   * This is useful for ensuring that headers are accessed correctly regardless of their case in the incoming request.
+   * @param key The header key to resolve.
+   * @returns The resolved header key or undefined if not found.
+   */
+  key?(key: string): string | undefined
 }

package/src/httpClient.ts

@@ -0,0 +1,223 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ExceptionHelper } from '@microsoft/agents-activity'
+import { Readable } from 'node:stream'
+import { Errors } from './errorHelper'
+
+/**
+ * Configuration for an HTTP request.
+ */
+export interface HttpRequestConfig {
+  method: string
+  url: string
+  headers?: Record<string, string>
+  data?: unknown
+  params?: Record<string, string | undefined>
+  responseType?: 'json' | 'arraybuffer' | 'stream'
+  timeout?: number
+  signal?: AbortSignal
+}
+
+/**
+ * Represents an HTTP response.
+ */
+export interface HttpResponse<T = unknown> {
+  data: T
+  status: number
+  statusText: string
+  headers: Headers
+  config: HttpRequestConfig
+}
+
+/**
+ * Options for creating an HttpClient instance.
+ */
+export interface HttpClientOptions {
+  baseURL?: string
+  headers?: Record<string, string>
+}
+
+/**
+ * A lightweight HTTP client built on native fetch.
+ */
+export class HttpClient {
+  private _baseURL: string
+  private _defaultHeaders: Record<string, string>
+
+  constructor (options: HttpClientOptions = {}) {
+    this._baseURL = options.baseURL ?? ''
+    this._defaultHeaders = this.normalizeHeaders(options.headers)
+  }
+
+  get baseURL (): string {
+    return this._baseURL
+  }
+
+  get defaultHeaders (): Record<string, string> {
+    return this._defaultHeaders
+  }
+
+  set defaultHeaders (headers: Record<string, string>) {
+    this._defaultHeaders = this.normalizeHeaders(headers)
+  }
+
+  setHeader (name: string, value: string): void {
+    this._defaultHeaders[name.toLowerCase()] = value
+  }
+
+  async request<T = unknown> (config: HttpRequestConfig): Promise<HttpResponse<T>> {
+    const url = this.buildUrl(config.url, config.params)
+    const headers = this.normalizeHeaders({ ...this._defaultHeaders, ...config.headers })
+    const requestHeaders = new Headers(headers)
+    const fetchOptions: RequestInit = {
+      method: config.method.toUpperCase(),
+      headers: requestHeaders,
+      signal: config.signal ??
+    (config.timeout ? AbortSignal.timeout(config.timeout) : undefined)
+    }
+
+    if (config.data !== undefined && config.data !== null) {
+      const contentType = requestHeaders.get('content-type') ?? ''
+      if (contentType.includes('application/x-www-form-urlencoded')) {
+        fetchOptions.body = new URLSearchParams(config.data as Record<string, string>).toString()
+      } else if (config.data instanceof URLSearchParams) {
+        if (!contentType) {
+          requestHeaders.set('content-type', 'application/x-www-form-urlencoded;charset=utf-8')
+        }
+        fetchOptions.body = config.data.toString()
+      } else if (typeof config.data === 'string') {
+        fetchOptions.body = config.data
+      } else if (config.data instanceof Uint8Array || config.data instanceof ArrayBuffer ||
+            config.data instanceof Blob || config.data instanceof FormData ||
+            config.data instanceof ReadableStream) {
+        fetchOptions.body = config.data
+      } else {
+        if (!contentType) {
+          requestHeaders.set('content-type', 'application/json')
+        }
+        fetchOptions.body = JSON.stringify(config.data)
+      }
+    }
+
+    const response = await fetch(url, fetchOptions)
+
+    let data: T
+    if (config.responseType === 'stream') {
+      if (!response.ok) {
+        data = await response.text() as T
+      } else {
+        data = Readable.fromWeb(response.body ?? new ReadableStream()) as T
+      }
+    } else if (config.responseType === 'arraybuffer') {
+      data = await response.arrayBuffer() as T
+    } else {
+      const text = await response.text()
+      try {
+        data = JSON.parse(text) as T
+      } catch {
+        data = text as T
+      }
+    }
+
+    const httpResponse: HttpResponse<T> = {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      config,
+    }
+
+    if (!response.ok) {
+      const error: HttpError = new HttpError(
+        `Request failed with status ${response.status}`,
+        httpResponse,
+        config
+      )
+      throw error
+    }
+
+    return httpResponse
+  }
+
+  async get<T = unknown> (url: string, options?: Partial<HttpRequestConfig>): Promise<HttpResponse<T>> {
+    return this.request<T>({ method: 'get', url, ...options })
+  }
+
+  private buildUrl (path: string, params?: Record<string, string | undefined>): string {
+    let url: string
+    if (path.startsWith('http://') || path.startsWith('https://')) {
+      url = path
+    } else {
+      if (!this._baseURL) {
+        throw ExceptionHelper.generateException(Error, Errors.HttpClientRelativeUrlRequiresBaseUrl, undefined, { url: path })
+      }
+
+      const base = this._baseURL.endsWith('/') ? this._baseURL.slice(0, -1) : this._baseURL
+      const cleanPath = path.startsWith('/') ? path : `/${path}`
+      url = `${base}${cleanPath}`
+    }
+
+    if (params) {
+      const searchParams = new URLSearchParams()
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+          searchParams.set(key, value)
+        }
+      }
+      const queryString = searchParams.toString()
+      if (queryString) {
+        url += `${url.includes('?') ? '&' : '?'}${queryString}`
+      }
+    }
+
+    return url
+  }
+
+  private normalizeHeaders (headers?: Record<string, string>): Record<string, string> {
+    if (!headers) {
+      return {}
+    }
+
+    return Object.entries(headers).reduce((normalized, [name, value]) => {
+      normalized[name.toLowerCase()] = value
+      return normalized
+    }, {} as Record<string, string>)
+  }
+}
+
+/**
+ * Error thrown when an HTTP request fails.
+ */
+export class HttpError extends Error {
+  public readonly response: HttpResponse
+  public readonly config: HttpRequestConfig
+  public readonly status: number
+
+  constructor (message: string, response: HttpResponse, config: HttpRequestConfig) {
+    super(message)
+    this.name = 'HttpError'
+    this.response = response
+    this.config = config
+    this.status = response.status
+  }
+
+  toJSON (): Record<string, unknown> {
+    return {
+      message: this.message,
+      status: this.status,
+      config: {
+        url: this.config.url,
+        method: this.config.method,
+        data: this.config.data,
+      },
+      response: {
+        status: this.response.status,
+        statusText: this.response.statusText,
+        data: this.response.data,
+      },
+    }
+  }
+}

package/src/index.ts

@@ -18,7 +18,10 @@ export * from './transcript'
 
 export * from './activityHandler'
 export * from './baseAdapter'
-export * from './cloudAdapter'
+// Note: re-export the public surface of `cloudAdapter` explicitly so the
+// test-only internals (e.g., the per-process warning dedup set) do not leak
+// into the package's public API.
+export { CloudAdapter, type CloudAdapterOptions } from './cloudAdapter'
 export * from './middlewareSet'
 export * from './messageFactory'
 export * from './statusCodes'
@@ -26,5 +29,6 @@ export * from './turnContext'
 export * from './turnContextStateCollection'
 export * from './storage/storage'
 export * from './headerPropagation'
+export * from './httpClient'
 
 export * from './agent-client'

package/src/oauth/userTokenClient.ts

@@ -1,12 +1,12 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import axios, { AxiosInstance } from 'axios'
+import { HttpClient, HttpError } from '../httpClient'
 import { Activity, ConversationReference } from '@microsoft/agents-activity'
 import { debug } from '@microsoft/agents-telemetry'
 import { normalizeTokenExchangeState } from '../activityWireCompat'
 import { AadResourceUrls, SignInResource, TokenExchangeRequest, TokenOrSinginResourceResponse, TokenResponse, TokenStatus } from './userTokenClient.types'
-import { getProductInfo } from '../getProductInfo'
+import { applyUserAgentHeader, getProductInfo } from '../getProductInfo'
 import { AuthProvider } from '../auth'
 import { HeaderPropagation, HeaderPropagationCollection } from '../headerPropagation'
 import { getTokenServiceEndpoint } from './customUserTokenAPI'
@@ -15,11 +15,25 @@ import { UserTokenClientTraceDefinitions } from '../observability'
 
 const logger = debug('agents:user-token-client')
 
+function formatHttpErrorMessage (error: HttpError): string {
+  const responseData = error.response?.data
+  if (responseData === undefined) {
+    return error.message
+  }
+
+  try {
+    const serializedResponseData = JSON.stringify(responseData)
+    return serializedResponseData === undefined ? error.message : `${error.message}: ${serializedResponseData}`
+  } catch {
+    return error.message
+  }
+}
+
 /**
  * Client for managing user tokens.
  */
 export class UserTokenClient {
-  client: AxiosInstance
+  client: HttpClient
   private msAppId: string = ''
   /**
    * Creates a new instance of UserTokenClient.
@@ -28,14 +42,14 @@ export class UserTokenClient {
   constructor (msAppId: string)
   /**
    * Creates a new instance of UserTokenClient.
-   * @param axiosInstance The axios instance.
+   * @param httpClient The HttpClient instance.
    */
-  constructor (axiosInstance: AxiosInstance)
+  constructor (httpClient: HttpClient)
 
-  constructor (param: string | AxiosInstance) {
+  constructor (param: string | HttpClient) {
     if (typeof param === 'string') {
       const baseURL = getTokenServiceEndpoint()
-      this.client = axios.create({
+      this.client = new HttpClient({
         baseURL,
         headers: {
           Accept: 'application/json',
@@ -45,55 +59,6 @@ export class UserTokenClient {
     } else {
       this.client = param
     }
-
-    this.client.interceptors.request.use((config) => {
-      const { method, url, data, headers, params } = config
-      const { Authorization, authorization, ...headersToLog } = headers || {}
-      logger.debug('Request: ', {
-        host: this.client.getUri(),
-        url,
-        data,
-        method,
-        params,
-        headers: headersToLog
-      })
-      return config
-    })
-
-    this.client.interceptors.response.use(
-      (config) => {
-        const { status, statusText, config: requestConfig, headers } = config
-        const { Authorization, authorization, ...headersToLog } = headers || {}
-        const { token, ...redactedData } = requestConfig?.data || {}
-        logger.debug('Response: ', {
-          status,
-          statusText,
-          host: this.client.getUri(),
-          url: requestConfig?.url,
-          data: redactedData,
-          method: requestConfig?.method,
-          headers: headersToLog
-        })
-        return config
-      },
-      (error) => {
-        const { code, status, message, stack, response } = error
-        const { headers } = response || {}
-        const errorDetails = {
-          code,
-          host: this.client.getUri(),
-          url: error.config.url,
-          method: error.config.method,
-          data: error.config.data,
-          message: message + JSON.stringify(response?.data),
-          headers,
-          stack,
-        }
-        logger.debug('Response error: ', errorDetails)
-        if (errorDetails.url === '/api/usertoken/GetToken' && status !== 404) {
-          return Promise.reject(errorDetails)
-        }
-      })
   }
 
   /**
@@ -112,29 +77,24 @@ export class UserTokenClient {
     headers?: HeaderPropagationCollection
   ): Promise<UserTokenClient> {
     const headerPropagation = headers ?? new HeaderPropagation({})
-    const userAgent = headerPropagation.outgoing['user-agent']
-    const productInfo = getProductInfo()
-    if (!userAgent) {
-      headerPropagation.add({ 'User-Agent': productInfo })
-    } else if (!userAgent.includes(productInfo)) {
-      headerPropagation.concat({ 'User-Agent': productInfo })
-    }
+    applyUserAgentHeader(headerPropagation)
     headerPropagation.override({
       Accept: 'application/json',
-      'Content-Type': 'application/json', // Required by transformRequest
-    })
-
-    const axiosInstance = axios.create({
-      baseURL,
-      headers: headerPropagation.outgoing,
+      'Content-Type': 'application/json',
     })
 
+    const clientHeaders: Record<string, string> = { ...headerPropagation.outgoing }
     const token = await authProvider?.getAccessToken(scope)
     if (token && token.length > 1) {
-      axiosInstance.defaults.headers.common.Authorization = `Bearer ${token}`
+      clientHeaders.Authorization = `Bearer ${token}`
     }
 
-    return new UserTokenClient(axiosInstance)
+    const httpClient = new HttpClient({
+      baseURL,
+      headers: clientHeaders,
+    })
+
+    return new UserTokenClient(httpClient)
   }
 
   /**
@@ -149,13 +109,21 @@ export class UserTokenClient {
     return trace(UserTokenClientTraceDefinitions.getUserToken, async ({ record }) => {
       const [channelId] = Activity.parseChannelId(channelIdComposite)
       const params = { connectionName, channelId, userId, code }
-      const response = await this.client.get('/api/usertoken/GetToken', { params })
-      record({ connectionName, channelId, userId, httpStatusCode: response.status?.toString() })
+      try {
+        const response = await this.executeRequest('get', '/api/usertoken/GetToken', undefined, { params })
+        record({ connectionName, channelId, userId, httpStatusCode: response.status?.toString() })
 
-      if (response?.data) {
-        return response.data as TokenResponse
+        if (response?.data) {
+          return response.data as TokenResponse
+        }
+        return { token: undefined }
+      } catch (error: any) {
+        if (error instanceof HttpError && error.status === 404) {
+          record({ connectionName, channelId, userId, httpStatusCode: '404' })
+          return { token: undefined }
+        }
+        throw error
       }
-      return { token: undefined }
     })
   }
 
@@ -170,7 +138,7 @@ export class UserTokenClient {
     return trace(UserTokenClientTraceDefinitions.signOut, async ({ record }) => {
       const [channelId] = Activity.parseChannelId(channelIdComposite)
       const params = { userId, connectionName, channelId }
-      const response = await this.client.delete('/api/usertoken/SignOut', { params })
+      const response = await this.executeRequest('delete', '/api/usertoken/SignOut', undefined, { params })
       record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
       if (response.status !== 200) {
         throw new Error('Failed to sign out')
@@ -197,7 +165,7 @@ export class UserTokenClient {
       const tokenExchangeStateNormalized = normalizeTokenExchangeState(tokenExchangeState)
       const state = Buffer.from(JSON.stringify(tokenExchangeStateNormalized)).toString('base64')
       const params = { state }
-      const response = await this.client.get('/api/botsignin/GetSignInResource', { params })
+      const response = await this.executeRequest('get', '/api/botsignin/GetSignInResource', undefined, { params })
       record({ connectionName, httpStatusCode: response.status?.toString() })
       return response.data as SignInResource
     })
@@ -215,7 +183,7 @@ export class UserTokenClient {
     return trace(UserTokenClientTraceDefinitions.exchangeToken, async ({ record }) => {
       const [channelId] = Activity.parseChannelId(channelIdComposite)
       const params = { userId, connectionName, channelId }
-      const response = await this.client.post('/api/usertoken/exchange', tokenExchangeRequest, { params })
+      const response = await this.executeRequest('post', '/api/usertoken/exchange', tokenExchangeRequest, { params })
       record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
       if (response?.data) {
         return response.data as TokenResponse
@@ -242,8 +210,8 @@ export class UserTokenClient {
       const [channelId] = Activity.parseChannelId(channelIdComposite)
       const state = Buffer.from(JSON.stringify({ conversation, relatesTo, connectionName, msAppId: this.msAppId })).toString('base64')
       const params = { userId, connectionName, channelId, state, code, finalRedirect, fwdUrl }
-      const response = await this.client.get('/api/usertoken/GetTokenOrSignInResource', { params })
-      record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
+      const response = await this.executeRequest('get', '/api/usertoken/GetTokenOrSignInResource', undefined, { params })
+      record({ userId, connectionName, channelId, httpStatusCode: response?.status?.toString() })
       return response.data as TokenOrSinginResourceResponse
     })
   }
@@ -259,7 +227,7 @@ export class UserTokenClient {
     return trace(UserTokenClientTraceDefinitions.getTokenStatus, async ({ record }) => {
       const [channelId] = Activity.parseChannelId(channelIdComposite)
       const params = { userId, channelId, include }
-      const response = await this.client.get('/api/usertoken/GetTokenStatus', { params })
+      const response = await this.executeRequest('get', '/api/usertoken/GetTokenStatus', undefined, { params })
       record({ userId, channelId, httpStatusCode: response.status?.toString() })
       return response.data as TokenStatus[]
     })
@@ -277,13 +245,64 @@ export class UserTokenClient {
     return trace(UserTokenClientTraceDefinitions.getAadTokens, async ({ record }) => {
       const [channelId] = Activity.parseChannelId(channelIdComposite)
       const params = { userId, connectionName, channelId }
-      const response = await this.client.post('/api/usertoken/GetAadTokens', resourceUrls, { params })
+      const response = await this.executeRequest('post', '/api/usertoken/GetAadTokens', resourceUrls, { params })
       record({ userId, connectionName, channelId, httpStatusCode: response.status?.toString() })
       return response.data as Record<string, TokenResponse>
     })
   }
 
   public updateAuthToken (token: string): void {
-    this.client.defaults.headers.common.Authorization = `Bearer ${token}`
+    this.client.setHeader('Authorization', `Bearer ${token}`)
+  }
+
+  private async executeRequest<T = unknown> (method: string, url: string, data?: unknown, options?: { params?: Record<string, string | undefined> }): Promise<{ data: T, status: number, statusText: string }> {
+    const { params } = options ?? {}
+    const { Authorization, authorization, ...headersToLog } = this.client.defaultHeaders
+    logger.debug('Request: ', {
+      host: this.client.baseURL,
+      url,
+      data,
+      method,
+      params,
+      headers: headersToLog
+    })
+
+    try {
+      const response = await this.client.request<T>({ method, url, data, params })
+      const { token: _token, ...redactedData } = (response.config?.data ?? {}) as Record<string, unknown>
+      logger.debug('Response: ', {
+        status: response.status,
+        statusText: response.statusText,
+        host: this.client.baseURL,
+        url: response.config?.url,
+        data: redactedData,
+        method: response.config?.method,
+      })
+      return response
+    } catch (error: any) {
+      if (error instanceof HttpError) {
+        const message = formatHttpErrorMessage(error)
+        const errorDetails = {
+          host: this.client.baseURL,
+          url: error.config.url,
+          method: error.config.method,
+          data: error.config.data,
+          message,
+          headers: error.response?.headers,
+          stack: error.stack,
+        }
+        logger.debug('Response error: ', errorDetails)
+
+        Object.assign(error, {
+          host: this.client.baseURL,
+          url: error.config.url,
+          method: error.config.method,
+          data: error.config.data,
+          headers: error.response?.headers,
+          message,
+        })
+      }
+      throw error
+    }
   }
 }