port: update and delete activities from skill handler

libraries/botbuilder-core/src/transcriptLogger.ts

@@ -12,6 +12,7 @@ import {
     ActivityTypes,
     ConversationReference,
     ResourceResponse,
+    RoleTypes,
 } from 'botframework-schema';
 import { Middleware } from './middlewareSet';
 import { TurnContext } from './turnContext';
@@ -45,7 +46,7 @@ export class TranscriptLoggerMiddleware implements Middleware {
         // log incoming activity at beginning of turn
         if (context.activity) {
             if (!context.activity.from.role) {
-                context.activity.from.role = 'user';
+                context.activity.from.role = RoleTypes.User;
             }
 
             this.logActivity(transcript, this.cloneActivity(context.activity));

libraries/botbuilder/src/botFrameworkAdapter.ts

@@ -1702,7 +1702,7 @@ export class BotFrameworkAdapter
      * Override this in a derived class to modify how the adapter creates a turn context.
      */
     protected createContext(request: Partial<Activity>): TurnContext {
-        return new TurnContext(this as any, request);
+        return new TurnContext(this, request);
     }
 
     /**

libraries/botbuilder/src/botFrameworkHttpClient.ts

@@ -7,7 +7,7 @@
  */
 
 import axios from 'axios';
-import { Activity, BotFrameworkClient, InvokeResponse } from 'botbuilder-core';
+import { Activity, BotFrameworkClient, ChannelAccount, InvokeResponse, RoleTypes } from 'botbuilder-core';
 import {
     AuthenticationConstants,
     AppCredentials,
@@ -58,33 +58,6 @@ export class BotFrameworkHttpClient implements BotFrameworkClient {
      * @param conversationId A conversation ID to use for the conversation with the skill.
      * @param activity Activity to forward.
      */
-    public async postActivity<T>(
-        fromBotId: string,
-        toBotId: string,
-        toUrl: string,
-        serviceUrl: string,
-        conversationId: string,
-        activity: Activity
-    ): Promise<InvokeResponse<T>>;
-    public async postActivity(
-        fromBotId: string,
-        toBotId: string,
-        toUrl: string,
-        serviceUrl: string,
-        conversationId: string,
-        activity: Activity
-    ): Promise<InvokeResponse>;
- /**
-     * Forwards an activity to another bot.
-     * @template T The type of body in the [InvokeResponse](xref:botbuilder-core.InvokeResponse). 
-     * @param fromBotId The MicrosoftAppId of the bot sending the activity.
-     * @param toBotId The MicrosoftAppId of the bot receiving the activity.
-     * @param toUrl The URL of the bot receiving the activity.
-     * @param serviceUrl The callback Url for the skill host.
-     * @param conversationId A conversation ID to use for the conversation with the skill.
-     * @param activity [Activity](xref:botframework-schema.Activity) to forward.
-     * @returns A `Promise` representing the [InvokeResponse](xref:botbuilder-core.InvokeResponse) for the operation.
-     */                              
     public async postActivity<T = any>(
         fromBotId: string,
         toBotId: string,
@@ -117,6 +90,7 @@ export class BotFrameworkHttpClient implements BotFrameworkClient {
         const originalServiceUrl = activity.serviceUrl;
         const originalRelatesTo = activity.relatesTo;
         const originalRecipient = activity.recipient;
+
         try {
             activity.relatesTo = {
                 serviceUrl: activity.serviceUrl,
@@ -139,10 +113,11 @@ export class BotFrameworkHttpClient implements BotFrameworkClient {
 
             // Fixes: https://github.com/microsoft/botframework-sdk/issues/5785
             if (!activity.recipient) {
-                activity.recipient = {} as any;
+                activity.recipient = {} as ChannelAccount;
             }
+            activity.recipient.role = RoleTypes.Skill;
 
-            const config = {
+            const config: { headers: Record<string, string>; validateStatus: () => boolean } = {
                 headers: {
                     Accept: 'application/json',
                     'Content-Type': 'application/json',
@@ -152,13 +127,11 @@ export class BotFrameworkHttpClient implements BotFrameworkClient {
             };
 
             if (token) {
-                config.headers['Authorization'] = `Bearer ${token}`;
+                config.headers.Authorization = `Bearer ${token}`;
             }
 
-            const response = await axios.post(toUrl, activity, config);
-            const invokeResponse: InvokeResponse<T> = { status: response.status, body: response.data };
-
-            return invokeResponse;
+            const response = await axios.post<T>(toUrl, activity, config);
+            return { status: response.status, body: response.data };
         } finally {
             // Restore activity properties.
             activity.conversation.id = originalConversationId;
@@ -177,14 +150,13 @@ export class BotFrameworkHttpClient implements BotFrameworkClient {
      */
     protected async buildCredentials(appId: string, oAuthScope?: string): Promise<AppCredentials> {
         const appPassword = await this.credentialProvider.getAppPassword(appId);
-        let appCredentials;
         if (JwtTokenValidation.isGovernment(this.channelService)) {
-            appCredentials = new MicrosoftAppCredentials(appId, appPassword, undefined, oAuthScope);
+            const appCredentials = new MicrosoftAppCredentials(appId, appPassword, undefined, oAuthScope);
             appCredentials.oAuthEndpoint = GovernmentConstants.ToChannelFromBotLoginUrl;
+            return appCredentials;
         } else {
-            appCredentials = new MicrosoftAppCredentials(appId, appPassword, undefined, oAuthScope);
+            return new MicrosoftAppCredentials(appId, appPassword, undefined, oAuthScope);
         }
-        return appCredentials;
     }
 
     /**
@@ -206,7 +178,7 @@ export class BotFrameworkHttpClient implements BotFrameworkClient {
         }
 
         // Credentials not found in cache, build them
-        appCredentials = (await this.buildCredentials(appId, oAuthScope)) as MicrosoftAppCredentials;
+        appCredentials = await this.buildCredentials(appId, oAuthScope);
 
         // Cache the credentials for later use
         BotFrameworkHttpClient.appCredentialMapCache.set(cacheKey, appCredentials);

libraries/botbuilder/src/channelServiceHandler.ts

@@ -26,6 +26,7 @@ import {
     ClaimsIdentity,
     ICredentialProvider,
     JwtTokenValidation,
+    SkillValidation,
 } from 'botframework-connector';
 import { StatusCodeError } from './statusCodeError';
 
@@ -597,27 +598,26 @@ export class ChannelServiceHandler {
      * @private
      */
     private async authenticate(authHeader: string): Promise<ClaimsIdentity> {
-        try {
-            if (!authHeader) {
-                const isAuthDisable = this.credentialProvider.isAuthenticationDisabled();
-                if (isAuthDisable) {
-                    // In the scenario where Auth is disabled, we still want to have the
-                    // IsAuthenticated flag set in the ClaimsIdentity. To do this requires
-                    // adding in an empty claim.
-                    return new ClaimsIdentity([], false);
-                }
+        if (!authHeader) {
+            const isAuthDisabled = await this.credentialProvider.isAuthenticationDisabled();
+            if (!isAuthDisabled) {
+                throw new StatusCodeError(StatusCodes.UNAUTHORIZED);
             }
 
-            return await JwtTokenValidation.validateAuthHeader(
-                authHeader,
-                this.credentialProvider,
-                this.channelService,
-                'unknown',
-                undefined,
-                this.authConfig
-            );
-        } catch (err) {
-            throw new StatusCodeError(StatusCodes.UNAUTHORIZED);
+            // In the scenario where Auth is disabled, we still want to have the
+            // IsAuthenticated flag set in the ClaimsIdentity. To do this requires
+            // adding in an empty claim.
+            // Since ChannelServiceHandler calls are always a skill callback call, we set the skill claim too.
+            return SkillValidation.createAnonymousSkillClaim();
         }
+
+        return JwtTokenValidation.validateAuthHeader(
+            authHeader,
+            this.credentialProvider,
+            this.channelService,
+            'unknown',
+            undefined,
+            this.authConfig
+        );
     }
 }

libraries/botbuilder/src/eventFactory.ts

@@ -18,9 +18,9 @@ export class EventFactory {
      * @param handoffContext Agent hub-specific context.
      * @param transcript Transcript of the conversation.
      */
-    public static createHandoffInitiation(
+    public static createHandoffInitiation<T = unknown>(
         context: TurnContext,
-        handoffContext: any,
+        handoffContext: T,
         transcript?: Transcript
     ): Activity {
         if (!context) {
@@ -30,7 +30,7 @@ export class EventFactory {
         const handoffEvent = this.createHandoffEvent(
             HandoffEventNames.InitiateHandoff,
             handoffContext,
-            context.activity.conversation
+            context.activity.conversation as ConversationAccount // TODO(joshgummersall) why is this necessary?
         );
 
         handoffEvent.from = context.activity.from;
@@ -66,18 +66,18 @@ export class EventFactory {
             throw new TypeError('EventFactory.createHandoffStatus(): missing state.');
         }
 
-        const value: any = { state, message };
-
-        const handoffEvent = this.createHandoffEvent(HandoffEventNames.HandoffStatus, value, conversation);
-
-        return handoffEvent;
+        return this.createHandoffEvent(HandoffEventNames.HandoffStatus, { state, message }, conversation);
     }
 
     /**
      * @private
      */
-    private static createHandoffEvent(name: string, value: any, conversation: ConversationAccount): Activity {
-        const handoffEvent: Activity = {} as any;
+    private static createHandoffEvent<T = unknown>(
+        name: string,
+        value: T,
+        conversation: ConversationAccount
+    ): Activity {
+        const handoffEvent: Partial<Activity> = {};
 
         handoffEvent.name = name;
         handoffEvent.value = value;
@@ -90,7 +90,7 @@ export class EventFactory {
         handoffEvent.attachments = [];
         handoffEvent.entities = [];
 
-        return handoffEvent;
+        return handoffEvent as Activity;
     }
 }