@kodelyth/msteams 2026.5.42 → 2026.6.2

package/src/monitor-handler/reaction-handler.test.ts

@@ -1,325 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { KlawConfig, PluginRuntime } from "../../runtime-api.js";
-import type { MSTeamsMessageHandlerDeps } from "../monitor-handler.js";
-import { setMSTeamsRuntime } from "../runtime.js";
-import { createMSTeamsReactionHandler } from "./reaction-handler.js";
-
-function buildMockRuntime(overrides?: Partial<PluginRuntime>): PluginRuntime {
-  return {
-    logging: { shouldLogVerbose: () => false },
-    channel: {
-      routing: {
-        resolveAgentRoute: vi.fn(() => ({
-          sessionKey: "test-session",
-          agentId: "agent1",
-          accountId: "default",
-        })),
-      },
-      pairing: {
-        readAllowFromStore: vi.fn(async () => []),
-        upsertPairingRequest: vi.fn(async () => null),
-      },
-    },
-    system: {
-      enqueueSystemEvent: vi.fn(),
-    },
-    ...overrides,
-  } as unknown as PluginRuntime;
-}
-
-function buildDeps(cfg: KlawConfig, _runtime?: PluginRuntime): MSTeamsMessageHandlerDeps {
-  return {
-    cfg,
-    runtime: { error: vi.fn() } as unknown as MSTeamsMessageHandlerDeps["runtime"],
-    appId: "test-app",
-    adapter: {} as MSTeamsMessageHandlerDeps["adapter"],
-    tokenProvider: { getAccessToken: vi.fn(async () => "token") },
-    textLimit: 4000,
-    mediaMaxBytes: 1024 * 1024,
-    conversationStore: {
-      upsert: vi.fn(async () => undefined),
-    } 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(),
-      warn: vi.fn(),
-    } as unknown as MSTeamsMessageHandlerDeps["log"],
-  };
-}
-
-function createReactionTestHarness() {
-  const mockRuntime = buildMockRuntime();
-  setMSTeamsRuntime(mockRuntime);
-
-  const cfg: KlawConfig = {
-    channels: { msteams: { allowFrom: ["allowed-aad"] } },
-  } as KlawConfig;
-
-  const deps = buildDeps(cfg, mockRuntime);
-  const handler = createMSTeamsReactionHandler(deps);
-  const enqueue = mockRuntime.system.enqueueSystemEvent as ReturnType<typeof vi.fn>;
-
-  return { handler, enqueue };
-}
-
-function firstEnqueueCall(enqueue: ReturnType<typeof vi.fn>): unknown[] {
-  const [call] = enqueue.mock.calls;
-  if (!call) {
-    throw new Error("Expected enqueueSystemEvent call");
-  }
-  return call;
-}
-
-function firstEnqueueLabel(enqueue: ReturnType<typeof vi.fn>): string {
-  const [label] = firstEnqueueCall(enqueue);
-  if (typeof label !== "string") {
-    throw new Error("Expected enqueueSystemEvent label");
-  }
-  return label;
-}
-
-function firstEnqueueMeta(enqueue: ReturnType<typeof vi.fn>): Record<string, unknown> {
-  const [, meta] = firstEnqueueCall(enqueue);
-  if (!meta || typeof meta !== "object") {
-    throw new Error("Expected enqueueSystemEvent metadata");
-  }
-  return meta as Record<string, unknown>;
-}
-
-async function invokeReactionEvent(
-  handler: ReturnType<typeof createMSTeamsReactionHandler>,
-  activity: Record<string, unknown>,
-  direction: "added" | "removed",
-) {
-  await handler(
-    {
-      activity: {
-        type: "messageReaction",
-        conversation: { id: "dm-conv", conversationType: "personal" },
-        ...activity,
-      },
-      sendActivity: vi.fn(async () => undefined),
-    } as never,
-    direction,
-  );
-}
-
-describe("createMSTeamsReactionHandler", () => {
-  describe("emoji mapping", () => {
-    it("maps Teams reaction types to unicode emoji in event label", async () => {
-      const mockRuntime = buildMockRuntime();
-      setMSTeamsRuntime(mockRuntime);
-
-      const cfg: KlawConfig = {
-        channels: {
-          msteams: {
-            allowFrom: ["allowed-aad"],
-          },
-        },
-      } as KlawConfig;
-
-      const deps = buildDeps(cfg);
-      const handler = createMSTeamsReactionHandler(deps);
-
-      await handler(
-        {
-          activity: {
-            type: "messageReaction",
-            reactionsAdded: [{ type: "like" }],
-            from: { id: "user-id", aadObjectId: "allowed-aad", name: "Alice" },
-            conversation: { id: "personal-conv", conversationType: "personal" },
-            replyToId: "msg-123",
-          },
-          sendActivity: vi.fn(async () => undefined),
-        } as never,
-        "added",
-      );
-
-      const enqueue = mockRuntime.system.enqueueSystemEvent as ReturnType<typeof vi.fn>;
-      expect(enqueue).toHaveBeenCalledOnce();
-      const label = firstEnqueueLabel(enqueue);
-      expect(label).toContain("👍");
-      expect(label).toContain("Alice");
-      expect(label).toContain("msg-123");
-    });
-
-    it("maps heart, laugh, surprised, sad, angry reaction types", async () => {
-      const emojiMap: Record<string, string> = {
-        heart: "❤️",
-        laugh: "😆",
-        surprised: "😮",
-        sad: "😢",
-        angry: "😡",
-      };
-
-      for (const [type, expectedEmoji] of Object.entries(emojiMap)) {
-        const mockRuntime = buildMockRuntime();
-        setMSTeamsRuntime(mockRuntime);
-
-        const cfg: KlawConfig = {
-          channels: { msteams: { allowFrom: ["allowed-aad"] } },
-        } as KlawConfig;
-
-        const deps = buildDeps(cfg, mockRuntime);
-        const handler = createMSTeamsReactionHandler(deps);
-
-        await handler(
-          {
-            activity: {
-              type: "messageReaction",
-              reactionsAdded: [{ type }],
-              from: { id: "user-id", aadObjectId: "allowed-aad", name: "Bob" },
-              conversation: { id: "dm-conv", conversationType: "personal" },
-              replyToId: "msg-456",
-            },
-            sendActivity: vi.fn(async () => undefined),
-          } as never,
-          "added",
-        );
-
-        const enqueue = mockRuntime.system.enqueueSystemEvent as ReturnType<typeof vi.fn>;
-        const label = firstEnqueueLabel(enqueue);
-        expect(label).toContain(expectedEmoji);
-      }
-    });
-  });
-
-  describe("inbound reaction events", () => {
-    it("enqueues system event for reactionsAdded", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: { id: "u1", aadObjectId: "allowed-aad", name: "User" },
-          replyToId: "msg-1",
-        },
-        "added",
-      );
-
-      expect(enqueue).toHaveBeenCalledOnce();
-      const label = firstEnqueueLabel(enqueue);
-      const meta = firstEnqueueMeta(enqueue);
-      expect(label).toContain("added");
-      expect(meta.sessionKey).toBe("test-session");
-      expect(meta.contextKey).toContain("added");
-    });
-
-    it("enqueues system event for reactionsRemoved", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsRemoved: [{ type: "heart" }],
-          from: { id: "u1", aadObjectId: "allowed-aad", name: "User" },
-          replyToId: "msg-2",
-        },
-        "removed",
-      );
-
-      expect(enqueue).toHaveBeenCalledOnce();
-      const label = firstEnqueueLabel(enqueue);
-      expect(label).toContain("removed");
-      expect(label).toContain("❤️");
-    });
-
-    it("skips when reactions array is empty", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [],
-          from: { id: "u1", aadObjectId: "allowed-aad", name: "User" },
-          replyToId: "msg-3",
-        },
-        "added",
-      );
-
-      expect(enqueue).not.toHaveBeenCalled();
-    });
-
-    it("skips when from.id is missing", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: {},
-          replyToId: "msg-4",
-        },
-        "added",
-      );
-
-      expect(enqueue).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("sender authorization", () => {
-    it("drops reaction from non-allowlisted DM sender", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: { id: "bad-user", aadObjectId: "not-allowed", name: "Attacker" },
-          replyToId: "msg-5",
-        },
-        "added",
-      );
-
-      expect(enqueue).not.toHaveBeenCalled();
-    });
-
-    it("allows reaction from allowlisted DM sender", async () => {
-      const { handler, enqueue } = createReactionTestHarness();
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: { id: "good-user", aadObjectId: "allowed-aad", name: "Alice" },
-          replyToId: "msg-6",
-        },
-        "added",
-      );
-
-      expect(enqueue).toHaveBeenCalledOnce();
-    });
-
-    it("allows reaction from static access group DM sender", async () => {
-      const mockRuntime = buildMockRuntime();
-      setMSTeamsRuntime(mockRuntime);
-      const cfg: KlawConfig = {
-        accessGroups: {
-          operators: {
-            type: "message.senders",
-            members: { msteams: ["allowed-aad"] },
-          },
-        },
-        channels: {
-          msteams: {
-            dmPolicy: "allowlist",
-            allowFrom: ["accessGroup:operators"],
-          },
-        },
-      } as KlawConfig;
-      const handler = createMSTeamsReactionHandler(buildDeps(cfg, mockRuntime));
-      const enqueue = mockRuntime.system.enqueueSystemEvent as ReturnType<typeof vi.fn>;
-
-      await invokeReactionEvent(
-        handler,
-        {
-          reactionsAdded: [{ type: "like" }],
-          from: { id: "good-user", aadObjectId: "allowed-aad", name: "Alice" },
-          replyToId: "msg-7",
-        },
-        "added",
-      );
-
-      expect(enqueue).toHaveBeenCalledOnce();
-    });
-  });
-});

