@microsoft/agents-hosting-extensions-msteams 1.7.0-beta.10.g0c6864b626

package/src/app/teamsAppExtensions.ts

@@ -0,0 +1,369 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Activity, ActivityTypes, Channels } from '@microsoft/agents-activity'
+import { AgentApplication, ConversationUpdateEvents, RouteHandler, RouteRank, RouteSelector, TurnContext, TurnState } from '@microsoft/agents-hosting'
+import { createTeamsRouteHandler, TeamsRouteHandler } from '../teamsRouteHandler'
+import { TeamsTurnContext } from '../teamsTurnContext'
+
+/**
+ * Value submitted by a Teams feedback loop action.
+ */
+export interface FeedbackActionValue {
+  /**
+   * Feedback reaction selected by the user.
+   */
+  reaction?: string;
+  /**
+   * Optional feedback text or structured feedback data.
+   */
+  feedback?: string | Record<string, unknown>;
+}
+
+/**
+ * Payload supplied to Teams feedback loop handlers.
+ */
+export interface FeedbackData {
+  /**
+   * Name of the submitted action.
+   */
+  actionName?: string;
+  /**
+   * Value submitted with the feedback action.
+   */
+  actionValue?: FeedbackActionValue;
+  /**
+   * ID of the activity that the feedback applies to.
+   */
+  replyToId?: string;
+}
+
+/**
+ * Handler for Teams handoff invoke activities.
+ */
+export type TeamsHandoffHandler<TState extends TurnState> = (context: TeamsTurnContext, state: TState, continuation: string) => Promise<void>
+/**
+ * Handler for Teams feedback loop invoke activities.
+ */
+export type TeamsFeedbackLoopHandler<TState extends TurnState> = (context: TeamsTurnContext, state: TState, feedbackData: FeedbackData) => Promise<void>
+
+function isTeamsRouteContext (context: TurnContext, isAgenticRoute: boolean): boolean {
+  return context.activity.channelId === Channels.Msteams &&
+    (!isAgenticRoute || (isAgenticRoute && context.activity.isAgenticRequest()))
+}
+
+function matchesValue (actual: string | undefined, expected: string | RegExp): boolean {
+  if (typeof expected === 'string') {
+    return expected.toLocaleLowerCase() === actual?.toLocaleLowerCase()
+  }
+
+  return actual != null && expected.test(actual)
+}
+
+function addTeamsRoute<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  selector: RouteSelector,
+  handler: RouteHandler<TState>,
+  isInvokeRoute: boolean,
+  rank: number,
+  authHandlers: string[],
+  isAgenticRoute: boolean
+): AgentApplication<TState> {
+  return app.addRoute(selector, handler, isInvokeRoute, rank, authHandlers, isAgenticRoute)
+}
+
+function addTeamsRouteHandler<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  selector: RouteSelector,
+  handler: TeamsRouteHandler<TState>,
+  rank: number,
+  authHandlers: string[],
+  isAgenticRoute: boolean
+): AgentApplication<TState> {
+  return addTeamsRoute(app, selector, createTeamsRouteHandler(handler), false, rank, authHandlers, isAgenticRoute)
+}
+
+function createInvokeResponse (): Activity {
+  const invokeResponse = new Activity(ActivityTypes.InvokeResponse)
+  invokeResponse.value = { status: 200 }
+  return invokeResponse
+}
+
+/**
+ * Registers a route that handles Teams activities by activity type.
+ *
+ * @param app - The agent application that receives the route.
+ * @param type - Activity type or regular expression to match.
+ * @param handler - Handler invoked with a Teams turn context and turn state.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsActivity<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  type: string | RegExp,
+  handler: TeamsRouteHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) =>
+    isTeamsRouteContext(context, isAgenticRoute) &&
+    matchesValue(context.activity.type, type)
+
+  return addTeamsRouteHandler(app, selector, handler, rank, authHandlers, isAgenticRoute)
+}
+
+/**
+ * Registers a route that handles Teams conversation update activities.
+ *
+ * @param app - The agent application that receives the route.
+ * @param event - Conversation update event name to match.
+ * @param handler - Handler invoked with a Teams turn context and turn state.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsConversationUpdate<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  event: ConversationUpdateEvents | string,
+  handler: TeamsRouteHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) => {
+    if (!isTeamsRouteContext(context, isAgenticRoute) ||
+      context.activity.type !== ActivityTypes.ConversationUpdate) {
+      return false
+    }
+
+    if (event === 'membersAdded') {
+      return Array.isArray(context.activity.membersAdded) && context.activity.membersAdded.length > 0
+    }
+
+    if (event === 'membersRemoved') {
+      return Array.isArray(context.activity.membersRemoved) && context.activity.membersRemoved.length > 0
+    }
+
+    return true
+  }
+
+  return addTeamsRouteHandler(app, selector, handler, rank, authHandlers, isAgenticRoute)
+}
+
+/**
+ * Registers a route that handles Teams message activities by text.
+ *
+ * @param app - The agent application that receives the route.
+ * @param text - Message text or regular expression to match.
+ * @param handler - Handler invoked with a Teams turn context and turn state.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsMessage<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  text: string | RegExp,
+  handler: TeamsRouteHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) =>
+    isTeamsRouteContext(context, isAgenticRoute) &&
+    context.activity.type === ActivityTypes.Message &&
+    matchesValue(context.activity.text, text)
+
+  return addTeamsRouteHandler(app, selector, handler, rank, authHandlers, isAgenticRoute)
+}
+
+/**
+ * Registers a route that handles Teams event activities by event name.
+ *
+ * @param app - The agent application that receives the route.
+ * @param name - Event name or regular expression to match.
+ * @param handler - Handler invoked with a Teams turn context and turn state.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsEvent<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  name: string | RegExp,
+  handler: TeamsRouteHandler<TState>,
+  rank?: number,
+  authHandlers?: string[],
+  isAgenticRoute?: boolean
+): AgentApplication<TState>
+/**
+ * Registers a route that handles Teams event activities by custom selector.
+ *
+ * @param app - The agent application that receives the route.
+ * @param selector - Selector used to decide whether the route should run.
+ * @param handler - Handler invoked with a Teams turn context and turn state.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsEvent<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  selector: RouteSelector,
+  handler: TeamsRouteHandler<TState>,
+  rank?: number,
+  authHandlers?: string[],
+  isAgenticRoute?: boolean
+): AgentApplication<TState>
+export function onTeamsEvent<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  nameOrSelector: string | RegExp | RouteSelector,
+  handler: TeamsRouteHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) => {
+    if (!isTeamsRouteContext(context, isAgenticRoute) ||
+      context.activity.type !== ActivityTypes.Event) {
+      return false
+    }
+
+    if (typeof nameOrSelector === 'function') {
+      return await nameOrSelector(context)
+    }
+
+    return matchesValue(context.activity.name, nameOrSelector)
+  }
+
+  return addTeamsRouteHandler(app, selector, handler, rank, authHandlers, isAgenticRoute)
+}
+
+/**
+ * Registers a route that handles Teams message reaction added activities.
+ *
+ * @param app - The agent application that receives the route.
+ * @param handler - Handler invoked with a Teams turn context and turn state.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsMessageReactionsAdded<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  handler: TeamsRouteHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) =>
+    isTeamsRouteContext(context, isAgenticRoute) &&
+    context.activity.type === ActivityTypes.MessageReaction &&
+    Array.isArray(context.activity.reactionsAdded) &&
+    context.activity.reactionsAdded.length > 0
+
+  return addTeamsRouteHandler(app, selector, handler, rank, authHandlers, isAgenticRoute)
+}
+
+/**
+ * Registers a route that handles Teams message reaction removed activities.
+ *
+ * @param app - The agent application that receives the route.
+ * @param handler - Handler invoked with a Teams turn context and turn state.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsMessageReactionsRemoved<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  handler: TeamsRouteHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) =>
+    isTeamsRouteContext(context, isAgenticRoute) &&
+    context.activity.type === ActivityTypes.MessageReaction &&
+    Array.isArray(context.activity.reactionsRemoved) &&
+    context.activity.reactionsRemoved.length > 0
+
+  return addTeamsRouteHandler(app, selector, handler, rank, authHandlers, isAgenticRoute)
+}
+
+/**
+ * Registers a route that handles Teams handoff invoke activities.
+ *
+ * @param app - The agent application that receives the route.
+ * @param handler - Handler invoked with the handoff continuation value.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsHandoff<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  handler: TeamsHandoffHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) =>
+    isTeamsRouteContext(context, isAgenticRoute) &&
+    context.activity.type === ActivityTypes.Invoke &&
+    context.activity.name?.toLocaleLowerCase() === 'handoff/action'
+
+  const routeHandler: RouteHandler<TState> = async (context, state) => {
+    const value = context.activity.value as { continuation?: unknown, Continuation?: unknown } | undefined
+    const continuation = typeof value?.continuation === 'string'
+      ? value.continuation
+      : typeof value?.Continuation === 'string' ? value.Continuation : ''
+
+    await handler(new TeamsTurnContext(context), state, continuation)
+    await context.sendActivity(createInvokeResponse())
+  }
+
+  return addTeamsRoute(app, selector, routeHandler, true, rank, authHandlers, isAgenticRoute)
+}
+
+/**
+ * Registers a route that handles Teams feedback loop invoke activities.
+ *
+ * @param app - The agent application that receives the route.
+ * @param handler - Handler invoked with feedback loop data.
+ * @param rank - Optional route rank used for route ordering.
+ * @param authHandlers - Optional authorization handlers required by the route.
+ * @param isAgenticRoute - Indicates whether the route should handle agentic requests only.
+ * @returns The agent application for chaining.
+ */
+export function onTeamsFeedbackLoop<TState extends TurnState> (
+  app: AgentApplication<TState>,
+  handler: TeamsFeedbackLoopHandler<TState>,
+  rank: number = RouteRank.Unspecified,
+  authHandlers: string[] = [],
+  isAgenticRoute: boolean = false
+): AgentApplication<TState> {
+  const selector: RouteSelector = async (context) => {
+    const actionName = (context.activity.value as { actionName?: unknown } | undefined)?.actionName
+    return isTeamsRouteContext(context, isAgenticRoute) &&
+      context.activity.type === ActivityTypes.Invoke &&
+      context.activity.name === 'message/submitAction' &&
+      actionName === 'feedback'
+  }
+
+  const routeHandler: RouteHandler<TState> = async (context, state) => {
+    const feedbackData = {
+      ...(context.activity.value as FeedbackData),
+      replyToId: context.activity.replyToId
+    }
+
+    await handler(new TeamsTurnContext(context), state, feedbackData)
+    await context.sendActivity(createInvokeResponse())
+  }
+
+  return addTeamsRoute(app, selector, routeHandler, true, rank, authHandlers, isAgenticRoute)
+}

