@openclaw/msteams 2026.3.13 → 2026.5.1-beta.1

package/src/config-schema.ts

@@ -0,0 +1,6 @@
+import { buildChannelConfigSchema, MSTeamsConfigSchema } from "../config-api.js";
+import { msTeamsChannelConfigUiHints } from "./config-ui-hints.js";
+
+export const MSTeamsChannelConfigSchema = buildChannelConfigSchema(MSTeamsConfigSchema, {
+  uiHints: msTeamsChannelConfigUiHints,
+});

package/src/config-ui-hints.ts

@@ -0,0 +1,12 @@
+import type { ChannelConfigUiHint } from "openclaw/plugin-sdk/channel-core";
+
+export const msTeamsChannelConfigUiHints = {
+  "": {
+    label: "MS Teams",
+    help: "Microsoft Teams channel provider configuration and provider-specific policy toggles. Use this section to isolate Teams behavior from other enterprise chat providers.",
+  },
+  configWrites: {
+    label: "MS Teams Config Writes",
+    help: "Allow Microsoft Teams to write config in response to channel events/commands (default: true).",
+  },
+} satisfies Record<string, ChannelConfigUiHint>;

package/src/conversation-store-fs.test.ts

@@ -7,12 +7,12 @@ import type { StoredConversationReference } from "./conversation-store.js";
 import { setMSTeamsRuntime } from "./runtime.js";
 import { msteamsRuntimeStub } from "./test-runtime.js";
 
