refactor: unify typing callbacks

extensions/matrix/src/matrix/monitor/handler.ts

@@ -1,6 +1,7 @@
 import type { LocationMessageEventContent, MatrixClient } from "matrix-bot-sdk";
 
 import {
+  createTypingCallbacks,
   formatAllowlistMatchMeta,
   type RuntimeEnv,
 } from "clawdbot/plugin-sdk";
@@ -552,6 +553,16 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
         channel: "matrix",
         accountId: route.accountId,
       });
+      const typingCallbacks = createTypingCallbacks({
+        start: () => sendTypingMatrix(roomId, true, undefined, client),
+        stop: () => sendTypingMatrix(roomId, false, undefined, client),
+        onStartError: (err) => {
+          logVerboseMessage(`matrix typing cue failed for room ${roomId}: ${String(err)}`);
+        },
+        onStopError: (err) => {
+          logVerboseMessage(`matrix typing stop failed for room ${roomId}: ${String(err)}`);
+        },
+      });
       const { dispatcher, replyOptions, markDispatchIdle } =
         core.channel.reply.createReplyDispatcherWithTyping({
           responsePrefix: core.channel.reply.resolveEffectiveMessagesConfig(cfg, route.agentId)
@@ -574,10 +585,8 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
           onError: (err, info) => {
             runtime.error?.(`matrix ${info.kind} reply failed: ${String(err)}`);
           },
-          onReplyStart: () =>
-            sendTypingMatrix(roomId, true, undefined, client).catch(() => {}),
-          onIdle: () =>
-            sendTypingMatrix(roomId, false, undefined, client).catch(() => {}),
+          onReplyStart: typingCallbacks.onReplyStart,
+          onIdle: typingCallbacks.onIdle,
         });
 
       const { queuedFinal, counts } = await core.channel.reply.dispatchReplyFromConfig({

extensions/mattermost/src/mattermost/monitor.ts

@@ -7,6 +7,7 @@ import type {
   RuntimeEnv,
 } from "clawdbot/plugin-sdk";
 import {
+  createTypingCallbacks,
   buildPendingHistoryContextFromMap,
   clearHistoryEntriesIfEnabled,
   DEFAULT_GROUP_HISTORY_LIMIT,
@@ -307,11 +308,7 @@ export async function monitorMattermostProvider(opts: MonitorMattermostOpts = {}
   };
 
   const sendTypingIndicator = async (channelId: string, parentId?: string) => {
-    try {
-      await sendMattermostTyping(client, { channelId, parentId });
-    } catch (err) {
-      logger.debug?.(`mattermost typing cue failed for channel ${channelId}: ${String(err)}`);
-    }
+    await sendMattermostTyping(client, { channelId, parentId });
   };
 
   const resolveChannelInfo = async (channelId: string): Promise<MattermostChannel | null> => {
@@ -717,6 +714,12 @@ export async function monitorMattermostProvider(opts: MonitorMattermostOpts = {}
       identityName: resolveIdentityName(cfg, route.agentId),
     };
 
+    const typingCallbacks = createTypingCallbacks({
+      start: () => sendTypingIndicator(channelId, threadRootId),
+      onStartError: (err) => {
+        logger.debug?.(`mattermost typing cue failed for channel ${channelId}: ${String(err)}`);
+      },
+    });
     const { dispatcher, replyOptions, markDispatchIdle } =
       core.channel.reply.createReplyDispatcherWithTyping({
         responsePrefix: core.channel.reply.resolveEffectiveMessagesConfig(cfg, route.agentId)
@@ -752,7 +755,7 @@ export async function monitorMattermostProvider(opts: MonitorMattermostOpts = {}
         onError: (err, info) => {
           runtime.error?.(`mattermost ${info.kind} reply failed: ${String(err)}`);
         },
-        onReplyStart: () => sendTypingIndicator(channelId, threadRootId),
+        onReplyStart: typingCallbacks.onReplyStart,
       });
 
     await core.channel.reply.dispatchReplyFromConfig({

extensions/msteams/src/reply-dispatcher.ts

@@ -1,4 +1,5 @@
 import {
+  createTypingCallbacks,
   resolveChannelMediaMaxBytes,
   type ClawdbotConfig,
   type MSTeamsReplyStyle,
@@ -39,12 +40,14 @@ export function createMSTeamsReplyDispatcher(params: {
 }) {
   const core = getMSTeamsRuntime();
   const sendTypingIndicator = async () => {
-    try {
-      await params.context.sendActivities([{ type: "typing" }]);
-    } catch {
-      // Typing indicator is best-effort.
-    }
+    await params.context.sendActivities([{ type: "typing" }]);
   };
+  const typingCallbacks = createTypingCallbacks({
+    start: sendTypingIndicator,
+    onStartError: () => {
+      // Typing indicator is best-effort.
+    },
+  });
 
   return core.channel.reply.createReplyDispatcherWithTyping({
     responsePrefix: core.channel.reply.resolveEffectiveMessagesConfig(
@@ -102,6 +105,6 @@ export function createMSTeamsReplyDispatcher(params: {
         hint,
       });
     },
-    onReplyStart: sendTypingIndicator,
+    onReplyStart: typingCallbacks.onReplyStart,
   });
 }