@openclaw/msteams 2026.3.13 → 2026.5.2-beta.1

package/src/monitor-handler/message-handler.dm-media.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { translateMSTeamsDmConversationIdForGraph } from "../inbound.js";
+
+describe("translateMSTeamsDmConversationIdForGraph", () => {
+  it("translates a: conversation ID to Graph format for DMs", () => {
+    const result = translateMSTeamsDmConversationIdForGraph({
+      isDirectMessage: true,
+      conversationId: "a:1abc2def3",
+      aadObjectId: "user-aad-id",
+      appId: "bot-app-id",
+    });
+    expect(result).toBe("19:user-aad-id_bot-app-id@unq.gbl.spaces");
+  });
+
+  it("passes through non-a: conversation IDs unchanged", () => {
+    const result = translateMSTeamsDmConversationIdForGraph({
+      isDirectMessage: true,
+      conversationId: "19:existing@unq.gbl.spaces",
+      aadObjectId: "user-aad-id",
+      appId: "bot-app-id",
+    });
+    expect(result).toBe("19:existing@unq.gbl.spaces");
+  });
+
+  it("passes through when aadObjectId is missing", () => {
+    const result = translateMSTeamsDmConversationIdForGraph({
+      isDirectMessage: true,
+      conversationId: "a:1abc2def3",
+      aadObjectId: null,
+      appId: "bot-app-id",
+    });
+    expect(result).toBe("a:1abc2def3");
+  });
+
+  it("passes through when appId is missing", () => {
+    const result = translateMSTeamsDmConversationIdForGraph({
+      isDirectMessage: true,
+      conversationId: "a:1abc2def3",
+      aadObjectId: "user-aad-id",
+      appId: null,
+    });
+    expect(result).toBe("a:1abc2def3");
+  });
+
+  it("passes through for non-DM conversations even with a: prefix", () => {
+    const result = translateMSTeamsDmConversationIdForGraph({
+      isDirectMessage: false,
+      conversationId: "a:1abc2def3",
+      aadObjectId: "user-aad-id",
+      appId: "bot-app-id",
+    });
+    expect(result).toBe("a:1abc2def3");
+  });
+});

package/src/monitor-handler/message-handler.test-support.ts

@@ -0,0 +1,100 @@
+import { vi } from "vitest";
+import type { OpenClawConfig, RuntimeEnv } from "../../runtime-api.js";
+import type { MSTeamsMessageHandlerDeps } from "../monitor-handler.js";
+import { installMSTeamsTestRuntime } from "../monitor-handler.test-helpers.js";
+
+export const channelConversationId = "19:general@thread.tacv2";
+
+type MessageHandlerDepsOptions = {
+  enqueueSystemEvent?: ReturnType<typeof vi.fn>;
+  readAllowFromStore?: ReturnType<typeof vi.fn>;
+  upsertPairingRequest?: ReturnType<typeof vi.fn>;
+  recordInboundSession?: ReturnType<typeof vi.fn>;
+  resolveAgentRoute?: (params: { peer: { kind: string; id: string } }) => unknown;
+};
+
+export function createMessageHandlerDeps(
+  cfg: OpenClawConfig,
+  options: MessageHandlerDepsOptions = {},
+) {
+  const enqueueSystemEvent = options.enqueueSystemEvent ?? vi.fn();
+  const readAllowFromStore = options.readAllowFromStore ?? vi.fn(async () => []);
+  const upsertPairingRequest = options.upsertPairingRequest ?? vi.fn(async () => null);
+  const recordInboundSession =
+    options.recordInboundSession ?? vi.fn(async (_params: { sessionKey: string }) => undefined);
+  const resolveAgentRoute =
+    options.resolveAgentRoute ??
+    vi.fn(({ peer }: { peer: { kind: string; id: string } }) => ({
+      sessionKey: `agent:main:msteams:${peer.kind}:${peer.id}`,
+      agentId: "main",
+      accountId: "default",
+      mainSessionKey: "agent:main:main",
+      lastRoutePolicy: "session" as const,
+      matchedBy: "default" as const,
+    }));
+
+  installMSTeamsTestRuntime({
+    enqueueSystemEvent,
+    readAllowFromStore,
+    upsertPairingRequest,
+    recordInboundSession,
+    resolveAgentRoute,
+    resolveTextChunkLimit: () => 4000,
+    resolveStorePath: () => "/tmp/test-store",
+  });
+
+  const conversationStore = {
+    get: vi.fn(async () => null),
+    upsert: vi.fn(async () => undefined),
+    list: vi.fn(async () => []),
+    remove: vi.fn(async () => false),
+    findPreferredDmByUserId: vi.fn(async () => null),
+    findByUserId: vi.fn(async () => null),
+  } satisfies MSTeamsMessageHandlerDeps["conversationStore"];
+
+  const deps: MSTeamsMessageHandlerDeps = {
+    cfg,
+    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,
+    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"],
+  };
+
+  return {
+    conversationStore,
+    deps,
+    enqueueSystemEvent,
+    readAllowFromStore,
+    upsertPairingRequest,
+    recordInboundSession,
+    resolveAgentRoute,
+  };
+}
+
+export function buildChannelActivity(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "msg-1",
+    type: "message",
+    text: "hello",
+    from: { id: "user-id", aadObjectId: "user-aad", name: "Test User" },
+    recipient: { id: "bot-id", name: "Bot" },
+    conversation: { id: channelConversationId, conversationType: "channel" },
+    channelData: { team: { id: "team-1" } },
+    attachments: [],
+    entities: [{ type: "mention", mentioned: { id: "bot-id" } }],
+    ...overrides,
+  };
+}