-describe("msteams conversation store (fs)", () => {
+describe("msteams conversation store (fs-only)", () => {
   beforeEach(() => {
     setMSTeamsRuntime(msteamsRuntimeStub);
   });
 
-  it("filters and prunes expired entries (but keeps legacy ones)", async () => {
+  it("filters and prunes expired entries while preserving legacy entries without lastSeenAt", async () => {
     const stateDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "openclaw-msteams-store-"));
 
     const env: NodeJS.ProcessEnv = {
@@ -35,7 +35,7 @@ describe("msteams conversation store (fs)", () => {
     const raw = await fs.promises.readFile(filePath, "utf-8");
     const json = JSON.parse(raw) as {
       version: number;
-      conversations: Record<string, StoredConversationReference & { lastSeenAt?: string }>;
+      conversations: Record<string, StoredConversationReference>;
     };
 
     json.conversations["19:old@thread.tacv2"] = {
@@ -44,7 +44,6 @@ describe("msteams conversation store (fs)", () => {
       lastSeenAt: new Date(Date.now() - 60_000).toISOString(),
     };
 
-    // Legacy entry without lastSeenAt should be preserved.
     json.conversations["19:legacy@thread.tacv2"] = {
       ...ref,
       conversation: { id: "19:legacy@thread.tacv2" },
@@ -53,7 +52,7 @@ describe("msteams conversation store (fs)", () => {
     await fs.promises.writeFile(filePath, `${JSON.stringify(json, null, 2)}\n`);
 
     const list = await store.list();
-    const ids = list.map((e) => e.conversationId).toSorted();
+    const ids = list.map((entry) => entry.conversationId).toSorted();
     expect(ids).toEqual(["19:active@thread.tacv2", "19:legacy@thread.tacv2"]);
 
     expect(await store.get("19:old@thread.tacv2")).toBeNull();

package/src/conversation-store-fs.ts

@@ -1,3 +1,10 @@
+import {
+  findPreferredDmConversationByUserId,
+  mergeStoredConversationReference,
+  normalizeStoredConversationId,
+  parseStoredConversationTimestamp,
+  toConversationStoreEntries,
+} from "./conversation-store-helpers.js";
 import type {
   MSTeamsConversationStore,
   MSTeamsConversationStoreEntry,
@@ -8,35 +15,22 @@ import { readJsonFile, withFileLock, writeJsonFile } from "./store-fs.js";
 
 type ConversationStoreData = {
   version: 1;
-  conversations: Record<string, StoredConversationReference & { lastSeenAt?: string }>;
+  conversations: Record<string, StoredConversationReference>;
 };
 
 const STORE_FILENAME = "msteams-conversations.json";
 const MAX_CONVERSATIONS = 1000;
 const CONVERSATION_TTL_MS = 365 * 24 * 60 * 60 * 1000;
 
-function parseTimestamp(value: string | undefined): number | null {
-  if (!value) {
-    return null;
-  }
-  const parsed = Date.parse(value);
-  if (!Number.isFinite(parsed)) {
-    return null;
-  }
-  return parsed;
-}
-
-function pruneToLimit(
-  conversations: Record<string, StoredConversationReference & { lastSeenAt?: string }>,
-) {
+function pruneToLimit(conversations: Record<string, StoredConversationReference>) {
   const entries = Object.entries(conversations);
   if (entries.length <= MAX_CONVERSATIONS) {
     return conversations;
   }
 
   entries.sort((a, b) => {
-    const aTs = parseTimestamp(a[1].lastSeenAt) ?? 0;
-    const bTs = parseTimestamp(b[1].lastSeenAt) ?? 0;
+    const aTs = parseStoredConversationTimestamp(a[1].lastSeenAt) ?? 0;
+    const bTs = parseStoredConversationTimestamp(b[1].lastSeenAt) ?? 0;
     return aTs - bTs;
   });
 
@@ -45,14 +39,14 @@ function pruneToLimit(
 }
 
 function pruneExpired(
-  conversations: Record<string, StoredConversationReference & { lastSeenAt?: string }>,
+  conversations: Record<string, StoredConversationReference>,
   nowMs: number,
   ttlMs: number,
 ) {
   let removed = false;
   const kept: typeof conversations = {};
   for (const [conversationId, reference] of Object.entries(conversations)) {
-    const lastSeenAt = parseTimestamp(reference.lastSeenAt);
+    const lastSeenAt = parseStoredConversationTimestamp(reference.lastSeenAt);
     // Preserve legacy entries that have no lastSeenAt until they're seen again.
     if (lastSeenAt != null && nowMs - lastSeenAt > ttlMs) {
       removed = true;
@@ -63,10 +57,6 @@ function pruneExpired(
   return { conversations: kept, removed };
 }
 
-function normalizeConversationId(raw: string): string {
-  return raw.split(";")[0] ?? raw;
-}
-
 export function createMSTeamsConversationStoreFs(params?: {
   env?: NodeJS.ProcessEnv;
   homedir?: () => string;
@@ -86,7 +76,7 @@ export function createMSTeamsConversationStoreFs(params?: {
   const empty: ConversationStoreData = { version: 1, conversations: {} };
 
   const readStore = async (): Promise<ConversationStoreData> => {
-    const { value } = await readJsonFile<ConversationStoreData>(filePath, empty);
+    const { value } = await readJsonFile(filePath, empty);
     if (
       value.version !== 1 ||
       !value.conversations ||
@@ -102,45 +92,32 @@ export function createMSTeamsConversationStoreFs(params?: {
 
   const list = async (): Promise<MSTeamsConversationStoreEntry[]> => {
     const store = await readStore();
-    return Object.entries(store.conversations).map(([conversationId, reference]) => ({
-      conversationId,
-      reference,
-    }));
+    return toConversationStoreEntries(Object.entries(store.conversations));
   };
 
   const get = async (conversationId: string): Promise<StoredConversationReference | null> => {
     const store = await readStore();
-    return store.conversations[normalizeConversationId(conversationId)] ?? null;
+    return store.conversations[normalizeStoredConversationId(conversationId)] ?? null;
   };
 
-  const findByUserId = async (id: string): Promise<MSTeamsConversationStoreEntry | null> => {
-    const target = id.trim();
-    if (!target) {
-      return null;
-    }
-    for (const entry of await list()) {
-      const { conversationId, reference } = entry;
-      if (reference.user?.aadObjectId === target) {
-        return { conversationId, reference };
-      }
-      if (reference.user?.id === target) {
-        return { conversationId, reference };
-      }
-    }
-    return null;
+  const findPreferredDmByUserId = async (
+    id: string,
+  ): Promise<MSTeamsConversationStoreEntry | null> => {
+    return findPreferredDmConversationByUserId(await list(), id);
   };
 
   const upsert = async (
     conversationId: string,
     reference: StoredConversationReference,
   ): Promise<void> => {
-    const normalizedId = normalizeConversationId(conversationId);
+    const normalizedId = normalizeStoredConversationId(conversationId);
     await withFileLock(filePath, empty, async () => {
       const store = await readStore();
-      store.conversations[normalizedId] = {
-        ...reference,
-        lastSeenAt: new Date().toISOString(),
-      };
+      store.conversations[normalizedId] = mergeStoredConversationReference(
+        store.conversations[normalizedId],
+        reference,
+        new Date().toISOString(),
+      );
       const nowMs = Date.now();
       store.conversations = pruneExpired(store.conversations, nowMs, ttlMs).conversations;
       store.conversations = pruneToLimit(store.conversations);
@@ -149,7 +126,7 @@ export function createMSTeamsConversationStoreFs(params?: {
   };
 
   const remove = async (conversationId: string): Promise<boolean> => {
-    const normalizedId = normalizeConversationId(conversationId);
+    const normalizedId = normalizeStoredConversationId(conversationId);
     return await withFileLock(filePath, empty, async () => {
       const store = await readStore();
       if (!(normalizedId in store.conversations)) {
@@ -161,5 +138,12 @@ export function createMSTeamsConversationStoreFs(params?: {
     });
   };
 
-  return { upsert, get, list, remove, findByUserId };
+  return {
+    upsert,
+    get,
+    list,
+    remove,
+    findPreferredDmByUserId,
+    findByUserId: findPreferredDmByUserId,
+  };
 }

package/src/conversation-store-helpers.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it } from "vitest";
+import { findPreferredDmConversationByUserId } from "./conversation-store-helpers.js";
+import type { MSTeamsConversationStoreEntry } from "./conversation-store.js";
+
+function entry(params: {
+  conversationId: string;
+  userId?: string;
+  aadObjectId?: string;
+  conversationType?: string;
+  lastSeenAt?: string;
+}): MSTeamsConversationStoreEntry {
+  return {
+    conversationId: params.conversationId,
+    reference: {
+      user: {
+        id: params.userId ?? "user-1",
+        aadObjectId: params.aadObjectId ?? "aad-1",
+      },
+      conversation: {
+        id: params.conversationId,
+        conversationType: params.conversationType,
+      },
+      lastSeenAt: params.lastSeenAt,
+    },
+  };
+}
+
+describe("findPreferredDmConversationByUserId", () => {
+  it("returns null for empty id", () => {
+    expect(findPreferredDmConversationByUserId([], "  ")).toBeNull();
+  });
+
+  it("returns null when no entries match", () => {
+    const entries = [entry({ conversationId: "conv-1", aadObjectId: "other-user" })];
+    expect(findPreferredDmConversationByUserId(entries, "aad-1")).toBeNull();
+  });
+
+  it("returns a personal DM conversation by aadObjectId", () => {
+    const entries = [
+      entry({
+        conversationId: "dm-conv",
+        aadObjectId: "aad-target",
+        conversationType: "personal",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result?.conversationId).toBe("dm-conv");
+  });
+
+  it("returns a personal DM conversation by user.id", () => {
+    const entries = [
+      entry({
+        conversationId: "dm-conv",
+        userId: "user-target",
+        aadObjectId: "other",
+        conversationType: "personal",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "user-target");
+    expect(result?.conversationId).toBe("dm-conv");
+  });
+
+  it("does NOT return a channel conversation for a user lookup (#54520)", () => {
+    // This is the core bug: user sends messages in both a DM and a channel.
+    // The channel conversation also carries the user's aadObjectId.
+    // findPreferredDmByUserId must NOT return the channel conversation.
+    const entries = [
+      entry({
+        conversationId: "19:channel@thread.tacv2",
+        aadObjectId: "aad-target",
+        conversationType: "channel",
+        lastSeenAt: "2026-03-25T21:00:00.000Z",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result).toBeNull();
+  });
+
+  it("does NOT return a groupChat conversation for a user lookup (#54520)", () => {
+    const entries = [
+      entry({
+        conversationId: "19:group@thread.tacv2",
+        aadObjectId: "aad-target",
+        conversationType: "groupChat",
+        lastSeenAt: "2026-03-25T21:00:00.000Z",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result).toBeNull();
+  });
+
+  it("prefers personal DM over channel even when channel is more recent (#54520)", () => {
+    // Reproduces the exact race: channel message arrives after DM, but the
+    // DM conversation should still be returned.
+    const entries = [
+      entry({
+        conversationId: "dm-conv",
+        aadObjectId: "aad-target",
+        conversationType: "personal",
+        lastSeenAt: "2026-03-25T20:00:00.000Z",
+      }),
+      entry({
+        conversationId: "19:channel@thread.tacv2",
+        aadObjectId: "aad-target",
+        conversationType: "channel",
+        lastSeenAt: "2026-03-25T21:00:00.000Z",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result?.conversationId).toBe("dm-conv");
+  });
+
+  it("prefers personal DM over groupChat even when groupChat is more recent", () => {
+    const entries = [
+      entry({
+        conversationId: "dm-conv",
+        aadObjectId: "aad-target",
+        conversationType: "personal",
+        lastSeenAt: "2026-03-25T20:00:00.000Z",
+      }),
+      entry({
+        conversationId: "19:group@thread.tacv2",
+        aadObjectId: "aad-target",
+        conversationType: "groupChat",
+        lastSeenAt: "2026-03-25T21:00:00.000Z",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result?.conversationId).toBe("dm-conv");
+  });
+
+  it("prefers the freshest personal DM when multiple exist", () => {
+    const entries = [
+      entry({
+        conversationId: "dm-old",
+        aadObjectId: "aad-target",
+        conversationType: "personal",
+        lastSeenAt: "2026-03-25T20:00:00.000Z",
+      }),
+      entry({
+        conversationId: "dm-new",
+        aadObjectId: "aad-target",
+        conversationType: "personal",
+        lastSeenAt: "2026-03-25T21:00:00.000Z",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result?.conversationId).toBe("dm-new");
+  });
+
+  it("falls back to unknown-type entries when no personal conversations exist", () => {
+    // Legacy entries without conversationType should still be usable as a
+    // fallback to avoid breaking existing deployments.
+    const entries = [
+      entry({
+        conversationId: "legacy-conv",
+        aadObjectId: "aad-target",
+        // No conversationType set (legacy entry)
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result?.conversationId).toBe("legacy-conv");
+  });
+
+  it("prefers personal over unknown-type entries", () => {
+    const entries = [
+      entry({
+        conversationId: "legacy-conv",
+        aadObjectId: "aad-target",
+        lastSeenAt: "2026-03-25T21:00:00.000Z",
+        // No conversationType
+      }),
+      entry({
+        conversationId: "dm-conv",
+        aadObjectId: "aad-target",
+        conversationType: "personal",
+        lastSeenAt: "2026-03-25T20:00:00.000Z",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result?.conversationId).toBe("dm-conv");
+  });
+
+  it("does NOT fall back to channel/group when no personal or unknown entries exist", () => {
+    const entries = [
+      entry({
+        conversationId: "19:channel@thread.tacv2",
+        aadObjectId: "aad-target",
+        conversationType: "channel",
+        lastSeenAt: "2026-03-25T21:00:00.000Z",
+      }),
+      entry({
+        conversationId: "19:group@thread.tacv2",
+        aadObjectId: "aad-target",
+        conversationType: "groupChat",
+        lastSeenAt: "2026-03-25T20:00:00.000Z",
+      }),
+    ];
+    const result = findPreferredDmConversationByUserId(entries, "aad-target");
+    expect(result).toBeNull();
+  });
+});

package/src/conversation-store-helpers.ts

@@ -0,0 +1,105 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+import type {
+  MSTeamsConversationStoreEntry,
+  StoredConversationReference,
+} from "./conversation-store.js";
+
+export function normalizeStoredConversationId(raw: string): string {
+  return raw.split(";")[0] ?? raw;
+}
+
+export function parseStoredConversationTimestamp(value: string | undefined): number | null {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    return null;
+  }
+  return parsed;
+}
+
+export function toConversationStoreEntries(
+  entries: Iterable<[string, StoredConversationReference]>,
+): MSTeamsConversationStoreEntry[] {
+  return Array.from(entries, ([conversationId, reference]) => ({
+    conversationId,
+    reference,
+  }));
+}
+
+export function mergeStoredConversationReference(
+  existing: StoredConversationReference | undefined,
+  incoming: StoredConversationReference,
+  nowIso: string,
+): StoredConversationReference {
+  return {
+    // Preserve fields from the previous entry that may not be present on every
+    // inbound activity. Without this, sparse activities (e.g. conversationUpdate,
+    // reactions) would clear previously captured values. Some fields are only
+    // populated opportunistically, such as timezone from clientInfo entities and
+    // graphChatId from Graph lookups used for DM media downloads.
+    ...(existing?.timezone && !incoming.timezone ? { timezone: existing.timezone } : {}),
+    ...(existing?.graphChatId && !incoming.graphChatId
+      ? { graphChatId: existing.graphChatId }
+      : {}),
+    ...(existing?.tenantId && !incoming.tenantId ? { tenantId: existing.tenantId } : {}),
+    ...(existing?.aadObjectId && !incoming.aadObjectId
+      ? { aadObjectId: existing.aadObjectId }
+      : {}),
+    ...incoming,
+    lastSeenAt: nowIso,
+  };
+}
+
+export function findPreferredDmConversationByUserId(
+  entries: Iterable<MSTeamsConversationStoreEntry>,
+  id: string,
+): MSTeamsConversationStoreEntry | null {
+  const target = id.trim();
+  if (!target) {
+    return null;
+  }
+
+  // Partition user matches into DM-safe and non-DM buckets.
+  // Channel and group conversations also carry the sender's aadObjectId, but
+  // returning one of those when the caller asked for a user-targeted DM would
+  // leak the reply into a shared channel -- the root cause of #54520.
+  const personalMatches: MSTeamsConversationStoreEntry[] = [];
+  const unknownTypeMatches: MSTeamsConversationStoreEntry[] = [];
+  for (const entry of entries) {
+    if (entry.reference.user?.aadObjectId !== target && entry.reference.user?.id !== target) {
+      continue;
+    }
+    const convType = normalizeLowercaseStringOrEmpty(
+      entry.reference.conversation?.conversationType ?? "",
+    );
+    if (convType === "personal") {
+      personalMatches.push(entry);
+    } else if (convType === "channel" || convType === "groupchat") {
+      // Explicitly skip channel/group conversations -- these must never be
+      // returned for a user-targeted DM lookup.
+    } else {
+      // Legacy entries without conversationType are ambiguous. Include them
+      // as a fallback but rank below confirmed personal conversations.
+      unknownTypeMatches.push(entry);
+    }
+  }
+
+  // Prefer confirmed personal DMs, fall back to unknown-type entries.
+  const candidates = personalMatches.length > 0 ? personalMatches : unknownTypeMatches;
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  // When multiple candidates exist, prefer the most recently seen one.
+  if (candidates.length > 1) {
+    candidates.sort(
+      (a, b) =>
+        (parseStoredConversationTimestamp(b.reference.lastSeenAt) ?? 0) -
+        (parseStoredConversationTimestamp(a.reference.lastSeenAt) ?? 0),
+    );
+  }
+
+  return candidates[0] ?? null;
+}

package/src/conversation-store-memory.ts

@@ -1,3 +1,9 @@
+import {
+  findPreferredDmConversationByUserId,
+  mergeStoredConversationReference,
+  normalizeStoredConversationId,
+  toConversationStoreEntries,
+} from "./conversation-store-helpers.js";
 import type {
   MSTeamsConversationStore,
   MSTeamsConversationStoreEntry,
@@ -9,39 +15,37 @@ export function createMSTeamsConversationStoreMemory(
 ): MSTeamsConversationStore {
   const map = new Map<string, StoredConversationReference>();
   for (const { conversationId, reference } of initial) {
-    map.set(conversationId, reference);
+    map.set(normalizeStoredConversationId(conversationId), reference);
   }
 
+  const findPreferredDmByUserId = async (
+    id: string,
+  ): Promise<MSTeamsConversationStoreEntry | null> => {
+    return findPreferredDmConversationByUserId(toConversationStoreEntries(map.entries()), id);
+  };
+
   return {
     upsert: async (conversationId, reference) => {
-      map.set(conversationId, reference);
+      const normalizedId = normalizeStoredConversationId(conversationId);
+      map.set(
+        normalizedId,
+        mergeStoredConversationReference(
+          map.get(normalizedId),
+          reference,
+          new Date().toISOString(),
+        ),
+      );
     },
     get: async (conversationId) => {
-      return map.get(conversationId) ?? null;
+      return map.get(normalizeStoredConversationId(conversationId)) ?? null;
     },
     list: async () => {
-      return Array.from(map.entries()).map(([conversationId, reference]) => ({
-        conversationId,
-        reference,
-      }));
+      return toConversationStoreEntries(map.entries());
     },
     remove: async (conversationId) => {
-      return map.delete(conversationId);
-    },
-    findByUserId: async (id) => {
-      const target = id.trim();
-      if (!target) {
-        return null;
-      }
-      for (const [conversationId, reference] of map.entries()) {
-        if (reference.user?.aadObjectId === target) {
-          return { conversationId, reference };
-        }
-        if (reference.user?.id === target) {
-          return { conversationId, reference };
-        }
-      }
-      return null;
+      return map.delete(normalizeStoredConversationId(conversationId));
     },
+    findPreferredDmByUserId,
+    findByUserId: findPreferredDmByUserId,
   };
 }