package/src/monitor-handler/reaction-handler.ts

@@ -1,122 +0,0 @@
-import { normalizeMSTeamsConversationId } from "../inbound.js";
-import type { MSTeamsMessageHandlerDeps } from "../monitor-handler.types.js";
-import { getMSTeamsRuntime } from "../runtime.js";
-import type { MSTeamsTurnContext } from "../sdk-types.js";
-import { resolveMSTeamsSenderAccess } from "./access.js";
-
-/** Teams reaction type names → Unicode emoji. */
-const TEAMS_REACTION_EMOJI: Record<string, string> = {
-  like: "👍",
-  heart: "❤️",
-  laugh: "😆",
-  surprised: "😮",
-  sad: "😢",
-  angry: "😡",
-};
-
-/**
- * Map a Teams reaction type string to a Unicode emoji.
- * Falls back to the raw type if not recognized.
- */
-function mapReactionEmoji(reactionType: string): string {
-  return TEAMS_REACTION_EMOJI[reactionType] ?? reactionType;
-}
-
-type ReactionDirection = "added" | "removed";
-
-/**
- * Create a handler for MS Teams reaction activities (reactionsAdded / reactionsRemoved).
- * The returned function accepts a turn context and a direction string.
- */
-export function createMSTeamsReactionHandler(deps: MSTeamsMessageHandlerDeps) {
-  const { cfg, log } = deps;
-  const core = getMSTeamsRuntime();
-  const msteamsCfg = cfg.channels?.msteams;
-
-  return async function handleReaction(
-    context: MSTeamsTurnContext,
-    direction: ReactionDirection,
-  ): Promise<void> {
-    const activity = context.activity;
-
-    // Reactions are carried in reactionsAdded / reactionsRemoved on the activity.
-    const reactions: Array<{ type?: string }> =
-      direction === "added"
-        ? ((activity as unknown as { reactionsAdded?: Array<{ type?: string }> }).reactionsAdded ??
-          [])
-        : ((activity as unknown as { reactionsRemoved?: Array<{ type?: string }> })
-            .reactionsRemoved ?? []);
-
-    if (reactions.length === 0) {
-      log.debug?.("reaction activity has no reactions; skipping");
-      return;
-    }
-
-    const from = activity.from;
-    if (!from?.id) {
-      log.debug?.("reaction activity missing from.id; skipping");
-      return;
-    }
-
-    const rawConversationId = activity.conversation?.id ?? "";
-    const conversationId = normalizeMSTeamsConversationId(rawConversationId);
-    const conversationType = activity.conversation?.conversationType ?? "personal";
-    const isGroupChat = conversationType === "groupChat" || activity.conversation?.isGroup === true;
-    const isChannel = conversationType === "channel";
-    const isDirectMessage = !isGroupChat && !isChannel;
-
-    const senderId = from.aadObjectId ?? from.id;
-    const senderName = from.name ?? from.id;
-
-    if (msteamsCfg) {
-      const senderAccess = await resolveMSTeamsSenderAccess({ cfg, activity });
-      if (senderAccess.senderAccess.decision !== "allow") {
-        log.debug?.("dropping reaction (access denied)", {
-          sender: senderId,
-          reason: senderAccess.senderAccess.reasonCode,
-        });
-        return;
-      }
-    }
-
-    // Resolve the agent route for this conversation/sender.
-    // Extract teamId for team-scoped routing bindings (channel/group reactions).
-    const teamId = isDirectMessage
-      ? undefined
-      : (activity as unknown as { channelData?: { team?: { id?: string } } }).channelData?.team?.id;
-    const route = core.channel.routing.resolveAgentRoute({
-      cfg,
-      channel: "msteams",
-      peer: {
-        kind: isDirectMessage ? "direct" : isChannel ? "channel" : "group",
-        id: isDirectMessage ? senderId : conversationId,
-      },
-      ...(teamId ? { teamId } : {}),
-    });
-
-    // The replyToId points to the message that was reacted to.
-    const targetMessageId = (activity as unknown as { replyToId?: string }).replyToId ?? "unknown";
-
-    for (const reaction of reactions) {
-      const reactionType = reaction.type ?? "unknown";
-      const emoji = mapReactionEmoji(reactionType);
-      const label =
-        direction === "added"
-          ? `Teams reaction ${emoji} added by ${senderName} on message ${targetMessageId}`
-          : `Teams reaction ${emoji} removed by ${senderName} from message ${targetMessageId}`;
-
-      log.info(`reaction ${direction}`, {
-        sender: senderId,
-        reactionType,
-        emoji,
-        targetMessageId,
-        conversationId,
-      });
-
-      core.system.enqueueSystemEvent(label, {
-        sessionKey: route.sessionKey,
-        contextKey: `msteams:reaction:${conversationId}:${targetMessageId}:${senderId}:${reactionType}:${direction}`,
-      });
-    }
-  };
-}

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

