Spaces:
Build error
Build error
File size: 15,017 Bytes
0827183 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
from copy import deepcopy
from typing import List
from botframework.connector.token_api.models import TokenExchangeRequest
from botbuilder.schema import (
Activity,
ActivityTypes,
ExpectedReplies,
DeliveryModes,
SignInConstants,
TokenExchangeInvokeRequest,
)
from botbuilder.core import BotAdapter, TurnContext, ExtendedUserTokenProvider
from botbuilder.core.card_factory import ContentTypes
from botbuilder.core.skills import SkillConversationIdFactoryOptions
from botbuilder.dialogs import (
Dialog,
DialogContext,
DialogEvents,
DialogReason,
DialogInstance,
)
from .begin_skill_dialog_options import BeginSkillDialogOptions
from .skill_dialog_options import SkillDialogOptions
class SkillDialog(Dialog):
SKILLCONVERSATIONIDSTATEKEY = (
"Microsoft.Bot.Builder.Dialogs.SkillDialog.SkillConversationId"
)
def __init__(self, dialog_options: SkillDialogOptions, dialog_id: str):
super().__init__(dialog_id)
if not dialog_options:
raise TypeError("SkillDialog.__init__(): dialog_options cannot be None.")
self.dialog_options = dialog_options
self._deliver_mode_state_key = "deliverymode"
async def begin_dialog(self, dialog_context: DialogContext, options: object = None):
"""
Method called when a new dialog has been pushed onto the stack and is being activated.
:param dialog_context: The dialog context for the current turn of conversation.
:param options: (Optional) additional argument(s) to pass to the dialog being started.
"""
dialog_args = self._validate_begin_dialog_args(options)
# Create deep clone of the original activity to avoid altering it before forwarding it.
skill_activity: Activity = deepcopy(dialog_args.activity)
# Apply conversation reference and common properties from incoming activity before sending.
TurnContext.apply_conversation_reference(
skill_activity,
TurnContext.get_conversation_reference(dialog_context.context.activity),
is_incoming=True,
)
# Store delivery mode in dialog state for later use.
dialog_context.active_dialog.state[self._deliver_mode_state_key] = (
dialog_args.activity.delivery_mode
)
# Create the conversationId and store it in the dialog context state so we can use it later
skill_conversation_id = await self._create_skill_conversation_id(
dialog_context.context, dialog_context.context.activity
)
dialog_context.active_dialog.state[SkillDialog.SKILLCONVERSATIONIDSTATEKEY] = (
skill_conversation_id
)
# Send the activity to the skill.
eoc_activity = await self._send_to_skill(
dialog_context.context, skill_activity, skill_conversation_id
)
if eoc_activity:
return await dialog_context.end_dialog(eoc_activity.value)
return self.end_of_turn
async def continue_dialog(self, dialog_context: DialogContext):
if not self._on_validate_activity(dialog_context.context.activity):
return self.end_of_turn
# Handle EndOfConversation from the skill (this will be sent to the this dialog by the SkillHandler if
# received from the Skill)
if dialog_context.context.activity.type == ActivityTypes.end_of_conversation:
return await dialog_context.end_dialog(
dialog_context.context.activity.value
)
# Create deep clone of the original activity to avoid altering it before forwarding it.
skill_activity = deepcopy(dialog_context.context.activity)
skill_activity.delivery_mode = dialog_context.active_dialog.state[
self._deliver_mode_state_key
]
# Just forward to the remote skill
skill_conversation_id = dialog_context.active_dialog.state[
SkillDialog.SKILLCONVERSATIONIDSTATEKEY
]
eoc_activity = await self._send_to_skill(
dialog_context.context, skill_activity, skill_conversation_id
)
if eoc_activity:
return await dialog_context.end_dialog(eoc_activity.value)
return self.end_of_turn
async def reprompt_dialog( # pylint: disable=unused-argument
self, context: TurnContext, instance: DialogInstance
):
# Create and send an event to the skill so it can resume the dialog.
reprompt_event = Activity(
type=ActivityTypes.event, name=DialogEvents.reprompt_dialog
)
# Apply conversation reference and common properties from incoming activity before sending.
TurnContext.apply_conversation_reference(
reprompt_event,
TurnContext.get_conversation_reference(context.activity),
is_incoming=True,
)
# connection Name is not applicable for a RePrompt, as we don't expect as OAuthCard in response.
skill_conversation_id = instance.state[SkillDialog.SKILLCONVERSATIONIDSTATEKEY]
await self._send_to_skill(context, reprompt_event, skill_conversation_id)
async def resume_dialog( # pylint: disable=unused-argument
self, dialog_context: "DialogContext", reason: DialogReason, result: object
):
await self.reprompt_dialog(dialog_context.context, dialog_context.active_dialog)
return self.end_of_turn
async def end_dialog(
self, context: TurnContext, instance: DialogInstance, reason: DialogReason
):
# Send of of conversation to the skill if the dialog has been cancelled.
if reason in (DialogReason.CancelCalled, DialogReason.ReplaceCalled):
activity = Activity(type=ActivityTypes.end_of_conversation)
# Apply conversation reference and common properties from incoming activity before sending.
TurnContext.apply_conversation_reference(
activity,
TurnContext.get_conversation_reference(context.activity),
is_incoming=True,
)
activity.channel_data = context.activity.channel_data
activity.additional_properties = context.activity.additional_properties
# connection Name is not applicable for an EndDialog, as we don't expect as OAuthCard in response.
skill_conversation_id = instance.state[
SkillDialog.SKILLCONVERSATIONIDSTATEKEY
]
await self._send_to_skill(context, activity, skill_conversation_id)
await super().end_dialog(context, instance, reason)
def _validate_begin_dialog_args(self, options: object) -> BeginSkillDialogOptions:
if not options:
raise TypeError("options cannot be None.")
dialog_args = BeginSkillDialogOptions.from_object(options)
if not dialog_args:
raise TypeError(
"SkillDialog: options object not valid as BeginSkillDialogOptions."
)
if not dialog_args.activity:
raise TypeError(
"SkillDialog: activity object in options as BeginSkillDialogOptions cannot be None."
)
return dialog_args
def _on_validate_activity(
self, activity: Activity # pylint: disable=unused-argument
) -> bool:
"""
Validates the activity sent during continue_dialog.
Override this method to implement a custom validator for the activity being sent during continue_dialog.
This method can be used to ignore activities of a certain type if needed.
If this method returns false, the dialog will end the turn without processing the activity.
"""
return True
async def _send_to_skill(
self, context: TurnContext, activity: Activity, skill_conversation_id: str
) -> Activity:
if activity.type == ActivityTypes.invoke:
# Force ExpectReplies for invoke activities so we can get the replies right away and send
# them back to the channel if needed. This makes sure that the dialog will receive the Invoke
# response from the skill and any other activities sent, including EoC.
activity.delivery_mode = DeliveryModes.expect_replies
# Always save state before forwarding
# (the dialog stack won't get updated with the skillDialog and things won't work if you don't)
await self.dialog_options.conversation_state.save_changes(context, True)
skill_info = self.dialog_options.skill
response = await self.dialog_options.skill_client.post_activity(
self.dialog_options.bot_id,
skill_info.app_id,
skill_info.skill_endpoint,
self.dialog_options.skill_host_endpoint,
skill_conversation_id,
activity,
)
# Inspect the skill response status
if not 200 <= response.status <= 299:
raise Exception(
f'Error invoking the skill id: "{skill_info.id}" at "{skill_info.skill_endpoint}"'
f" (status is {response.status}). \r\n {response.body}"
)
eoc_activity: Activity = None
if activity.delivery_mode == DeliveryModes.expect_replies and response.body:
# Process replies in the response.Body.
response.body: List[Activity]
response.body = ExpectedReplies().deserialize(response.body).activities
# Track sent invoke responses, so more than one is not sent.
sent_invoke_response = False
for from_skill_activity in response.body:
if from_skill_activity.type == ActivityTypes.end_of_conversation:
# Capture the EndOfConversation activity if it was sent from skill
eoc_activity = from_skill_activity
# The conversation has ended, so cleanup the conversation id
await self.dialog_options.conversation_id_factory.delete_conversation_reference(
skill_conversation_id
)
elif not sent_invoke_response and await self._intercept_oauth_cards(
context, from_skill_activity, self.dialog_options.connection_name
):
# Token exchange succeeded, so no oauthcard needs to be shown to the user
sent_invoke_response = True
else:
# If an invoke response has already been sent we should ignore future invoke responses as this
# represents a bug in the skill.
if from_skill_activity.type == ActivityTypes.invoke_response:
if sent_invoke_response:
continue
sent_invoke_response = True
# Send the response back to the channel.
await context.send_activity(from_skill_activity)
return eoc_activity
async def _create_skill_conversation_id(
self, context: TurnContext, activity: Activity
) -> str:
# Create a conversationId to interact with the skill and send the activity
conversation_id_factory_options = SkillConversationIdFactoryOptions(
from_bot_oauth_scope=context.turn_state.get(BotAdapter.BOT_OAUTH_SCOPE_KEY),
from_bot_id=self.dialog_options.bot_id,
activity=activity,
bot_framework_skill=self.dialog_options.skill,
)
skill_conversation_id = await self.dialog_options.conversation_id_factory.create_skill_conversation_id(
conversation_id_factory_options
)
return skill_conversation_id
async def _intercept_oauth_cards(
self, context: TurnContext, activity: Activity, connection_name: str
):
"""
Tells is if we should intercept the OAuthCard message.
"""
if not connection_name or not isinstance(
context.adapter, ExtendedUserTokenProvider
):
# The adapter may choose not to support token exchange, in which case we fallback to
# showing an oauth card to the user.
return False
oauth_card_attachment = next(
attachment
for attachment in activity.attachments
if attachment.content_type == ContentTypes.oauth_card
)
if oauth_card_attachment:
oauth_card = oauth_card_attachment.content
if (
oauth_card
and oauth_card.token_exchange_resource
and oauth_card.token_exchange_resource.uri
):
try:
result = await context.adapter.exchange_token(
turn_context=context,
connection_name=connection_name,
user_id=context.activity.from_property.id,
exchange_request=TokenExchangeRequest(
uri=oauth_card.token_exchange_resource.uri
),
)
if result and result.token:
# If token above is null, then SSO has failed and hence we return false.
# If not, send an invoke to the skill with the token.
return await self._send_token_exchange_invoke_to_skill(
activity,
oauth_card.token_exchange_resource.id,
oauth_card.connection_name,
result.token,
)
except:
# Failures in token exchange are not fatal. They simply mean that the user needs
# to be shown the OAuth card.
return False
return False
async def _send_token_exchange_invoke_to_skill(
self,
incoming_activity: Activity,
request_id: str,
connection_name: str,
token: str,
):
activity = incoming_activity.create_reply()
activity.type = ActivityTypes.invoke
activity.name = SignInConstants.token_exchange_operation_name
activity.value = TokenExchangeInvokeRequest(
id=request_id,
token=token,
connection_name=connection_name,
)
# route the activity to the skill
skill_info = self.dialog_options.skill
response = await self.dialog_options.skill_client.post_activity(
self.dialog_options.bot_id,
skill_info.app_id,
skill_info.skill_endpoint,
self.dialog_options.skill_host_endpoint,
incoming_activity.conversation.id,
activity,
)
# Check response status: true if success, false if failure
return response.is_successful_status_code()
|