fix(msteams): persist conversation reference during DM pairing

Eric · Eric · commit a74702b7b8ab · 2026-03-12T18:02:28.000+08:00
When a user sends their first DM with dmPolicy=pairing, the handler returned early after upsertPairingRequest without calling conversationStore.upsert(). This meant the conversation reference was never saved, so --notify could not reach the user after pairing was approved. Move conversationStore.upsert() into the pairing block before the early return so the reference is persisted immediately. Closes #43323
diff --git a/extensions/msteams/src/monitor-handler/message-handler.authz.test.ts b/extensions/msteams/src/monitor-handler/message-handler.authz.test.ts
@@ -152,4 +152,110 @@ describe("msteams monitor handler authz", () => {
 
     expect(conversationStore.upsert).not.toHaveBeenCalled();
   });
+
+  it("persists conversation reference on first DM during pairing", async () => {
+    const upsertPairingRequest = vi.fn(async () => ({ id: "user-aad", channel: "msteams" }));
+    setMSTeamsRuntime({
+      logging: { shouldLogVerbose: () => false },
+      channel: {
+        debounce: {
+          resolveInboundDebounceMs: () => 0,
+          createInboundDebouncer: <T>(params: {
+            onFlush: (entries: T[]) => Promise<void>;
+          }): { enqueue: (entry: T) => Promise<void> } => ({
+            enqueue: async (entry: T) => {
+              await params.onFlush([entry]);
+            },
+          }),
+        },
+        pairing: {
+          readAllowFromStore: vi.fn(async () => []),
+          upsertPairingRequest,
+        },
+        text: {
+          hasControlCommand: () => false,
+        },
+      },
+    } as unknown as PluginRuntime);
+
+    const conversationStore = {
+      upsert: vi.fn(async () => undefined),
+    };
+
+    const deps: MSTeamsMessageHandlerDeps = {
+      cfg: {
+        channels: {
+          msteams: {
+            dmPolicy: "pairing",
+            allowFrom: [],
+          },
+        },
+      } as OpenClawConfig,
+      runtime: { error: vi.fn() } as unknown as RuntimeEnv,
+      appId: "test-app",
+      adapter: {} as MSTeamsMessageHandlerDeps["adapter"],
+      tokenProvider: {
+        getAccessToken: vi.fn(async () => "token"),
+      },
+      textLimit: 4000,
+      mediaMaxBytes: 1024 * 1024,
+      conversationStore:
+        conversationStore as unknown as MSTeamsMessageHandlerDeps["conversationStore"],
+      pollStore: {
+        recordVote: vi.fn(async () => null),
+      } as unknown as MSTeamsMessageHandlerDeps["pollStore"],
+      log: {
+        info: vi.fn(),
+        debug: vi.fn(),
+        error: vi.fn(),
+      } as unknown as MSTeamsMessageHandlerDeps["log"],
+    };
+
+    const handler = createMSTeamsMessageHandler(deps);
+    await handler({
+      activity: {
+        id: "dm-1",
+        type: "message",
+        text: "hello",
+        from: {
+          id: "user-id",
+          aadObjectId: "user-aad",
+          name: "New User",
+        },
+        recipient: {
+          id: "bot-id",
+          name: "Bot",
+        },
+        conversation: {
+          id: "19:user-id_bot-id@unq.gbl.spaces",
+          conversationType: "personal",
+        },
+        channelData: {},
+        channelId: "msteams",
+        serviceUrl: "https://smba.trafficmanager.net/teams/",
+        locale: "en-US",
+        attachments: [],
+      },
+      sendActivity: vi.fn(async () => undefined),
+    } as unknown as Parameters<typeof handler>[0]);
+
+    expect(upsertPairingRequest).toHaveBeenCalledWith({
+      channel: "msteams",
+      accountId: "default",
+      id: "user-aad",
+      meta: { name: "New User" },
+    });
+    // Conversation reference must be persisted so --notify works after approval.
+    expect(conversationStore.upsert).toHaveBeenCalledWith(
+      "19:user-id_bot-id@unq.gbl.spaces",
+      expect.objectContaining({
+        user: { id: "user-id", name: "New User", aadObjectId: "user-aad" },
+        serviceUrl: "https://smba.trafficmanager.net/teams/",
+        conversation: expect.objectContaining({
+          id: "19:user-id_bot-id@unq.gbl.spaces",
+          conversationType: "personal",
+        }),
+      }),
+    );
+  });
 });
diff --git a/extensions/msteams/src/monitor-handler/message-handler.ts b/extensions/msteams/src/monitor-handler/message-handler.ts
@@ -210,6 +210,29 @@ export function createMSTeamsMessageHandler(deps: MSTeamsMessageHandlerDeps) {
         allowNameMatching: isDangerousNameMatchingEnabled(msteamsCfg),
       });
       if (access.decision === "pairing") {
+        // Persist conversation reference before returning so that
+        // `--notify` can reach the user after pairing is approved.
+        const agent = activity.recipient;
+        const pairingRef: StoredConversationReference = {
+          activityId: activity.id,
+          user: { id: from.id, name: from.name, aadObjectId: from.aadObjectId },
+          agent,
+          bot: agent ? { id: agent.id, name: agent.name } : undefined,
+          conversation: {
+            id: conversationId,
+            conversationType,
+            tenantId: conversation?.tenantId,
+          },
+          channelId: activity.channelId,
+          serviceUrl: activity.serviceUrl,
+          locale: activity.locale,
+        };
+        conversationStore.upsert(conversationId, pairingRef).catch((err) => {
+          log.debug?.("failed to save pairing conversation reference", {
+            error: formatUnknownError(err),
+          });
+        });
+
         const request = await pairing.upsertPairingRequest({
           id: senderId,
           meta: { name: senderName },