@@ -1,30 +0,0 @@
-import { resolveThreadSessionKeys } from "klaw/plugin-sdk/routing";
-
-// Strip any trailing `:thread:<id>` segments from a session key. Thread ids are
-// timestamps/uuids and never contain `:`, so the segment boundary is unambiguous;
-// the `+` covers pathological keys with multiple compounded suffixes.
-const TRAILING_THREAD_SUFFIX = /(?::thread:[^:]+)+$/;
-
-export function resolveMSTeamsRouteSessionKey(params: {
-  baseSessionKey: string;
-  isChannel: boolean;
-  conversationMessageId?: string;
-  replyToId?: string;
-}): string {
-  const channelThreadId = params.isChannel
-    ? (params.conversationMessageId ?? params.replyToId ?? undefined)
-    : undefined;
-  // Re-derive from a clean base. If a caller hands us a session key that is
-  // already thread-qualified (e.g. a `route.sessionKey` mutated in place by a
-  // prior turn whose object is still held in the resolved-route cache, see
-  // src/routing/resolve-route.ts cache-miss return), naively appending the
-  // current thread id would compound into `…:thread:OLD:thread:NEW` and route
-  // the turn to a malformed lane that splits same-thread context across turns.
-  // Stripping makes this helper idempotent regardless of caller hygiene. (#66771)
-  const cleanBase = params.baseSessionKey.replace(TRAILING_THREAD_SUFFIX, "");
-  return resolveThreadSessionKeys({
-    baseSessionKey: cleanBase,
-    threadId: channelThreadId,
-    parentSessionKey: channelThreadId ? cleanBase : undefined,
-  }).sessionKey;
-}