package/src/monitor-handler/message-handler.thread-parent.test.ts

@@ -0,0 +1,223 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { OpenClawConfig } from "../../runtime-api.js";
+import { _resetThreadParentContextCachesForTest } from "../thread-parent-context.js";
+import "./message-handler-mock-support.test-support.js";
+import { getRuntimeApiMockState } from "./message-handler-mock-support.test-support.js";
+import { createMSTeamsMessageHandler } from "./message-handler.js";
+import {
+  buildChannelActivity,
+  channelConversationId,
+  createMessageHandlerDeps,
+} from "./message-handler.test-support.js";
+
+const runtimeApiMockState = getRuntimeApiMockState();
+const fetchChannelMessageMock = vi.hoisted(() => vi.fn());
+const fetchThreadRepliesMock = vi.hoisted(() => vi.fn(async () => []));
+const resolveTeamGroupIdMock = vi.hoisted(() => vi.fn(async () => "group-1"));
+
+vi.mock("../graph-thread.js", () => {
+  const stripHtmlFromTeamsMessage = (html: string) =>
+    html
+      .replace(/<at[^>]*>(.*?)<\/at>/gi, "@$1")
+      .replace(/<[^>]*>/g, " ")
+      .replace(/&amp;/g, "&")
+      .replace(/&lt;/g, "<")
+      .replace(/&gt;/g, ">")
+      .replace(/&quot;/g, '"')
+      .replace(/&#39;/g, "'")
+      .replace(/&nbsp;/g, " ")
+      .replace(/\s+/g, " ")
+      .trim();
+  return {
+    stripHtmlFromTeamsMessage,
+    resolveTeamGroupId: resolveTeamGroupIdMock,
+    fetchChannelMessage: fetchChannelMessageMock,
+    fetchThreadReplies: fetchThreadRepliesMock,
+  };
+});
+
+describe("msteams thread parent context injection", () => {
+  type MessageHandler = ReturnType<typeof createMSTeamsMessageHandler>;
+
+  function findParentSystemEventCall(
+    mock: ReturnType<typeof vi.fn>,
+  ): [string, { sessionKey: string; contextKey?: string }] | undefined {
+    const calls = mock.mock.calls as Array<[string, { sessionKey: string; contextKey?: string }]>;
+    return calls.find(([text]) => text.startsWith("Replying to @"));
+  }
+
+  async function dispatchThreadReply(handler: MessageHandler, id: string) {
+    await handler({
+      activity: buildChannelActivity({ id, replyToId: "thread-root-123" }),
+      sendActivity: vi.fn(async () => undefined),
+    } as unknown as Parameters<MessageHandler>[0]);
+  }
+
+  async function dispatchTwoThreadReplies(handler: MessageHandler) {
+    await dispatchThreadReply(handler, "msg-reply-1");
+    await dispatchThreadReply(handler, "msg-reply-2");
+  }
+
+  beforeEach(() => {
+    _resetThreadParentContextCachesForTest();
+    fetchChannelMessageMock.mockReset();
+    fetchThreadRepliesMock.mockReset();
+    fetchThreadRepliesMock.mockImplementation(async () => []);
+    resolveTeamGroupIdMock.mockReset();
+    resolveTeamGroupIdMock.mockImplementation(async () => "group-1");
+    runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher.mockClear();
+  });
+
+  const cfg: OpenClawConfig = {
+    channels: { msteams: { groupPolicy: "open" } },
+  } as OpenClawConfig;
+
+  it("enqueues a Replying to @sender system event on the first thread reply", async () => {
+    fetchChannelMessageMock.mockResolvedValueOnce({
+      id: "thread-root-123",
+      from: { user: { displayName: "Alice", id: "alice-id" } },
+      body: { content: "Can someone investigate the latency spike?", contentType: "text" },
+    });
+    const { deps, enqueueSystemEvent } = createMessageHandlerDeps(cfg);
+    const handler = createMSTeamsMessageHandler(deps);
+
+    await handler({
+      activity: buildChannelActivity({ id: "msg-reply-1", replyToId: "thread-root-123" }),
+      sendActivity: vi.fn(async () => undefined),
+    } as unknown as Parameters<typeof handler>[0]);
+
+    const parentCall = findParentSystemEventCall(enqueueSystemEvent);
+    expect(parentCall).toBeDefined();
+    expect(parentCall?.[0]).toBe("Replying to @Alice: Can someone investigate the latency spike?");
+    expect(parentCall?.[1]?.contextKey).toContain("msteams:thread-parent:");
+    expect(parentCall?.[1]?.contextKey).toContain("thread-root-123");
+  });
+
+  it("caches parent fetches across thread replies in the same session", async () => {
+    fetchChannelMessageMock.mockResolvedValue({
+      id: "thread-root-123",
+      from: { user: { displayName: "Alice" } },
+      body: { content: "Original question", contentType: "text" },
+    });
+    const { deps } = createMessageHandlerDeps(cfg);
+    const handler = createMSTeamsMessageHandler(deps);
+
+    await dispatchTwoThreadReplies(handler);
+
+    // Parent message fetched exactly once across two replies thanks to LRU cache.
+    expect(fetchChannelMessageMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not re-enqueue the same parent context within the same session", async () => {
+    fetchChannelMessageMock.mockResolvedValue({
+      id: "thread-root-123",
+      from: { user: { displayName: "Alice" } },
+      body: { content: "Original question", contentType: "text" },
+    });
+    const { deps, enqueueSystemEvent } = createMessageHandlerDeps(cfg);
+    const handler = createMSTeamsMessageHandler(deps);
+
+    await dispatchTwoThreadReplies(handler);
+
+    const parentCalls = enqueueSystemEvent.mock.calls.filter(
+      ([text]) => typeof text === "string" && text.startsWith("Replying to @"),
+    );
+    expect(parentCalls).toHaveLength(1);
+  });
+
+  it("does not enqueue parent context when allowlist visibility blocks the parent sender", async () => {
+    fetchChannelMessageMock.mockResolvedValue({
+      id: "thread-root-123",
+      from: { user: { displayName: "Mallory", id: "mallory-aad" } },
+      body: { content: "Blocked context", contentType: "text" },
+    });
+    const { deps, enqueueSystemEvent } = createMessageHandlerDeps({
+      channels: {
+        msteams: {
+          groupPolicy: "allowlist",
+          groupAllowFrom: ["alice-aad"],
+          contextVisibility: "allowlist",
+          teams: {
+            "team-1": {
+              channels: {
+                [channelConversationId]: { requireMention: false },
+              },
+            },
+          },
+        },
+      },
+    } as OpenClawConfig);
+    const handler = createMSTeamsMessageHandler(deps);
+
+    await handler({
+      activity: buildChannelActivity({
+        id: "msg-reply-1",
+        replyToId: "thread-root-123",
+        from: { id: "alice-id", aadObjectId: "alice-aad", name: "Alice" },
+      }),
+      sendActivity: vi.fn(async () => undefined),
+    } as unknown as Parameters<typeof handler>[0]);
+
+    expect(findParentSystemEventCall(enqueueSystemEvent)).toBeUndefined();
+  });
+
+  it("handles Graph failure gracefully without throwing or emitting a parent event", async () => {
+    fetchChannelMessageMock.mockRejectedValueOnce(new Error("graph down"));
+    const { deps, enqueueSystemEvent } = createMessageHandlerDeps(cfg);
+    const handler = createMSTeamsMessageHandler(deps);
+
+    await handler({
+      activity: buildChannelActivity({ id: "msg-reply-1", replyToId: "thread-root-123" }),
+      sendActivity: vi.fn(async () => undefined),
+    } as unknown as Parameters<typeof handler>[0]);
+
+    const parentCall = findParentSystemEventCall(enqueueSystemEvent);
+    expect(parentCall).toBeUndefined();
+    // Original inbound system event still fires (best-effort parent fetch does not block).
+    expect(enqueueSystemEvent).toHaveBeenCalled();
+  });
+
+  it("does not fetch parent for DM replyToId", async () => {
+    fetchChannelMessageMock.mockResolvedValue({
+      id: "x",
+      from: { user: { displayName: "Alice" } },
+      body: { content: "should-not-happen", contentType: "text" },
+    });
+    const { deps, enqueueSystemEvent } = createMessageHandlerDeps({
+      channels: { msteams: { allowFrom: ["*"] } },
+    } as OpenClawConfig);
+    const handler = createMSTeamsMessageHandler(deps);
+
+    await handler({
+      activity: {
+        ...buildChannelActivity(),
+        conversation: { id: "a:dm-conversation", conversationType: "personal" },
+        channelData: {},
+        replyToId: "dm-parent",
+        entities: [],
+      },
+      sendActivity: vi.fn(async () => undefined),
+    } as unknown as Parameters<typeof handler>[0]);
+
+    expect(fetchChannelMessageMock).not.toHaveBeenCalled();
+    expect(findParentSystemEventCall(enqueueSystemEvent)).toBeUndefined();
+  });
+
+  it("does not fetch parent for top-level channel messages without replyToId", async () => {
+    fetchChannelMessageMock.mockResolvedValue({
+      id: "x",
+      from: { user: { displayName: "Alice" } },
+      body: { content: "should-not-happen", contentType: "text" },
+    });
+    const { deps, enqueueSystemEvent } = createMessageHandlerDeps(cfg);
+    const handler = createMSTeamsMessageHandler(deps);
+
+    await handler({
+      activity: buildChannelActivity({ id: "msg-root-1", replyToId: undefined }),
+      sendActivity: vi.fn(async () => undefined),
+    } as unknown as Parameters<typeof handler>[0]);
+
+    expect(fetchChannelMessageMock).not.toHaveBeenCalled();
+    expect(findParentSystemEventCall(enqueueSystemEvent)).toBeUndefined();
+  });
+});

package/src/monitor-handler/message-handler.thread-session.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { resolveMSTeamsRouteSessionKey } from "./thread-session.js";
+
+const channelConversationSessionKey = "agent:main:msteams:channel:19:channel@thread.tacv2";
+
+describe("msteams thread session isolation", () => {
+  it("appends thread suffix to session key for channel thread replies", async () => {
+    const sessionKey = resolveMSTeamsRouteSessionKey({
+      baseSessionKey: channelConversationSessionKey,
+      isChannel: true,
+      replyToId: "thread-root-123",
+    });
+
+    expect(sessionKey).toContain("thread:");
+    expect(sessionKey).toContain("thread-root-123");
+  });
+
+  it("does not append thread suffix for top-level channel messages", async () => {
+    const sessionKey = resolveMSTeamsRouteSessionKey({
+      baseSessionKey: channelConversationSessionKey,
+      isChannel: true,
+      replyToId: undefined,
+    });
+
+    expect(sessionKey).not.toContain("thread:");
+    expect(sessionKey).toBe(channelConversationSessionKey);
+  });
+
+  it("produces different session keys for different threads in the same channel", async () => {
+    const sessionKeyA = resolveMSTeamsRouteSessionKey({
+      baseSessionKey: channelConversationSessionKey,
+      isChannel: true,
+      replyToId: "thread-A",
+    });
+    const sessionKeyB = resolveMSTeamsRouteSessionKey({
+      baseSessionKey: channelConversationSessionKey,
+      isChannel: true,
+      replyToId: "thread-B",
+    });
+
+    expect(sessionKeyA).not.toBe(sessionKeyB);
+    expect(sessionKeyA).toContain("thread-a"); // normalized lowercase
+    expect(sessionKeyB).toContain("thread-b");
+  });
+
+  it("does not affect DM session keys", async () => {
+    const sessionKey = resolveMSTeamsRouteSessionKey({
+      baseSessionKey: "agent:main:msteams:dm:user-1",
+      isChannel: false,
+      replyToId: "some-reply-id",
+    });
+
+    expect(sessionKey).not.toContain("thread:");
+  });
+
+  it("does not affect group chat session keys", async () => {
+    const sessionKey = resolveMSTeamsRouteSessionKey({
+      baseSessionKey: "agent:main:msteams:group:19:group-chat-id@unq.gbl.spaces",
+      isChannel: false,
+      replyToId: "some-reply-id",
+    });
+
+    expect(sessionKey).not.toContain("thread:");
+  });
+
+  it("prefers conversation message id over replyToId for deep channel replies", async () => {
+    const sessionKey = resolveMSTeamsRouteSessionKey({
+      baseSessionKey: channelConversationSessionKey,
+      isChannel: true,
+      conversationMessageId: "thread-root",
+      replyToId: "nested-reply",
+    });
+
+    expect(sessionKey).toContain("thread-root");
+    expect(sessionKey).not.toContain("nested-reply");
+  });
+});