botframework-webchat-core 4.18.1 → 4.19.0

package/src/index.ts

@@ -1,10 +1,13 @@
-import clearSuggestedActions from './actions/clearSuggestedActions';
 import connect from './actions/connect';
 import disconnect from './actions/disconnect';
 import dismissNotification from './actions/dismissNotification';
 import emitTypingIndicator from './actions/emitTypingIndicator';
 import markActivity from './actions/markActivity';
+import muteVoiceRecording from './actions/muteVoiceRecording';
 import postActivity from './actions/postActivity';
+import postVoiceActivity from './actions/postVoiceActivity';
+import type { VoiceHandler } from './actions/registerVoiceHandler';
+import registerVoiceHandler from './actions/registerVoiceHandler';
 import sendEvent from './actions/sendEvent';
 import sendFiles from './actions/sendFiles';
 import sendMessage from './actions/sendMessage';
@@ -18,30 +21,50 @@ import setSendBox from './actions/setSendBox';
 import setSendBoxAttachments from './actions/setSendBoxAttachments';
 import setSendTimeout from './actions/setSendTimeout';
 import setSendTypingIndicator from './actions/setSendTypingIndicator';
+import type { VoiceState } from './actions/setVoiceState';
+import setVoiceState from './actions/setVoiceState';
 import startDictate from './actions/startDictate';
 import startSpeakingActivity from './actions/startSpeakingActivity';
+import startVoiceRecording from './actions/startVoiceRecording';
 import stopDictate from './actions/stopDictate';
 import stopSpeakingActivity from './actions/stopSpeakingActivity';
+import stopVoiceRecording from './actions/stopVoiceRecording';
 import submitSendBox from './actions/submitSendBox';
+import unmuteVoiceRecording from './actions/unmuteVoiceRecording';
+import unregisterVoiceHandler from './actions/unregisterVoiceHandler';
 import * as ActivityClientState from './constants/ActivityClientState';
 import * as DictateState from './constants/DictateState';
 import createStore, {
   withDevTools as createStoreWithDevTools,
   withOptions as createStoreWithOptions
 } from './createStore';
-import OneOrMany from './types/OneOrMany';
-import { parseAction } from './types/external/OrgSchema/Action';
-import { parseClaim } from './types/external/OrgSchema/Claim';
-import { parseCreativeWork } from './types/external/OrgSchema/CreativeWork';
-import { parseDefinedTerm } from './types/external/OrgSchema/DefinedTerm';
-import { parseProject } from './types/external/OrgSchema/Project';
-import { parseThing } from './types/external/OrgSchema/Thing';
-import { parseVoteAction } from './types/external/OrgSchema/VoteAction';
+import getActivityLivestreamingMetadata from './utils/getActivityLivestreamingMetadata';
 import getOrgSchemaMessage from './utils/getOrgSchemaMessage';
-import isForbiddenPropertyName from './utils/isForbiddenPropertyName';
 import onErrorResumeNext from './utils/onErrorResumeNext';
-import singleToArray from './utils/singleToArray';
-import warnOnce from './utils/warnOnce';
+import getVoiceActivityRole from './utils/voiceActivity/getVoiceActivityRole';
+import getVoiceActivityText from './utils/voiceActivity/getVoiceActivityText';
+import isVoiceActivity from './utils/voiceActivity/isVoiceActivity';
+import isVoiceTranscriptActivity from './utils/voiceActivity/isVoiceTranscriptActivity';
+
+export {
+  isForbiddenPropertyName,
+  withResolvers,
+  type PromiseWithResolvers
+} from '@msinternal/botframework-webchat-base/utils';
+
+export {
+  CLEAR_SUGGESTED_ACTIONS,
+  default as clearSuggestedActions,
+  clearSuggestedActionsActionSchema,
+  type ClearSuggestedActionsAction
+} from './actions/clearSuggestedActions';
+
+export {
+  SET_SUGGESTED_ACTIONS,
+  default as setSuggestedActions,
+  setSuggestedActionsActionSchema,
+  type SetSuggestedActionsAction
+} from './actions/setSuggestedActions';
 
 import type { GlobalScopePonyfill } from './types/GlobalScopePonyfill';
 import type { SendBoxAttachment } from './types/SendBoxAttachment';