package/src/monitor-handler.adaptive-card.test.ts

@@ -1,158 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { KlawConfig, RuntimeEnv } from "../runtime-api.js";
-import type { MSTeamsConversationStore } from "./conversation-store.js";
-import {
-  type MSTeamsActivityHandler,
-  type MSTeamsMessageHandlerDeps,
-  registerMSTeamsHandlers,
-} from "./monitor-handler.js";
-import { installMSTeamsTestRuntime } from "./monitor-handler.test-helpers.js";
-import type { MSTeamsTurnContext } from "./sdk-types.js";
-
-const runtimeApiMockState = vi.hoisted(() => ({
-  dispatchReplyFromConfigWithSettledDispatcher: vi.fn(async (params: { ctxPayload: unknown }) => ({
-    queuedFinal: false,
-    counts: {},
-    capturedCtxPayload: params.ctxPayload,
-  })),
-}));
-
-vi.mock("klaw/plugin-sdk/inbound-reply-dispatch", () => {
-  return {
-    dispatchReplyFromConfigWithSettledDispatcher:
-      runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher,
-  };
-});
-
-vi.mock("./reply-dispatcher.js", () => ({
-  createMSTeamsReplyDispatcher: () => ({
-    dispatcher: {},
-    replyOptions: {},
-    markDispatchIdle: vi.fn(),
-  }),
-}));
-
-function createDeps(): MSTeamsMessageHandlerDeps {
-  installMSTeamsTestRuntime();
-
-  return {
-    cfg: {} as KlawConfig,
-    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: {
-      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 MSTeamsConversationStore,
-    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"],
-  };
-}
-
-function createActivityHandler() {
-  const messageHandlers: Array<(context: unknown, next: () => Promise<void>) => Promise<void>> = [];
-  const run = vi.fn(async (context: unknown) => {
-    const activityType = (context as MSTeamsTurnContext).activity?.type;
-    if (activityType !== "message") {
-      return;
-    }
-    for (const handler of messageHandlers) {
-      await handler(context, async () => {});
-    }
-  });
-
-  let handler: MSTeamsActivityHandler & {
-    run: NonNullable<MSTeamsActivityHandler["run"]>;
-  };
-  handler = {
-    onMessage: (nextHandler) => {
-      messageHandlers.push(nextHandler);
-      return handler;
-    },
-    onMembersAdded: () => handler,
-    onReactionsAdded: () => handler,
-    onReactionsRemoved: () => handler,
-    run,
-  };
-
-  return { handler, run };
-}
-
-describe("msteams adaptive card action invoke", () => {
-  beforeEach(() => {
-    runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher.mockClear();
-  });
-
-  it("forwards adaptive card invoke values to the agent as message text", async () => {
-    const deps = createDeps();
-    const { handler, run } = createActivityHandler();
-    const registered = registerMSTeamsHandlers(handler, deps) as MSTeamsActivityHandler & {
-      run: NonNullable<MSTeamsActivityHandler["run"]>;
-    };
-    const payload = {
-      action: {
-        type: "Action.Submit",
-        data: {
-          intent: "deploy",
-          environment: "prod",
-        },
-      },
-      trigger: "button-click",
-    };
-
-    await registered.run({
-      activity: {
-        id: "invoke-1",
-        type: "invoke",
-        name: "adaptiveCard/action",
-        channelId: "msteams",
-        serviceUrl: "https://service.example.test",
-        from: {
-          id: "user-bf",
-          aadObjectId: "user-aad",
-          name: "User",
-        },
-        recipient: {
-          id: "bot-id",
-          name: "Bot",
-        },
-        conversation: {
-          id: "19:personal-chat;messageid=abc123",
-          conversationType: "personal",
-        },
-        channelData: {},
-        attachments: [],
-        value: payload,
-      },
-      sendActivity: vi.fn(async () => ({ id: "activity-id" })),
-      sendActivities: async () => [],
-    } as unknown as MSTeamsTurnContext);
-
-    expect(run).not.toHaveBeenCalled();
-    expect(runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher).toHaveBeenCalledTimes(
-      1,
-    );
-    const dispatched = runtimeApiMockState.dispatchReplyFromConfigWithSettledDispatcher.mock
-      .calls[0]?.[0] as { ctxPayload?: Record<string, unknown> } | undefined;
-    expect(dispatched?.ctxPayload?.RawBody).toBe(JSON.stringify(payload));
-    expect(dispatched?.ctxPayload?.BodyForAgent).toBe(JSON.stringify(payload));
-    expect(dispatched?.ctxPayload?.CommandBody).toBe(JSON.stringify(payload));
-    expect(dispatched?.ctxPayload?.SessionKey).toBe("msteams:direct:user-aad");
-    expect(dispatched?.ctxPayload?.SenderId).toBe("user-aad");
-  });
-});