botframework-webchat-core 4.18.1 → 4.19.0

package/src/sagas/actionSinkSaga.ts

@@ -0,0 +1,39 @@
+import { type Action } from 'redux';
+import { take, takeEvery } from 'redux-saga/effects';
+import { safeParse } from 'valibot';
+
+import {
+  REGISTER_ACTION_SINK,
+  registerActionSinkActionSchema,
+  type RegisterActionSinkAction
+} from '../actions/registerActionSink';
+import { UNREGISTER_ACTION_SINK, unregisterActionSinkActionSchema } from '../actions/unregisterActionSink';
+
+export default function* actionSinkSaga() {
+  yield takeEvery(
+    ({ type }) => type === REGISTER_ACTION_SINK,
+    function* (action: RegisterActionSinkAction) {
+      const result = safeParse(registerActionSinkActionSchema, action);
+
+      if (result.success) {
+        const {
+          payload: { sink }
+        } = result.output;
+
+        for (;;) {
+          const action: Action = yield take();
+
+          if (action.type === UNREGISTER_ACTION_SINK) {
+            const result = safeParse(unregisterActionSinkActionSchema, action);
+
+            if (result.success && result.output.payload.sink === sink) {
+              break;
+            }
+          }
+
+          sink(action);
+        }
+      }
+    }
+  );
+}

package/src/sagas/observeActivitySaga.ts

@@ -1,9 +1,12 @@
-import { put } from 'redux-saga/effects';
+import { put, select } from 'redux-saga/effects';
 import updateIn from 'simple-update-in';
 
 import observeEach from './effects/observeEach';
 import queueIncomingActivity from '../actions/queueIncomingActivity';
+import setVoiceState from '../actions/setVoiceState';
 import whileConnected from './effects/whileConnected';
+import isVoiceActivity from '../utils/voiceActivity/isVoiceActivity';
+import isVoiceTranscriptActivity from '../utils/voiceActivity/isVoiceTranscriptActivity';
 import type { DirectLineActivity } from '../types/external/DirectLineActivity';
 import type { DirectLineJSBotConnection } from '../types/external/DirectLineJSBotConnection';
 import type { WebChatActivity } from '../types/WebChatActivity';
