@kodelyth/msteams 2026.5.42 → 2026.6.1

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

@@ -1,54 +0,0 @@
-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

@@ -1,99 +0,0 @@
-import { vi } from "vitest";
-import type { KlawConfig, PluginRuntime, 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;
-  hasControlCommand?: PluginRuntime["channel"]["text"]["hasControlCommand"];
-};
-
-export function createMessageHandlerDeps(cfg: KlawConfig, 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,
-    hasControlCommand: options.hasControlCommand,
-    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

@@ -1,225 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { KlawConfig } 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: KlawConfig = {
-    channels: { msteams: { groupPolicy: "open" } },
-  } as KlawConfig;
-
-  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);
-    if (!parentCall) {
-      throw new Error("expected parent thread system event");
-    }
-    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 KlawConfig);
-    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 KlawConfig);
-    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

@@ -1,132 +0,0 @@
-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", () => {
-    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", () => {
-    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", () => {
-    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", () => {
-    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", () => {
-    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", () => {
-    const sessionKey = resolveMSTeamsRouteSessionKey({
-      baseSessionKey: channelConversationSessionKey,
-      isChannel: true,
-      conversationMessageId: "thread-root",
-      replyToId: "nested-reply",
-    });
-
-    expect(sessionKey).toContain("thread-root");
-    expect(sessionKey).not.toContain("nested-reply");
-  });
-
-  // Regression coverage for #66771 — malformed mixed thread session key from
-  // pre-suffixed base. The handler may pass a base that has already been
-  // thread-qualified by a prior turn (e.g. cache-miss-returned route object
-  // mutated in-place by message-handler.ts:489). The helper must be idempotent
-  // and re-derive from a clean base.
-  describe("idempotency against pre-suffixed bases (#66771)", () => {
-    it("collapses an already-thread-suffixed base when re-applied with a different thread", () => {
-      const sessionKey = resolveMSTeamsRouteSessionKey({
-        baseSessionKey: `${channelConversationSessionKey}:thread:old-root`,
-        isChannel: true,
-        conversationMessageId: "new-root",
-      });
-
-      expect(sessionKey).toBe(`${channelConversationSessionKey}:thread:new-root`);
-      expect(sessionKey).not.toContain("old-root");
-      // No `:thread:OLD:thread:NEW` mixed shape.
-      expect(sessionKey.match(/:thread:/g)).toHaveLength(1);
-    });
-
-    it("collapses a doubly-thread-suffixed (already-malformed) base to a single suffix", () => {
-      const sessionKey = resolveMSTeamsRouteSessionKey({
-        baseSessionKey: `${channelConversationSessionKey}:thread:x:thread:y`,
-        isChannel: true,
-        conversationMessageId: "z",
-      });
-
-      expect(sessionKey).toBe(`${channelConversationSessionKey}:thread:z`);
-      expect(sessionKey).not.toContain(":thread:x");
-      expect(sessionKey).not.toContain(":thread:y");
-      expect(sessionKey.match(/:thread:/g)).toHaveLength(1);
-    });
-
-    it("is idempotent when the base is already qualified with the same thread", () => {
-      const sessionKey = resolveMSTeamsRouteSessionKey({
-        baseSessionKey: `${channelConversationSessionKey}:thread:same-root`,
-        isChannel: true,
-        conversationMessageId: "same-root",
-      });
-
-      expect(sessionKey).toBe(`${channelConversationSessionKey}:thread:same-root`);
-      expect(sessionKey.match(/:thread:/g)).toHaveLength(1);
-    });
-
-    it("strips a stale thread suffix when the inbound is a top-level channel message", () => {
-      const sessionKey = resolveMSTeamsRouteSessionKey({
-        baseSessionKey: `${channelConversationSessionKey}:thread:stale-root`,
-        isChannel: true,
-        replyToId: undefined,
-      });
-
-      expect(sessionKey).toBe(channelConversationSessionKey);
-      expect(sessionKey).not.toContain("thread:");
-    });
-  });
-});