package/src/channels/index.ts

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export * from './teamsChannel'

package/src/channels/teamsChannel.ts

@@ -0,0 +1,229 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { ActivityTypes } from '@microsoft/agents-activity'
+import { AgentApplication, RouteHandler, RouteRank, RouteSelector, TurnContext, TurnState } from '@microsoft/agents-hosting'
+import { parseTeamsChannelData } from '../activity-extensions'
+import type { ChannelInfo } from '@microsoft/teams.api'
+import { TeamsTurnContext } from '../teamsTurnContext'
+
+const CHANNEL_CREATED_EVENT = 'channelCreated'
+const CHANNEL_DELETED_EVENT = 'channelDeleted'
+const CHANNEL_RENAMED_EVENT = 'channelRenamed'
+const CHANNEL_RESTORED_EVENT = 'channelRestored'
+const CHANNEL_SHARED_EVENT = 'channelShared'
+const CHANNEL_UNSHARED_EVENT = 'channelUnshared'
+const CHANNEL_MEMBER_ADDED_EVENT = 'channelMemberAdded'
+const CHANNEL_MEMBER_REMOVED_EVENT = 'channelMemberRemoved'
+
+type ChannelUpdateHandler<TState extends TurnState> = (context: TeamsTurnContext, state: TState, data: ChannelInfo) => Promise<void>
+
+function isChannelUpdateEvent (context: TurnContext, eventType?: string): boolean {
+  const channelData = parseTeamsChannelData(context.activity.channelData)
+  const actualEventType = typeof channelData?.eventType === 'string' ? channelData.eventType.toLowerCase() : undefined
+  const expectedEventType = eventType?.toLowerCase()
+
+  return (
+    context.activity.type === ActivityTypes.ConversationUpdate &&
+    context.activity.channelId === 'msteams' &&
+    channelData?.channel != null &&
+    (
+      expectedEventType != null
+        ? actualEventType === expectedEventType
+        : actualEventType?.startsWith('channel') === true
+    )
+  )
+}
+
+function getChannelInfo (context: TurnContext): ChannelInfo {
+  return parseTeamsChannelData(context.activity.channelData).channel as ChannelInfo
+}
+
+/**
+ * Registers handlers for Microsoft Teams channel lifecycle and membership events.
+ *
+ * @typeParam TState - The turn state type used by the agent application.
+ */
+export class TeamsChannel<TState extends TurnState = TurnState> {
+  private _app: AgentApplication<TState>
+
+  /**
+   * Creates a Teams channel route helper.
+   *
+   * @param app - The agent application that receives the registered routes.
+   */
+  constructor (app: AgentApplication<TState>) {
+    this._app = app
+  }
+
+  /**
+   * Registers a handler for any Teams channel update event.
+   *
+   * @param handler - Handler invoked with the Teams turn context, turn state, and channel information.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onChannelEventReceived (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for Teams channel created events.
+   *
+   * @param handler - Handler invoked with the created channel information.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onCreated (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_CREATED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for Teams channel deleted events.
+   *
+   * @param handler - Handler invoked with the deleted channel information.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onDeleted (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_DELETED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for Teams channel renamed events.
+   *
+   * @param handler - Handler invoked with the renamed channel information.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onRenamed (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_RENAMED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for Teams channel restored events.
+   *
+   * @param handler - Handler invoked with the restored channel information.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onRestored (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_RESTORED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for Teams channel shared events.
+   *
+   * @param handler - Handler invoked with the shared channel information.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onShared (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_SHARED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for Teams channel unshared events.
+   *
+   * @param handler - Handler invoked with the unshared channel information.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onUnshared (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_UNSHARED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for member-added events in a Teams channel.
+   *
+   * @param handler - Handler invoked with channel information for the membership event.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onMemberAdded (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_MEMBER_ADDED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for member-removed events in a Teams channel.
+   *
+   * @param handler - Handler invoked with channel information for the membership event.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This channel helper for chaining.
+   */
+  onMemberRemoved (handler: ChannelUpdateHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(isChannelUpdateEvent(context, CHANNEL_MEMBER_REMOVED_EVENT))
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      await handler(new TeamsTurnContext(context), state, getChannelInfo(context))
+    }
+    this._app.addRoute(routeSel, routeHandler, false, rank, authHandlers)
+    return this
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Activity, ActivityTypes } from '@microsoft/agents-activity'
+import { AgentApplication, RouteHandler, RouteRank, RouteSelector, TurnContext, TurnState } from '@microsoft/agents-hosting'
+import type { ConfigResponse } from '@microsoft/teams.api'
+import { TeamsTurnContext } from '../teamsTurnContext'
+
+type ConfigHandler<TState extends TurnState> = (context: TeamsTurnContext, state: TState, configData: unknown) => Promise<ConfigResponse>
+
+/**
+ * Registers handlers for Microsoft Teams app configuration invokes.
+ *
+ * @typeParam TState - The turn state type used by the agent application.
+ */
+export class TeamsConfig<TState extends TurnState = TurnState> {
+  private _app: AgentApplication<TState>
+
+  /**
+   * Creates a Teams configuration route helper.
+   *
+   * @param app - The agent application that receives the registered routes.
+   */
+  constructor (app: AgentApplication<TState>) {
+    this._app = app
+  }
+
+  /**
+   * Registers a handler for Teams config/fetch invokes.
+   *
+   * @param handler - Handler invoked with the config fetch payload.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This config helper for chaining.
+   */
+  onConfigFetch (handler: ConfigHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(
+        context.activity.type === ActivityTypes.Invoke &&
+        context.activity.channelId === 'msteams' &&
+        context.activity.name === 'config/fetch'
+      )
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      const response: ConfigResponse = await handler(new TeamsTurnContext(context), state, context.activity.value)
+      const invokeResponse = new Activity(ActivityTypes.InvokeResponse)
+      invokeResponse.value = { status: 200, body: response }
+      await context.sendActivity(invokeResponse)
+    }
+    this._app.addRoute(routeSel, routeHandler, true, rank, authHandlers)
+    return this
+  }
+
+  /**
+   * Registers a handler for Teams config/submit invokes.
+   *
+   * @param handler - Handler invoked with the config submit payload.
+   * @param rank - Optional route rank used for route ordering.
+   * @param authHandlers - Optional authorization handlers required by the route.
+   * @returns This config helper for chaining.
+   */
+  onConfigSubmit (handler: ConfigHandler<TState>, rank: number = RouteRank.Unspecified, authHandlers: string[] = []) {
+    const routeSel: RouteSelector = (context: TurnContext) => {
+      return Promise.resolve(
+        context.activity.type === ActivityTypes.Invoke &&
+        context.activity.channelId === 'msteams' &&
+        context.activity.name === 'config/submit'
+      )
+    }
+    const routeHandler: RouteHandler<TState> = async (context: TurnContext, state: TState) => {
+      const response: ConfigResponse = await handler(new TeamsTurnContext(context), state, context.activity.value)
+      const invokeResponse = new Activity(ActivityTypes.InvokeResponse)
+      invokeResponse.value = { status: 200, body: response }
+      await context.sendActivity(invokeResponse)
+    }
+    this._app.addRoute(routeSel, routeHandler, true, rank, authHandlers)
+    return this
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export * from './config'