feat: cloud adapter

libraries/botbuilder-ai/src/luisRecognizer.ts

@@ -237,9 +237,13 @@ export interface LuisRecognizerOptionsV2 extends LuisRecognizerOptions {
 // This zod type is purely used for type assertions in a scenario where we
 // know better than the compiler does that we'll have a value of this type.
 // This is just meant to operate as a simple type assertion.
-const UnsafeLuisRecognizerUnion: z.ZodType<
-    LuisRecognizerOptionsV2 | LuisRecognizerOptionsV3 | LuisPredictionOptions
-> = z.record(z.unknown());
+const UnsafeLuisRecognizerUnion = z.custom<LuisRecognizerOptionsV3 | LuisRecognizerOptionsV2 | LuisPredictionOptions>(
+    (val: unknown): val is LuisRecognizerOptionsV3 | LuisRecognizerOptionsV2 | LuisPredictionOptions =>
+        z.record(z.unknown()).check(val),
+    {
+        message: 'LuisRecognizerOptionsV3 | LuisRecognizerOptionsV2 | LuisPredictionOptions',
+    }
+);
 
 /**
  * Recognize intents in a user utterance using a configured LUIS model.

libraries/botbuilder-ai/src/luisRecognizerOptionsV3.ts

@@ -113,6 +113,7 @@ export class LuisRecognizerV3 extends LuisRecognizerInternal {
                                             if (
                                                 z
                                                     .object({ startIndex: z.number(), endIndex: z.number() })
+                                                    .nonstrict()
                                                     .check(childInstance)
                                             ) {
                                                 const start = childInstance.startIndex;

libraries/botbuilder-azure-blobs/src/blobsTranscriptStore.ts

@@ -34,7 +34,10 @@ function getConversationPrefix(channelId: string, conversationId: string): strin
 
 // Formats an activity as a blob key
 function getBlobKey(activity: Activity): string {
-    const { timestamp } = z.object({ timestamp: z.instanceof(Date) }).parse(activity);
+    const { timestamp } = z
+        .object({ timestamp: z.instanceof(Date) })
+        .nonstrict()
+        .parse(activity);
 
     return sanitizeBlobKey(
         [activity.channelId, activity.conversation.id, `${formatTicks(timestamp)}-${activity.id}.json`].join('/')

libraries/botbuilder-core/etc/botbuilder-core.api.md

@@ -11,11 +11,17 @@ import { AnimationCard } from 'botframework-schema';
 import { Assertion } from 'botbuilder-stdlib';
 import { Attachment } from 'botframework-schema';
 import { AudioCard } from 'botframework-schema';
+import { AuthenticateRequestResult } from 'botframework-connector';
+import { AuthenticationConfiguration } from 'botframework-connector';
+import { BotFrameworkAuthentication } from 'botframework-connector';
 import { BotFrameworkClient } from 'botframework-connector';
 import { CardAction } from 'botframework-schema';
 import { CardImage } from 'botframework-schema';
 import { ChannelAccount } from 'botframework-schema';
+import { ClaimsIdentity } from 'botframework-connector';
 import { Configuration } from 'botbuilder-dialogs-adaptive-runtime-core';
+import { ConnectorClientOptions } from 'botframework-connector';
+import { ConnectorFactory } from 'botframework-connector';
 import { ConversationReference } from 'botframework-schema';
 import { HeroCard } from 'botframework-schema';
 import { InputHints } from 'botframework-schema';
@@ -24,16 +30,20 @@ import { MediaUrl } from 'botframework-schema';
 import { Mention } from 'botframework-schema';
 import { MessageReaction } from 'botframework-schema';
 import { O365ConnectorCard } from 'botframework-schema';
+import { PasswordServiceClientCredentialFactory } from 'botframework-connector';
 import { ReceiptCard } from 'botframework-schema';
 import { ResourceResponse } from 'botframework-schema';
+import { ServiceClientCredentialsFactory } from 'botframework-connector';
 import { ServiceCollection } from 'botbuilder-dialogs-adaptive-runtime-core';
 import { SignInUrlResponse } from 'botframework-schema';
 import { StatusCodes } from 'botframework-schema';
 import { ThumbnailCard } from 'botframework-schema';
 import { TokenExchangeRequest } from 'botframework-schema';
 import { TokenExchangeResource } from 'botframework-schema';
 import { TokenResponse } from 'botframework-schema';
+import { UserTokenClient } from 'botframework-connector';
 import { VideoCard } from 'botframework-schema';
+import * as z from 'zod';
 
 // @public
 export class ActivityFactory {
@@ -135,7 +145,12 @@ export class AutoSaveStateMiddleware implements Middleware {
 export abstract class BotAdapter {
     // (undocumented)
     readonly BotIdentityKey: symbol;
+    // (undocumented)
+    readonly ConnectorClientKey: symbol;
     abstract continueConversation(reference: Partial<ConversationReference>, logic: (revocableContext: TurnContext) => Promise<void>): Promise<void>;
+    continueConversationAsync(botAppId: string, reference: Partial<ConversationReference>, logic: (context: TurnContext) => Promise<void>): Promise<void>;
+    continueConversationAsync(claimsIdentity: ClaimsIdentity, reference: Partial<ConversationReference>, logic: (context: TurnContext) => Promise<void>): Promise<void>;
+    continueConversationAsync(claimsIdentity: ClaimsIdentity, reference: Partial<ConversationReference>, audience: string, logic: (context: TurnContext) => Promise<void>): Promise<void>;
     abstract deleteActivity(context: TurnContext, reference: Partial<ConversationReference>): Promise<void>;
     // (undocumented)
     protected middleware: MiddlewareSet;
@@ -273,12 +288,69 @@ export class CardFactory {
     static videoCard(title: string, media: (MediaUrl | string)[], buttons?: (CardAction | string)[], other?: Partial<VideoCard>): Attachment;
 }
 
+// @public (undocumented)
+export abstract class CloudAdapterBase extends BotAdapter {
+    constructor(botFrameworkAuthentication: BotFrameworkAuthentication);
+    // (undocumented)
+    protected readonly botFrameworkAuthentication: BotFrameworkAuthentication;
+    // (undocumented)
+    readonly ConnectorFactoryKey: symbol;
+    // @deprecated (undocumented)
+    continueConversation(reference: Partial<ConversationReference>, logic: (context: TurnContext) => Promise<void>): Promise<void>;
+    // @internal (undocumented)
+    continueConversationAsync(botAppIdOrClaimsIdentity: string | ClaimsIdentity, reference: Partial<ConversationReference>, logicOrAudience: ((context: TurnContext) => Promise<void>) | string, maybeLogic?: (context: TurnContext) => Promise<void>): Promise<void>;
+    protected createClaimsIdentity(botAppId?: string): ClaimsIdentity;
+    // (undocumented)
+    deleteActivity(context: TurnContext, reference: Partial<ConversationReference>): Promise<void>;
+    protected processActivity(authHeader: string, activity: Activity, logic: (context: TurnContext) => Promise<void>): Promise<InvokeResponse | undefined>;
+    protected processActivity(authenticateRequestResult: AuthenticateRequestResult, activity: Activity, logic: (context: TurnContext) => Promise<void>): Promise<InvokeResponse | undefined>;
+    protected processProactive(claimsIdentity: ClaimsIdentity, continuationActivity: Partial<Activity>, audience: string | undefined, logic: (context: TurnContext) => Promise<void>): Promise<void>;
+    // (undocumented)
+    sendActivities(context: TurnContext, activities: Partial<Activity>[]): Promise<ResourceResponse[]>;
+    // (undocumented)
+    updateActivity(context: TurnContext, activity: Partial<Activity>): Promise<ResourceResponse | void>;
+    // (undocumented)
+    readonly UserTokenClientKey: symbol;
+}
+
 // @public
 export class ComponentRegistration {
     static add(componentRegistration: ComponentRegistration): void;
     static get components(): ComponentRegistration[];
     }
 
+// @public
+export class ConfigurationBotFrameworkAuthentication extends BotFrameworkAuthentication {
+    constructor(botFrameworkAuthConfig?: ConfigurationBotFrameworkAuthenticationOptions, credentialsFactory?: ServiceClientCredentialsFactory, authConfiguration?: AuthenticationConfiguration, botFrameworkClientFetch?: (input: RequestInfo, init?: RequestInit) => Promise<Response>, connectorClientOptions?: ConnectorClientOptions);
+    // (undocumented)
+    authenticateChannelRequest(authHeader: string): Promise<ClaimsIdentity>;
+    // (undocumented)
+    authenticateRequest(activity: Activity, authHeader: string): Promise<AuthenticateRequestResult>;
+    // (undocumented)
+    authenticateStreamingRequest(authHeader: string, channelIdHeader: string): Promise<AuthenticateRequestResult>;
+    // (undocumented)
+    createBotFrameworkClient(): BotFrameworkClient;
+    // (undocumented)
+    createConnectorFactory(claimsIdentity: ClaimsIdentity): ConnectorFactory;
+    // (undocumented)
+    createUserTokenClient(claimsIdentity: ClaimsIdentity): Promise<UserTokenClient>;
+    }
+
+// Warning: (ae-forgotten-export) The symbol "TypedOptions" needs to be exported by the entry point index.d.ts
+//
+// @public
+export type ConfigurationBotFrameworkAuthenticationOptions = z.infer<typeof TypedOptions>;
+
+// @public
+export class ConfigurationServiceClientCredentialFactory extends PasswordServiceClientCredentialFactory {
+    constructor(factoryOptions?: ConfigurationServiceClientCredentialFactoryOptions);
+}
+
+// Warning: (ae-forgotten-export) The symbol "TypedConfig" needs to be exported by the entry point index.d.ts
+//
+// @public
+export type ConfigurationServiceClientCredentialFactoryOptions = z.infer<typeof TypedConfig>;
+
 // @public
 export class ConsoleTranscriptLogger implements TranscriptLogger {
     logActivity(activity: Activity): void | Promise<void>;
@@ -296,6 +368,12 @@ export interface CoreAppCredentials {
     signRequest(webResource: CoreWebResource): Promise<CoreWebResource>;
 }
 
+// @public
+export function createBotFrameworkAuthenticationFromConfiguration(configuration: Configuration, credentialsFactory?: ServiceClientCredentialsFactory, authConfiguration?: AuthenticationConfiguration, botFrameworkClientFetch?: (input: RequestInfo, init?: RequestInit) => Promise<Response>, connectorClientOptions?: ConnectorClientOptions): BotFrameworkAuthentication;
+
+// @public
+export function createServiceClientCredentialFactoryFromConfiguration(configuration: Configuration): ConfigurationServiceClientCredentialFactory;
+
 // @public
 export type DeleteActivityHandler = (context: TurnContext, reference: Partial<ConversationReference>, next: () => Promise<void>) => Promise<void>;
 

libraries/botbuilder-core/package.json

@@ -31,7 +31,8 @@
     "botbuilder-stdlib": "4.1.6",
     "botframework-connector": "4.1.6",
     "botframework-schema": "4.1.6",
-    "uuid": "^8.3.2"
+    "uuid": "^8.3.2",
+    "zod": "~1.11.17"
   },
   "devDependencies": {
     "chatdown": "^1.2.4",

libraries/botbuilder-core/src/activityHandler.ts

@@ -3,20 +3,20 @@
  * Licensed under the MIT License.
  */
 
+import { ActivityHandlerBase } from './activityHandlerBase';
+import { InvokeException } from './invokeException';
+import { InvokeResponse } from './invokeResponse';
+import { TurnContext } from './turnContext';
+import { verifyStateOperationName, tokenExchangeOperationName, tokenResponseEventName } from './signInConstants';
+
 import {
     Activity,
     AdaptiveCardInvokeResponse,
     AdaptiveCardInvokeValue,
     MessageReaction,
+    StatusCodes,
 } from 'botframework-schema';
 
-import { ActivityHandlerBase } from './activityHandlerBase';
-import { InvokeException } from './invokeException';
-import { InvokeResponse } from './invokeResponse';
-import { StatusCodes } from './statusCodes';
-import { TurnContext } from './turnContext';
-import { verifyStateOperationName, tokenExchangeOperationName, tokenResponseEventName } from './signInConstants';
-
 /**
  * Describes a bot activity event handler, for use with an [ActivityHandler](xref:botbuilder-core.ActivityHandler) object.
  *

libraries/botbuilder-core/src/activityHandlerBase.ts

@@ -4,7 +4,7 @@
  */
 import { ActivityTypes, ChannelAccount, MessageReaction, TurnContext } from '.';
 import { InvokeResponse } from './invokeResponse';
-import { StatusCodes } from './statusCodes';
+import { StatusCodes } from 'botframework-schema';
 
 // This key is exported internally so that subclassed ActivityHandlers and BotAdapters will not override any already set InvokeResponses.
 export const INVOKE_RESPONSE_KEY = Symbol('invokeResponse');

libraries/botbuilder-core/src/botAdapter.ts

@@ -2,6 +2,7 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
+import { ClaimsIdentity } from 'botframework-connector';
 import { Activity, ConversationReference, ResourceResponse } from 'botframework-schema';
 import { makeRevocable } from './internal';
 import { Middleware, MiddlewareHandler, MiddlewareSet } from './middlewareSet';
@@ -28,9 +29,12 @@ import { TurnContext } from './turnContext';
  */
 export abstract class BotAdapter {
     protected middleware: MiddlewareSet = new MiddlewareSet();
+
     private turnError: (context: TurnContext, error: Error) => Promise<void>;
-    public readonly BotIdentityKey: symbol = Symbol('BotIdentity');
-    public readonly OAuthScopeKey: symbol = Symbol('OAuthScope');
+
+    public readonly BotIdentityKey = Symbol('BotIdentity');
+    public readonly ConnectorClientKey = Symbol('ConnectorClient');
+    public readonly OAuthScopeKey = Symbol('OAuthScope');
 
     /**
      * Asynchronously sends a set of outgoing activities to a channel server.
@@ -97,6 +101,62 @@ export abstract class BotAdapter {
         logic: (revocableContext: TurnContext) => Promise<void>
     ): Promise<void>;
 
+    /**
+     * Asynchronously resumes a conversation with a user, possibly after some time has gone by.
+     *
+     * @param botAppId The application ID of the bot. This parameter is ignored in single tenant the Adapters (Console,Test, etc) but is critical to the BotFrameworkAdapter which is multi-tenant aware.
+     * @param reference A partial [ConversationReference](xref:botframework-schema.ConversationReference) to the conversation to continue.
+     * @param logic The asynchronous method to call after the adapter middleware runs.
+     * @returns a promise representing the async operation
+     */
+    continueConversationAsync(
+        botAppId: string,
+        reference: Partial<ConversationReference>,
+        logic: (context: TurnContext) => Promise<void>
+    ): Promise<void>;
+
+    /**
+     * Asynchronously resumes a conversation with a user, possibly after some time has gone by.
+     *
+     * @param claimsIdentity A [ClaimsIdentity](xref:botframework-connector) for the conversation.
+     * @param reference A partial [ConversationReference](xref:botframework-schema.ConversationReference) to the conversation to continue.
+     * @param logic The asynchronous method to call after the adapter middleware runs.
+     * @returns a promise representing the async operation
+     */
+    continueConversationAsync(
+        claimsIdentity: ClaimsIdentity,
+        reference: Partial<ConversationReference>,
+        logic: (context: TurnContext) => Promise<void>
+    ): Promise<void>;
+
+    /**
+     * Asynchronously resumes a conversation with a user, possibly after some time has gone by.
+     *
+     * @param claimsIdentity A [ClaimsIdentity](xref:botframework-connector) for the conversation.
+     * @param reference A partial [ConversationReference](xref:botframework-schema.ConversationReference) to the conversation to continue.
+     * @param audience A value signifying the recipient of the proactive message.</param>
+     * @param logic The asynchronous method to call after the adapter middleware runs.
+     * @returns a promise representing the async operation
+     */
+    continueConversationAsync(
+        claimsIdentity: ClaimsIdentity,
+        reference: Partial<ConversationReference>,
+        audience: string,
+        logic: (context: TurnContext) => Promise<void>
+    ): Promise<void>;
+
+    /**
+     * @internal
+     */
+    async continueConversationAsync(
+        botAppIdOrClaimsIdentity: string | ClaimsIdentity,
+        reference: Partial<ConversationReference>,
+        logicOrAudience: ((context: TurnContext) => Promise<void>) | string,
+        maybeLogic?: (context: TurnContext) => Promise<void>
+    ): Promise<void> {
+        throw new Error('NotImplemented');
+    }
+
     /**
      * Gets or sets an error handler that can catch exceptions in the middleware or application.
      *