@@ -75,6 +78,53 @@ function patchFromName(activity: DirectLineActivity) {
 
 function* observeActivity({ directLine, userID }: { directLine: DirectLineJSBotConnection; userID?: string }) {
   yield observeEach(directLine.activity$, function* observeActivity(activity: DirectLineActivity) {
+    // Handle voice activities separately - don't store them in Redux (except transcripts)
+    if (isVoiceActivity(activity) && !isVoiceTranscriptActivity(activity)) {
+      const { recording, voiceHandlers } = yield select(state => ({
+        recording: state.voice.voiceState !== 'idle',
+        voiceHandlers: state.voice.voiceHandlers
+      }));
+
+      // Only process voice chunks if speech-to-speech is enabled.
+      if (!recording) {
+        return;
+      }
+
+      switch (activity.name) {
+        case 'media.chunk': {
+          const audioContent = activity?.value?.content;
+          if (audioContent) {
+            voiceHandlers.forEach(handler => handler.queueAudio(audioContent));
+          }
+          break;
+        }
+
+        case 'request.update': {
+          const state = activity?.value?.state;
+
+          switch (state) {
+            case 'detected':
+              voiceHandlers.forEach(handler => handler.stopAllAudio());
+              yield put(setVoiceState('user_speaking'));
+              break;
+
+            case 'processing':
+              yield put(setVoiceState('processing'));
+              break;
+
+            default:
+              break;
+          }
+          break;
+        }
+
+        default:
+          break;
+      }
+
+      return;
+    }
+
     // TODO: [P2] #3953 Move the patching logic to a DirectLineJS wrapper, instead of too close to inners of Web Chat.
     activity = patchNullAsUndefined(activity);
     activity = patchActivityWithFromRole(activity, userID);

package/src/sagas/postActivitySaga.ts

@@ -8,18 +8,15 @@ import {
   POST_ACTIVITY_PENDING,
   POST_ACTIVITY_REJECTED
 } from '../actions/postActivity';
-import dateToLocaleISOString from '../utils/dateToLocaleISOString';
-import deleteKey from '../utils/deleteKey';
 import languageSelector from '../selectors/language';
-import observeOnce from './effects/observeOnce';
 import sendTimeoutSelector from '../selectors/sendTimeout';
+import dateToLocaleISOString from '../utils/dateToLocaleISOString';
+import deleteKey from '../utils/deleteKey';
 import sleep from '../utils/sleep';
 import uniqueID from '../utils/uniqueID';
+import observeOnce from './effects/observeOnce';
 import whileConnected from './effects/whileConnected';
 
-import type { DirectLineActivity } from '../types/external/DirectLineActivity';
-import type { DirectLineJSBotConnection } from '../types/external/DirectLineJSBotConnection';
-import type { GlobalScopePonyfill } from '../types/GlobalScopePonyfill';
 import type { IncomingActivityAction } from '../actions/incomingActivity';
 import type {
   PostActivityAction,
@@ -28,8 +25,12 @@ import type {
   PostActivityPendingAction,
   PostActivityRejectedAction
 } from '../actions/postActivity';
-import type { WebChatActivity } from '../types/WebChatActivity';
+import { setSendStatusInOutgoingActivity } from '../reducers/activities/sort/property/SendStatus';
+import type { DirectLineActivity } from '../types/external/DirectLineActivity';
+import type { DirectLineJSBotConnection } from '../types/external/DirectLineJSBotConnection';
+import type { GlobalScopePonyfill } from '../types/GlobalScopePonyfill';
 import type { WebChatOutgoingActivity } from '../types/internal/WebChatOutgoingActivity';
+import type { WebChatActivity } from '../types/WebChatActivity';
 
 // After 5 minutes, the saga will stop from listening for echo backs and consider the outgoing message as permanently undeliverable.
 // This value must be equals to or larger than the user-defined `styleOptions.sendTimeout`.
@@ -52,13 +53,12 @@ function* postActivity(
 
   // Currently, we allow untyped outgoing activity as long as the chat adapter can deliver.
   // In the future, we should warn if the outgoing activity is not matching the type.
-  const outgoingActivity: WebChatOutgoingActivity = {
+  let outgoingActivity: WebChatOutgoingActivity = {
     ...deleteKey(activity, 'id'),
     channelData: {
-      // Remove local fields that should not be send to the service.
       // `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.
-      ...deleteKey(activity.channelData, 'state', 'webchat:send-status'),
+      ...deleteKey(activity.channelData, 'state'),
       clientActivityID
     },
     channelId: 'webchat',
@@ -90,6 +90,13 @@ function* postActivity(
         : {})
   };
 
+  // Remove local fields that should not be send to the service.
+  outgoingActivity = setSendStatusInOutgoingActivity(
+    // TODO: [P1] Need to rework WebChatActivity typing.
+    outgoingActivity as WebChatActivity,
+    undefined
+  ) as WebChatOutgoingActivity;
+
   if (!numActivitiesPosted) {
     outgoingActivity.entities = [
       ...(outgoingActivity.entities || []),

package/src/sagas/postVoiceActivitySaga.ts

@@ -0,0 +1,76 @@
+import { select, takeEvery } from 'redux-saga/effects';
+import { VOICE_POST_ACTIVITY } from '../actions/postVoiceActivity';
+import languageSelector from '../selectors/language';
+import dateToLocaleISOString from '../utils/dateToLocaleISOString';
+import whileConnected from './effects/whileConnected';
+import observeOnce from './effects/observeOnce';
+
+import type { DirectLineJSBotConnection } from '../types/external/DirectLineJSBotConnection';
+import type { DirectLineActivity } from '../types/external/DirectLineActivity';
+import type { GlobalScopePonyfill } from '../types/GlobalScopePonyfill';
+import type { VoicePostActivityAction } from '../actions/postVoiceActivity';
+
+/**
+ * Saga for handling outgoing voice activities.
+ *
+ * Unlike regular postActivitySaga, this saga:
+ * - Does NOT wait for echo back
+ * - Does NOT store activity in Redux
+ * - Does NOT dispatch PENDING/FULFILLED/REJECTED actions
+ * - Fire and forget - just send to WebSocket
+ *
+ * This prevents memory leaks from storing thousands of voice chunks.
+ */
+function* postVoiceActivity(
+  directLine: DirectLineJSBotConnection,
+  userID: string,
+  username: string,
+  { payload: { activity } }: VoicePostActivityAction,
+  ponyfill: GlobalScopePonyfill
+) {
+  const locale: string = yield select(languageSelector);
+  const localTimeZone =
+    typeof window.Intl === 'undefined' ? undefined : new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const now = new ponyfill.Date();
+
+  const outgoingActivity = {
+    ...activity,
+    channelId: 'webchat',
+    from: {
+      id: userID,
+      name: username,
+      role: 'user'
+    },
+    locale,
+    localTimestamp: dateToLocaleISOString(now),
+    localTimezone: localTimeZone,
+    ...(activity.type === 'event'
+      ? {
+          name: activity.name,
+          value: activity.value
+        }
+      : {})
+  };
+
+  try {
+    yield observeOnce(directLine.postActivity(outgoingActivity as DirectLineActivity));
+  } catch (error) {
+    console.error('botframework-webchat: Failed to post voice activity to chat adapter.', error);
+  }
+}
+
+export default function* voiceActivitySaga(ponyfill: GlobalScopePonyfill) {
+  yield whileConnected(function* voiceActivityWhileConnected({
+    directLine,
+    userID,
+    username
+  }: {
+    directLine: DirectLineJSBotConnection;
+    userID: string;
+    username: string;
+  }) {
+    yield takeEvery(VOICE_POST_ACTIVITY, function* (action: VoicePostActivityAction) {
+      yield* postVoiceActivity(directLine, userID, username, action, ponyfill);
+    });
+  });
+}

package/src/sagas/queueIncomingActivitySaga.ts

@@ -1,10 +1,10 @@
 import { call, cancelled, fork, put, race, select, take } from 'redux-saga/effects';
 
-import { QUEUE_INCOMING_ACTIVITY } from '../actions/queueIncomingActivity';
-import activitiesSelector, { ofType as activitiesOfType } from '../selectors/activities';
-import activityFromBot from '../definitions/activityFromBot';
 import incomingActivity, { INCOMING_ACTIVITY } from '../actions/incomingActivity';
+import { QUEUE_INCOMING_ACTIVITY } from '../actions/queueIncomingActivity';
 import setSuggestedActions from '../actions/setSuggestedActions';
+import activityFromBot from '../definitions/activityFromBot';
+import activitiesSelector, { ofType as activitiesOfType } from '../selectors/activities';
 import sleep from '../utils/sleep';
 import whileConnected from './effects/whileConnected';
 
@@ -94,7 +94,13 @@ function* queueIncomingActivity({ userID }: { userID: string }, ponyfill: Global
 
         // If suggested actions is not destined to anyone, or is destined to the user, show it.
         // In other words, if suggested actions is destined to someone else, don't show it.
-        yield put(setSuggestedActions(to?.length && !to.includes(userID) ? null : actions));
+        const suggestedActions = to?.length && !to.includes(userID) ? null : actions;
+
+        if (suggestedActions) {
+          yield put(setSuggestedActions(suggestedActions, lastMessageActivity));
+        } else {
+          yield put(setSuggestedActions());
+        }
       }
     }
   );

package/src/sagas/sendMessageToPostActivitySaga.ts

@@ -12,7 +12,10 @@ function* postActivityWithMessage({
       {
         attachments: attachments.map(({ blob, thumbnailURL }) => ({
           contentType: (blob instanceof File && blob.type) || 'application/octet-stream',
-          contentUrl: URL.createObjectURL(blob),
+          // Chat adapter should download the file as binary.
+          // In case the chat adapter naively echo back the URL, it will be treated as binary.
+          // eslint-disable-next-line no-restricted-properties
+          contentUrl: URL.createObjectURL(new Blob([blob], { type: 'application/octet-stream' })),
           name: blob instanceof File ? blob.name : undefined,
           thumbnailUrl: thumbnailURL?.toString()
         })),

package/src/sagas/speakActivityAndStartDictateOnIncomingActivityFromOthersSaga.js

@@ -1,12 +1,13 @@
 import { put, select, takeEvery } from 'redux-saga/effects';
 
 import { INCOMING_ACTIVITY } from '../actions/incomingActivity';
-import { WILL_START } from '../constants/DictateState';
 import markActivity from '../actions/markActivity';
 import setDictateState from '../actions/setDictateState';
-import shouldSpeakIncomingActivitySelector from '../selectors/shouldSpeakIncomingActivity';
-import speakableActivity from '../definitions/speakableActivity';
 import stopDictate from '../actions/stopDictate';
+import { IDLE, WILL_START } from '../constants/DictateState';
+import speakableActivity from '../definitions/speakableActivity';
+import dictateStateSelector from '../selectors/dictateState';
+import shouldSpeakIncomingActivitySelector from '../selectors/shouldSpeakIncomingActivity';
 import whileConnected from './effects/whileConnected';
 
 function* speakActivityAndStartDictateOnIncomingActivityFromOthers({ userID }) {
@@ -18,6 +19,7 @@ function* speakActivityAndStartDictateOnIncomingActivityFromOthers({ userID }) {
       type === INCOMING_ACTIVITY && payload.activity.from.id !== userID && payload.activity.from.role !== 'user',
     function* ({ payload: { activity } }) {
       const shouldSpeakIncomingActivity = yield select(shouldSpeakIncomingActivitySelector);
+      const dictateState = yield select(dictateStateSelector);
       const shouldSpeak = speakableActivity(activity) && shouldSpeakIncomingActivity;
 
       if (
@@ -30,7 +32,11 @@ function* speakActivityAndStartDictateOnIncomingActivityFromOthers({ userID }) {
       }
 
       if (shouldSpeak && activity.inputHint === 'expectingInput') {
-        yield put(setDictateState(WILL_START));
+        // In continuous mode (dictateState === LISTENING), we shouldn't set it to WILL_START.
+        // WILL_START means auto start after synthesis completed.
+        if (dictateState === IDLE) {
+          yield put(setDictateState(WILL_START));
+        }
       } else if (activity.inputHint === 'ignoringInput') {
         yield put(stopDictate());
       }

package/src/sagas/startDictateOnSpeakCompleteSaga.js

@@ -1,12 +1,12 @@
 import { put, select, takeEvery } from 'redux-saga/effects';
 
 import { MARK_ACTIVITY } from '../actions/markActivity';
-import { of as activitiesOf } from '../selectors/activities';
 import { SET_DICTATE_STATE } from '../actions/setDictateState';
+import startDictate from '../actions/startDictate';
 import { WILL_START } from '../constants/DictateState';
-import dictateStateSelector from '../selectors/dictateState';
 import speakingActivity from '../definitions/speakingActivity';
-import startDictate from '../actions/startDictate';
+import { of as activitiesOf } from '../selectors/activities';
+import dictateStateSelector from '../selectors/dictateState';
 
 function* startDictateOnSpeakComplete() {
   const speakingActivities = yield select(activitiesOf(speakingActivity));

package/src/sagas/startSpeakActivityOnPostActivitySaga.js

@@ -1,15 +1,25 @@
-import { put, takeEvery } from 'redux-saga/effects';
+import { put, select, takeEvery } from 'redux-saga/effects';
 
 import { POST_ACTIVITY_PENDING } from '../actions/postActivity';
 import startSpeakingActivity from '../actions/startSpeakingActivity';
+import { DICTATING } from '../constants/DictateState';
+import dictateStateSelector from '../selectors/dictateState';
 import whileConnected from './effects/whileConnected';
 
 function* startSpeakActivityOnPostActivity() {
   yield takeEvery(
-    ({ meta, payload, type }) =>
-      type === POST_ACTIVITY_PENDING && meta.method === 'speech' && payload.activity.type === 'message',
-    function* () {
-      yield put(startSpeakingActivity());
+    ({ type }) => type === POST_ACTIVITY_PENDING,
+    function* ({ meta, payload }) {
+      const dictateState = yield select(dictateStateSelector);
+
+      if (
+        // In continuous mode (speech recognition is active), we should speak everything.
+        dictateState === DICTATING ||
+        // Otherwise, in interactive mode, if last message was sent via speech, we should speak bot response.
+        (meta.method === 'speech' && payload.activity.type === 'message')
+      ) {
+        yield put(startSpeakingActivity());
+      }
     }
   );
 }

package/src/sagas/stopDictateOnCardActionSaga.js

@@ -1,20 +1,28 @@
-import { put, takeEvery } from 'redux-saga/effects';
+import { put, select, takeEvery } from 'redux-saga/effects';
 
 import { POST_ACTIVITY_PENDING } from '../actions/postActivity';
 import stopDictate from '../actions/stopDictate';
+import { DICTATING } from '../constants/DictateState';
+import dictateStateSelector from '../selectors/dictateState';
 import whileConnected from './effects/whileConnected';
 
 function* stopDictateOnCardAction() {
   // TODO: [P2] We should stop speech input when the user click on anything on a card, including open URL which doesn't generate postActivity
   //       This functionality was not implemented in v3
-
   yield takeEvery(
     // Currently, there are no actions that are related to card input
     // For now, we are using POST_ACTIVITY of a "message" activity
     // In the future, if we have an action for card input, we should use that instead
     ({ payload, type }) => type === POST_ACTIVITY_PENDING && payload.activity.type === 'message',
     function* putStopDictate() {
-      yield put(stopDictate());
+      const dictateState = yield select(dictateStateSelector);
+
+      // When performing card action:
+      // - In continuous mode (speech recognition is active), speech recognition should not be stopped
+      // - Otherwise, in interactive mode, speech recognition should be stopped
+      if (dictateState !== DICTATING) {
+        yield put(stopDictate());
+      }
     }
   );
 }

package/src/sagas/stopSpeakingActivityOnInputSaga.js

@@ -1,20 +1,38 @@
-import { put, takeEvery } from 'redux-saga/effects';
+import { put, select, takeEvery } from 'redux-saga/effects';
 
 import { POST_ACTIVITY_PENDING } from '../actions/postActivity';
+import { SET_DICTATE_INTERIMS } from '../actions/setDictateInterims';
 import { SET_SEND_BOX } from '../actions/setSendBox';
 import stopSpeakingActivity from '../actions/stopSpeakingActivity';
+import { DICTATING } from '../constants/DictateState';
+import dictateStateSelector from '../selectors/dictateState';
 import whileConnected from './effects/whileConnected';
 
 function* stopSpeakingActivityOnInput() {
   yield takeEvery(
-    ({ meta, payload, type }) =>
+    ({ payload, type }) =>
       (type === SET_SEND_BOX && payload.text) ||
       // We want to stop speaking activity when the user click on a card action
       // But currently there are no actions generated out of a card action
       // So, right now, we are using best-effort by listening to POST_ACTIVITY_PENDING with a "message" event
       // We filter out speech because we will call startSpeakingActivity() for POST_ACTIVITY_PENDING dispatched by speech
-      (type === POST_ACTIVITY_PENDING && meta.method !== 'speech' && payload.activity.type === 'message'),
-    function* () {
+      type === POST_ACTIVITY_PENDING ||
+      // We want to stop speaking activity on barge-in.
+      type === SET_DICTATE_INTERIMS,
+    function* ({ meta, payload, type }) {
+      const dictateState = yield select(dictateStateSelector);
+
+      // If input is post activity, do not stop speaking if either one of the followings:
+      // - In continuous mode (speech recognition should active for as long as possible)
+      // - Posting via speech (interactive mode, should speak bot response)
+      // - Posting a non-message (interactive mode, not typing on keyboard, should be ignored)
+      if (
+        type === POST_ACTIVITY_PENDING &&
+        (dictateState === DICTATING || meta.method === 'speech' || payload.activity.type !== 'message')
+      ) {
+        return;
+      }
+
       yield put(stopSpeakingActivity());
     }
   );

package/src/selectors/combineSelectors.ts

@@ -1,4 +1,4 @@
-import isForbiddenPropertyName from '../utils/isForbiddenPropertyName';
+import { isForbiddenPropertyName } from '@msinternal/botframework-webchat-base/utils';
 
 export default function combineSelectors<
   TState extends { [key: string]: unknown },

package/src/tsconfig.json

@@ -1,19 +1,7 @@
 {
   "compilerOptions": {
-    "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "declarationDir": "../lib",
-    "declarationMap": true,
-    "downlevelIteration": true,
-    "emitDeclarationOnly": true,
-    "jsx": "react",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "preserveWatchOutput": true,
-    "pretty": true,
-    "resolveJsonModule": true, // Required for localization files
-    "skipLibCheck": true,
-    "sourceMap": true
+    "strict": false
   },
-  "files": ["index.ts"]
+  "exclude": ["**/*.spec.ts"],
+  "extends": "@msinternal/botframework-webchat-tsconfig/legacy"
 }

package/src/types/StoreDebugAPI.ts

@@ -0,0 +1,25 @@
+import { RestrictedDebugAPI, type InferPublic } from '@msinternal/botframework-webchat-core-debug-api';
+import type { ArrayElement } from 'type-fest';
+
+const BREAKPOINT_NAMES = ['incomingActivity'] as const;
+
+type StoreBreakpointName = ArrayElement<typeof BREAKPOINT_NAMES>;
+
+type StoreDebugContext = {
+  readonly activities: readonly any[];
+};
+
+class RestrictedStoreDebugAPI extends RestrictedDebugAPI<StoreBreakpointName, StoreDebugContext> {
+  constructor(getActivities: () => StoreDebugContext['activities']) {
+    super(
+      BREAKPOINT_NAMES,
+      Object.freeze({
+        activities: getActivities
+      })
+    );
+  }
+}
+
+type StoreDebugAPI = InferPublic<RestrictedStoreDebugAPI>;
+
+export { RestrictedStoreDebugAPI, type StoreDebugAPI };

package/src/types/WebChatActivity.ts

@@ -7,6 +7,7 @@
 //    - However, we do not expect the server to return "localTimestamp" as they may not have capability to store this information
 // - "conversationUpdate" activity is never sent to Web Chat, thus, it is not defined
 
+import type { LocalId } from '../reducers/activities/sort/property/LocalId';
 import type { AnyAnd } from './AnyAnd';
 // import type { AsEntity, Thing } from './external/OrgSchema/Thing';
 import type { DirectLineAttachment } from './external/DirectLineAttachment';
@@ -23,17 +24,23 @@ type ChannelData<SendStatus extends SupportedSendStatus | undefined, Type extend
     // TODO: [P2] #3953 Rename to "webchat:client-activity-id".
     clientActivityID?: string;
 
-    // Sequence ID must be available when chat adapter send it to Web Chat.
-    'webchat:sequence-id': number;
+    // Web Chat local ID.
+    'webchat:internal:local-id': LocalId;
 
-    webChat?: {
-      /**
-       * Time when the activity appear in chat history.
-       *
-       * Note: if the activity is updated, this value will also be updated.
-       */
-      receivedAt?: number;
+    // Web Chat ordering sequence, must be computed before inserting into Redux.
+    'webchat:internal:position': number;
+
+    /**
+     * Time when the activity appear in chat history.
+     *
+     * Note: if the activity is updated, this value will also be updated.
+     */
+    'webchat:internal:received-at'?: number;
 
+    // Chat adapter may send sequence ID to Web Chat to affect ordering.
+    'webchat:sequence-id'?: number | undefined;
+
+    webChat?: {
       /**
        * Per-activity style options.
        *
@@ -93,7 +100,7 @@ type ChannelData<SendStatus extends SupportedSendStatus | undefined, Type extend
          */
         'webchat:send-status': SendStatus;
       }
-    : {}) &
+    : Record<any, any>) &
     (Type extends 'message'
       ? {
           // TODO: [P2] #3953 Rename to "webchat:message-back".
@@ -112,8 +119,13 @@ type ChannelData<SendStatus extends SupportedSendStatus | undefined, Type extend
 
           // TODO: [P2] #3953 It seems Direct Line added a new "summary" field to cater this case.
           'webchat:fallback-text'?: string;
+
+          feedbackLoop?: {
+            type: 'default';
+            disclaimer?: string;
+          };
         }
-      : {})
+      : Record<any, any>)
 >;
 
 // Entity - https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#entity
@@ -169,15 +181,20 @@ type MessageActivityEssence = {
 // https://github.com/Microsoft/botframework-sdk/blob/main/specs/botframework-activity/botframework-activity.md#typing-activity
 type TypingActivityEssence =
   | {
+      attachmentLayout?: 'carousel' | 'stacked';
+      attachments?: DirectLineAttachment[];
+      text?: undefined;
       type: 'typing';
     }
   | {
+      attachmentLayout?: 'carousel' | 'stacked';
+      attachments?: DirectLineAttachment[];
       channelData: {
-        streamId: string;
+        streamId?: string | undefined;
         streamSequence: number;
-        streamType: 'informative' | 'streaming';
+        streamType: 'informative' | 'streaming' | 'final';
       };
-      text: string;
+      text?: string | undefined;
       type: 'typing';
     };
 

package/src/types/external/DirectLineActivity.ts

@@ -2,6 +2,6 @@
 
 // Until we fully typed out DirectLineActivity, we need to use "any" here.
 // We only know the DirectLineActivity must be a map, and not other primitive types.
-type DirectLineActivity = Exclude<any, [] | boolean | Function | number | string>;
+type DirectLineActivity = Exclude<any, [] | boolean | ((...args: unknown[]) => unknown) | number | string>;
 
 export type { DirectLineActivity };

package/src/types/external/Observable.ts

@@ -1,6 +1,9 @@
 // This is a declaration file for a single ES feature. Could contains multiple classes definitions.
 /* eslint-disable max-classes-per-file */
 
+// TODO: Align with final proposal at https://wicg.github.io/observable/.
+// For example, this signature missed `addTeardown`.
+
 // Adopted from https://github.com/tc39/proposal-observable.
 
 /** Receives a completion notification */
@@ -39,7 +42,7 @@ declare class Subscription {
  */
 declare class Observer<T> {
   /** Receives the subscription object when `subscribe` is called */
-  start(subscription: Subscription);
+  start(subscription: Subscription): void;
 
   /** Receives the next value in the sequence */
   next: NextFunction<T>;