@@ -60,44 +83,33 @@ import type { DirectLineSuggestedAction } from './types/external/DirectLineSugge
 import type { DirectLineThumbnailCard } from './types/external/DirectLineThumbnailCard';
 import type { DirectLineVideoCard } from './types/external/DirectLineVideoCard';
 import type { Observable } from './types/external/Observable';
-import type { Action as OrgSchemaAction } from './types/external/OrgSchema/Action';
-import type { Claim as OrgSchemaClaim } from './types/external/OrgSchema/Claim';
-import type { CreativeWork as OrgSchemaCreativeWork } from './types/external/OrgSchema/CreativeWork';
-import type { DefinedTerm as OrgSchemaDefinedTerm } from './types/external/OrgSchema/DefinedTerm';
-import type { Project as OrgSchemaProject } from './types/external/OrgSchema/Project';
-import type { Thing as OrgSchemaThing } from './types/external/OrgSchema/Thing';
 
-const Constants = { ActivityClientState, DictateState };
-const buildTool = process.env.build_tool;
-const moduleFormat = process.env.module_format;
-const version = process.env.npm_package_version;
+/** @deprecated */
+export { singleToArray, type OneOrMany } from '@msinternal/botframework-webchat-base/utils';
 
-const buildInfo = { buildTool, moduleFormat, version };
+const Constants = { ActivityClientState, DictateState };
 
 export {
-  Constants,
-  buildInfo,
-  clearSuggestedActions,
   connect,
+  Constants,
   createStore,
   createStoreWithDevTools,
   createStoreWithOptions,
   disconnect,
   dismissNotification,
   emitTypingIndicator,
+  getActivityLivestreamingMetadata,
   getOrgSchemaMessage,
-  isForbiddenPropertyName,
+  getVoiceActivityRole,
+  getVoiceActivityText,
+  isVoiceActivity,
+  isVoiceTranscriptActivity,
   markActivity,
-  moduleFormat,
+  muteVoiceRecording,
   onErrorResumeNext,
-  parseAction,
-  parseClaim,
-  parseCreativeWork,
-  parseDefinedTerm,
-  parseProject,
-  parseThing,
-  parseVoteAction,
   postActivity,
+  postVoiceActivity,
+  registerVoiceHandler,
   sendEvent,
   sendFiles,
   sendMessage,
@@ -111,14 +123,16 @@ export {
   setSendBoxAttachments,
   setSendTimeout,
   setSendTypingIndicator,
-  singleToArray,
+  setVoiceState,
   startDictate,
   startSpeakingActivity,
+  startVoiceRecording,
   stopDictate,
   stopSpeakingActivity,
+  stopVoiceRecording,
   submitSendBox,
-  version,
-  warnOnce
+  unmuteVoiceRecording,
+  unregisterVoiceHandler
 };
 
 export type {
@@ -137,13 +151,16 @@ export type {
   DirectLineVideoCard,
   GlobalScopePonyfill,
   Observable,
-  OneOrMany,
-  OrgSchemaAction,
-  OrgSchemaClaim,
-  OrgSchemaCreativeWork,
-  OrgSchemaDefinedTerm,
-  OrgSchemaProject,
-  OrgSchemaThing,
   SendBoxAttachment,
+  VoiceHandler,
+  VoiceState,
   WebChatActivity
 };
+
+// #region Build info
+import buildInfo from './buildInfo';
+
+const { object: buildInfoObject, version } = buildInfo;
+
+export { buildInfoObject as buildInfo, version };
+// #endregion

package/src/internal/StoreDebugAPIRegistry.ts

@@ -0,0 +1,4 @@
+import type createStore from '../createStore';
+import type { StoreDebugAPI } from '../types/StoreDebugAPI';
+
+export default new WeakMap<ReturnType<typeof createStore>, StoreDebugAPI>();

package/src/internal/actions/setRawState.ts

@@ -0,0 +1,48 @@
+import { literal, object, pipe, readonly, union, type InferOutput } from 'valibot';
+
+import { suggestedActionsStateSchema } from '../types/suggestedActions';
+import { suggestedActionsOriginActivityStateSchema } from '../types/suggestedActionsOriginActivity';
+
+const SET_RAW_STATE = 'WEB_CHAT_INTERNAL/SET_RAW_STATE' as const;
+
+const setRawStateActionSchema = pipe(
+  object({
+    payload: union([
+      pipe(
+        object({
+          name: literal('suggestedActions'),
+          state: suggestedActionsStateSchema
+        }),
+        readonly()
+      ),
+      pipe(
+        object({
+          name: literal('suggestedActionsOriginActivity'),
+          state: suggestedActionsOriginActivityStateSchema
+        }),
+        readonly()
+      )
+    ]),
+    type: literal(SET_RAW_STATE)
+  }),
+  readonly()
+);
+
+type SetRawStateAction = InferOutput<typeof setRawStateActionSchema>;
+
+// Due to limitation of TypeScript, we need to specify overloading functions.
+export default function setRawState(
+  name: 'suggestedActions',
+  state: (SetRawStateAction['payload'] & { name: typeof name })['state']
+): SetRawStateAction;
+
+export default function setRawState(
+  name: 'suggestedActionsOriginActivity',
+  state: (SetRawStateAction['payload'] & { name: typeof name })['state']
+): SetRawStateAction;
+
+export default function setRawState(name: SetRawStateAction['payload']['name'], state: any): SetRawStateAction {
+  return { payload: { name, state }, type: SET_RAW_STATE };
+}
+
+export { SET_RAW_STATE, setRawStateActionSchema, type SetRawStateAction };

package/src/internal/types/suggestedActions.ts

@@ -0,0 +1,11 @@
+import { array, custom, pipe, readonly, type InferOutput } from 'valibot';
+
+// TODO: Resolve possibly cyclic dependency by moving `types` into a separate package.
+// import { type DirectLineCardAction } from '../../types/external/DirectLineCardAction';
+
+// const suggestedActionsStateSchema = pipe(array(custom<DirectLineCardAction>(() => true)), readonly());
+const suggestedActionsStateSchema = pipe(array(custom<any>(() => true)), readonly());
+
+type SuggestedActionsState = InferOutput<typeof suggestedActionsStateSchema>;
+
+export { suggestedActionsStateSchema, type SuggestedActionsState };

package/src/internal/types/suggestedActionsOriginActivity.ts

@@ -0,0 +1,16 @@
+import { custom, object, pipe, readonly, undefinedable, type InferOutput } from 'valibot';
+
+// TODO: Resolve possibly cyclic dependency by moving `types` into a separate package.
+// import { type WebChatActivity } from '../../types/WebChatActivity';
+
+const suggestedActionsOriginActivityStateSchema = pipe(
+  object({
+    // activity: undefinedable(custom<WebChatActivity>(() => true))
+    activity: undefinedable(custom<any>(() => true))
+  }),
+  readonly()
+);
+
+type SuggestedActionsOriginActivityState = InferOutput<typeof suggestedActionsOriginActivityStateSchema>;
+
+export { suggestedActionsOriginActivityStateSchema, type SuggestedActionsOriginActivityState };

package/src/reducers/activities/combineActivitiesReducer.ts

@@ -0,0 +1,58 @@
+import { isForbiddenPropertyName } from '@msinternal/botframework-webchat-base/utils';
+import type { ActionFromReducersMapObject, combineReducers, Reducer, StateFromReducersMapObject } from 'redux';
+import type { GlobalScopePonyfill } from '../../types/GlobalScopePonyfill';
+import type { RestrictedStoreDebugAPI } from '../../types/StoreDebugAPI';
+import type { WebChatActivity } from '../../types/WebChatActivity';
+import createGroupedActivitiesReducer, {
+  type GroupedActivitiesAction,
+  type GroupedActivitiesState
+} from './createGroupedActivitiesReducer';
+
+type ActivitiesState = {
+  activities: readonly WebChatActivity[];
+  groupedActivities: GroupedActivitiesState;
+};
+
+/**
+ * Creates a reducer by combining slice `activities` and `groupedActivities` to an existing sliced reducer.
+ *
+ * @param ponyfill
+ * @param existingSlicedReducer
+ * @returns
+ */
+export default function combineActivitiesReducer<M>(
+  ponyfill: GlobalScopePonyfill,
+  restrictedStoreDebugAPI: RestrictedStoreDebugAPI,
+  existingSlicedReducer: ReturnType<typeof combineReducers<M>>
+): Reducer<StateFromReducersMapObject<M> & ActivitiesState, ActionFromReducersMapObject<M> & GroupedActivitiesAction> {
+  type ExistingState = StateFromReducersMapObject<M>;
+  type ExistingAction = ActionFromReducersMapObject<M>;
+
+  const groupedActivitiesReducer = createGroupedActivitiesReducer(ponyfill, restrictedStoreDebugAPI);
+
+  return function (
+    state: (ExistingState & ActivitiesState) | undefined,
+    action: ExistingAction & GroupedActivitiesAction
+  ): ExistingState & ActivitiesState {
+    const { activities: _activities, groupedActivities, ...existingState } = state ?? {};
+    const nextState = existingSlicedReducer(existingState as ExistingState, action);
+    const nextGroupedActivities = groupedActivitiesReducer(groupedActivities, action);
+
+    const existingStateEntries = Object.entries(existingState);
+    const nextStateEntries = Object.entries(nextState);
+
+    const hasChanged =
+      !state ||
+      !Object.is(state.groupedActivities, nextGroupedActivities) ||
+      existingStateEntries.length !== nextStateEntries.length ||
+      existingStateEntries.some(
+        // Denylisting forbidden property names.
+        // eslint-disable-next-line security/detect-object-injection
+        ([key, value]) => !Object.is(value, isForbiddenPropertyName(key) ? undefined : (nextState as any)[key])
+      );
+
+    return hasChanged
+      ? { ...nextState, activities: nextGroupedActivities.sortedActivities, groupedActivities: nextGroupedActivities }
+      : state;
+  };
+}

package/src/reducers/activities/createGroupedActivitiesReducer.ts

@@ -0,0 +1,297 @@
+/* eslint-disable complexity */
+/* eslint no-magic-numbers: ["error", { "ignore": [0, 1, -1] }] */
+
+// @ts-ignore No @types/simple-update-in
+import updateIn from 'simple-update-in';
+import { v4 } from 'uuid';
+
+import { DELETE_ACTIVITY } from '../../actions/deleteActivity';
+import { INCOMING_ACTIVITY } from '../../actions/incomingActivity';
+import { MARK_ACTIVITY } from '../../actions/markActivity';
+import {
+  POST_ACTIVITY_FULFILLED,
+  POST_ACTIVITY_IMPEDED,
+  POST_ACTIVITY_PENDING,
+  POST_ACTIVITY_REJECTED
+} from '../../actions/postActivity';
+import { SENDING, SEND_FAILED, SENT } from '../../types/internal/SendStatus';
+
+import type { Reducer } from 'redux';
+import type { DeleteActivityAction } from '../../actions/deleteActivity';
+import type { IncomingActivityAction } from '../../actions/incomingActivity';
+import type { MarkActivityAction } from '../../actions/markActivity';
+import type {
+  PostActivityFulfilledAction,
+  PostActivityImpededAction,
+  PostActivityPendingAction,
+  PostActivityRejectedAction
+} from '../../actions/postActivity';
+import type { GlobalScopePonyfill } from '../../types/GlobalScopePonyfill';
+import { type RestrictedStoreDebugAPI } from '../../types/StoreDebugAPI';
+import type { WebChatActivity } from '../../types/WebChatActivity';
+import patchActivity from './patchActivity';
+import deleteActivityByLocalId from './sort/deleteActivityByLocalId';
+import { generateLocalIdInActivity, getLocalIdFromActivity, setLocalIdInActivity } from './sort/property/LocalId';
+import { getPositionFromActivity, setPositionInActivity } from './sort/property/Position';
+import { setReceivedAtInActivity } from './sort/property/ReceivedAt';
+import { querySendStatusFromOutgoingActivity, setSendStatusInOutgoingActivity } from './sort/property/SendStatus';
+import queryLocalIdAByActivityId from './sort/queryLocalIdByActivityId';
+import queryLocalIdAByClientActivityId from './sort/queryLocalIdByClientActivityId';
+import type { State } from './sort/types';
+import updateActivityChannelData, {
+  updateActivityChannelDataInternalSkipNameCheck
+} from './sort/updateActivityChannelData';
+import upsert, { INITIAL_STATE } from './sort/upsert';
+
+type GroupedActivitiesAction =
+  | DeleteActivityAction
+  | IncomingActivityAction
+  | MarkActivityAction
+  | PostActivityFulfilledAction
+  | PostActivityImpededAction
+  | PostActivityPendingAction
+  | PostActivityRejectedAction;
+
+type GroupedActivitiesState = State;
+
+const DEFAULT_STATE: GroupedActivitiesState = INITIAL_STATE;
+
+function getClientActivityID(activity: WebChatActivity): string | undefined {
+  return activity.channelData?.clientActivityID;
+}
+
+function createGroupedActivitiesReducer(
+  ponyfill: GlobalScopePonyfill,
+  restrictedStoreDebugAPI: RestrictedStoreDebugAPI
+): Reducer<GroupedActivitiesState, GroupedActivitiesAction> {
+  return function activities(
+    state: GroupedActivitiesState = DEFAULT_STATE,
+    action: GroupedActivitiesAction
+  ): GroupedActivitiesState {
+    switch (action.type) {
+      case DELETE_ACTIVITY: {
+        console.warn(
+          'botframework-webchat: Delete activity is being deprecated, please build your own chat adapter instead.'
+        );
+
+        const localId = queryLocalIdAByActivityId(state, action.payload.activityID);
+
+        if (localId) {
+          state = deleteActivityByLocalId(state, localId);
+        }
+
+        break;
+      }
+
+      case MARK_ACTIVITY: {
+        // We need to deprecate this, however, it is currently using by speech.
+
+        const localId = queryLocalIdAByActivityId(state, action.payload.activityID);
+
+        if (localId) {
+          state = updateActivityChannelData(state, localId, action.payload.name, action.payload.value);
+        }
+
+        break;
+      }
+
+      case POST_ACTIVITY_PENDING: {
+        let {
+          payload: { activity }
+        } = action;
+
+        // Patch activity so the outgoing blob: URL is not re-downloadable.
+        // Related to /__tests__/html2/accessibility/liveRegion/attachment/file.
+
+        // Why not re-downloadable?
+        // - When the activity echo back, the URL will be dummy (not downloadable)
+        // - Outgoing -> echo back, the UI will be "downloadable" and flash to "not downloadable" in a short amount of time
+
+        // TODO: [P0] Consider modify attachment middleware so all outgoing activity is not downloadable.
+
+        activity = patchActivity(activity, ponyfill);
+        activity = setReceivedAtInActivity(activity, ponyfill.Date.now());
+        activity = generateLocalIdInActivity(activity);
+        // `channelData.state` is being deprecated in favor of `channelData['webchat:send-status']`.
+        // Please refer to #4362 for details. Remove on or after 2024-07-31.
+        activity = updateIn(activity, ['channelData', 'state'], () => SENDING);
+        activity = setSendStatusInOutgoingActivity(activity, SENDING);
+
+        state = upsert(ponyfill, state, activity);
+
+        break;
+      }
+
+      case POST_ACTIVITY_IMPEDED: {
+        const localId = queryLocalIdAByClientActivityId(state, action.meta.clientActivityID);
+
+        if (localId) {
+          state = updateActivityChannelDataInternalSkipNameCheck(
+            state,
+            localId,
+            // `channelData.state` is being deprecated in favor of `channelData['webchat:send-status']`.
+            // Please refer to #4362 for details. Remove on or after 2024-07-31.
+            'state',
+            SEND_FAILED
+          );
+        }
+
+        break;
+      }
+
+      case POST_ACTIVITY_REJECTED: {
+        const localId = queryLocalIdAByClientActivityId(state, action.meta.clientActivityID);
+
+        if (localId) {
+          state = updateActivityChannelDataInternalSkipNameCheck(state, localId, 'state', SEND_FAILED);
+          state = updateActivityChannelDataInternalSkipNameCheck(state, localId, 'webchat:send-status', SEND_FAILED);
+        }
+
+        break;
+      }
+
+      case POST_ACTIVITY_FULFILLED: {
+        const localId = queryLocalIdAByClientActivityId(state, action.meta.clientActivityID);
+
+        const existingActivity = localId && state.activityMap.get(localId)?.activity;
+
+        if (!existingActivity) {
+          throw new Error(
+            'botframework-webchat-internal: On POST_ACTIVITY_FULFILLED, there is no activities with same client activity ID'
+          );
+        }
+
+        // We will replace the outgoing activity with the version from the server
+        let activity = patchActivity(action.payload.activity, ponyfill);
+
+        activity = updateIn(
+          activity,
+          // `channelData.state` is being deprecated in favor of `channelData['webchat:send-status']`.
+          // Please refer to #4362 for details. Remove on or after 2024-07-31.
+          ['channelData', 'state'],
+          () => SENT
+        );
+
+        activity = setSendStatusInOutgoingActivity(activity, SENT);
+        activity = setLocalIdInActivity(activity, localId);
+
+        // Keep existing position.
+        activity = setPositionInActivity(activity, getPositionFromActivity(existingActivity));
+
+        // Compare the INCOMING_ACTIVITY below:
+        // - POST_ACTIVITY_FULFILLED will mark send status as SENT
+        // - INCOMING_ACTIVITY will not change send status and leave it as-is
+        state = upsert(ponyfill, state, activity);
+
+        break;
+      }
+
+      case INCOMING_ACTIVITY: {
+        let {
+          payload: { activity }
+        } = action;
+
+        // We cannot call breakpoint inside Redux because DebugContext cannot call getState(), need setTimeout.
+        queueMicrotask(() => restrictedStoreDebugAPI.UNSAFE_callBreakpoint.incomingActivity({ activity }));
+
+        activity = patchActivity(activity, ponyfill);
+
+        // Clean internal properties if they were passed from chat adapter.
+        // These properties should not be passed from external systems.
+        activity = setLocalIdInActivity(activity, undefined);
+        activity = setPositionInActivity(activity, undefined);
+        activity = setSendStatusInOutgoingActivity(activity, undefined);
+
+        // If the incoming activity is an echo back, we should keep the existing `channelData['webchat:send-status']` field.
+        //
+        // Otherwise, it will fail following scenario:
+        //
+        // 1. Send an activity to the service
+        // 2. Service echoed back the activity
+        // 3. Service did NOT return `postActivity` call
+        // -  EXPECT: `channelData['webchat:send-status']` should be "sending".
+        // -  ACTUAL: `channelData['webchat:send-status']` is `undefined` because the activity get overwritten by the echo back activity.
+        //            The echo back activity contains no `channelData['webchat:send-status']`.
+        //
+        // While we are looking out for the scenario above, we should also look at the following scenarios:
+        //
+        // 1. Service restore chat history, including activities sent from the user. These activities has the following characteristics:
+        //    - They do not have `channelData['webchat:send-status']`;
+        //    - They do not have an ongoing `postActivitySaga`;
+        //    - They should not previously appear in the chat history.
+        // 2. We need to mark these activities as "sent".
+        //
+        // In the future, when we revamp our object model, we could use a different signal so we don't need the code below, for example:
+        //
+        // -  If `activity.id` is set, it is "sent", because the chat service assigned an ID to the activity;
+        // -  If `activity.id` is not set, it is either "sending" or "send failed";
+        //    - If `activity.channelData['webchat:send-failed-reason']` is set, it is "send failed" with the reason, otherwise;
+        //    - It is sending.
+        if (activity.from.role === 'user') {
+          const { id } = activity;
+          const clientActivityID = getClientActivityID(activity);
+
+          const existingLocalId = clientActivityID
+            ? queryLocalIdAByClientActivityId(state, clientActivityID)
+            : id
+              ? queryLocalIdAByActivityId(state, id)
+              : undefined;
+          const existingActivity = existingLocalId && state.activityMap.get(existingLocalId)?.activity;
+
+          if (existingActivity) {
+            activity = setLocalIdInActivity(activity, getLocalIdFromActivity(existingActivity));
+
+            const existingSendStatus = querySendStatusFromOutgoingActivity(existingActivity);
+
+            if (typeof existingSendStatus !== 'undefined') {
+              activity = setSendStatusInOutgoingActivity(activity, existingSendStatus);
+            }
+          } else {
+            activity = generateLocalIdInActivity(activity);
+
+            // If there are no existing activity, probably this activity is restored from chat history.
+            // All outgoing activities restored from service means they arrived at the service successfully.
+            // Thus, we are marking them as "sent".
+            activity = setSendStatusInOutgoingActivity(activity, SENT);
+          }
+        } else {
+          let { id } = activity;
+
+          if (!id) {
+            id = v4();
+
+            console.warn(
+              'botframework-webchat: Incoming activity must have "id" field set, assigning a random value as ID',
+              {
+                activity,
+                newActivityId: id
+              }
+            );
+
+            activity = updateIn(activity, ['id'], () => id);
+          }
+
+          const existingLocalId = queryLocalIdAByActivityId(state, id);
+
+          if (existingLocalId) {
+            activity = setLocalIdInActivity(activity, existingLocalId);
+          } else {
+            activity = generateLocalIdInActivity(activity);
+          }
+        }
+
+        state = upsert(ponyfill, state, activity);
+
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    return state;
+  };
+}
+
+export default createGroupedActivitiesReducer;
+export type { GroupedActivitiesAction, GroupedActivitiesState };

package/src/reducers/activities/patchActivity.ts

@@ -0,0 +1,37 @@
+// @ts-ignore No @types/simple-update-in
+import updateIn from 'simple-update-in';
+import type { GlobalScopePonyfill } from '../../types/GlobalScopePonyfill';
+import type { WebChatActivity } from '../../types/WebChatActivity';
+import { setReceivedAtInActivity } from './sort/property/ReceivedAt';
+
+const DIRECT_LINE_PLACEHOLDER_URL =
+  'https://docs.botframework.com/static/devportal/client/images/bot-framework-default-placeholder.png';
+
+/**
+ * Patches incoming activity.
+ *
+ * @returns A patched activity.
+ */
+export default function patchActivity(activity: WebChatActivity, { Date }: GlobalScopePonyfill): WebChatActivity {
+  // Direct Line channel will return a placeholder image for the user-uploaded image.
+  // As observed, the URL for the placeholder image is https://docs.botframework.com/static/devportal/client/images/bot-framework-default-placeholder.png.
+  // To make our code simpler, we are removing the value if "contentUrl" is pointing to a placeholder image.
+
+  // TODO: [P2] #2869 This "contentURL" removal code should be moved to DirectLineJS adapter.
+
+  // Also, if the "contentURL" starts with "blob:", this means the user is uploading a file (the URL is constructed by URL.createObjectURL)
+  // Although the copy/reference of the file is temporary in-memory, to make the UX consistent across page refresh, we do not allow the user to re-download the file either.
+
+  activity = updateIn(activity, ['attachments', () => true, 'contentUrl'], (contentUrl: string) => {
+    if (contentUrl !== DIRECT_LINE_PLACEHOLDER_URL && !/^blob:/iu.test(contentUrl)) {
+      return contentUrl;
+    }
+
+    return undefined;
+  });
+
+  activity = updateIn(activity, ['channelData'], (channelData: any) => ({ ...channelData }));
+  activity = setReceivedAtInActivity(activity, Date.now());
+
+  return activity;
+}