@openclaw/msteams 2026.3.12 → 2026.5.1-beta.1

package/src/secret-contract.ts

@@ -0,0 +1,49 @@
+import {
+  collectSecretInputAssignment,
+  getChannelRecord,
+  type ResolverContext,
+  type SecretDefaults,
+} from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+
+export const secretTargetRegistryEntries: import("openclaw/plugin-sdk/channel-secret-basic-runtime").SecretTargetRegistryEntry[] =
+  [
+    {
+      id: "channels.msteams.appPassword",
+      targetType: "channels.msteams.appPassword",
+      configFile: "openclaw.json",
+      pathPattern: "channels.msteams.appPassword",
+      secretShape: "secret_input",
+      expectedResolvedValue: "string",
+      includeInPlan: true,
+      includeInConfigure: true,
+      includeInAudit: true,
+    },
+  ];
+
+export function collectRuntimeConfigAssignments(params: {
+  config: { channels?: Record<string, unknown> };
+  defaults?: SecretDefaults;
+  context: ResolverContext;
+}): void {
+  const msteams = getChannelRecord(params.config, "msteams");
+  if (!msteams) {
+    return;
+  }
+  collectSecretInputAssignment({
+    value: msteams.appPassword,
+    path: "channels.msteams.appPassword",
+    expected: "string",
+    defaults: params.defaults,
+    context: params.context,
+    active: msteams.enabled !== false,
+    inactiveReason: "Microsoft Teams channel is disabled.",
+    apply: (value) => {
+      msteams.appPassword = value;
+    },
+  });
+}
+
+export const channelSecrets = {
+  secretTargetRegistryEntries,
+  collectRuntimeConfigAssignments,
+};

package/src/secret-input.ts

@@ -2,6 +2,6 @@ import {
   hasConfiguredSecretInput,
   normalizeResolvedSecretInputString,
   normalizeSecretInputString,
-} from "openclaw/plugin-sdk/msteams";
+} from "openclaw/plugin-sdk/secret-input";
 
 export { hasConfiguredSecretInput, normalizeResolvedSecretInputString, normalizeSecretInputString };

package/src/send-context.ts

@@ -1,20 +1,23 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
 import {
   resolveChannelMediaMaxBytes,
   type OpenClawConfig,
   type PluginRuntime,
-} from "openclaw/plugin-sdk/msteams";
+} from "../runtime-api.js";
 import type { MSTeamsAccessTokenProvider } from "./attachments/types.js";
 import { createMSTeamsConversationStoreFs } from "./conversation-store-fs.js";
 import type {
   MSTeamsConversationStore,
   StoredConversationReference,
 } from "./conversation-store.js";
+import { formatUnknownError } from "./errors.js";
+import { resolveGraphChatId } from "./graph-upload.js";
 import type { MSTeamsAdapter } from "./messenger.js";
 import { getMSTeamsRuntime } from "./runtime.js";
-import { createMSTeamsAdapter, loadMSTeamsSdkWithAuth } from "./sdk.js";
+import { createMSTeamsAdapter, createMSTeamsTokenProvider, loadMSTeamsSdkWithAuth } from "./sdk.js";
 import { resolveMSTeamsCredentials } from "./token.js";
 
-export type MSTeamsConversationType = "personal" | "groupChat" | "channel";
+type MSTeamsConversationType = "personal" | "groupChat" | "channel";
 
 export type MSTeamsProactiveContext = {
   appId: string;
@@ -30,6 +33,13 @@ export type MSTeamsProactiveContext = {
   sharePointSiteId?: string;
   /** Resolved media max bytes from config (default: 100MB) */
   mediaMaxBytes?: number;
+  /**
+   * Graph API-native chat ID for this conversation.
+   * Bot Framework personal DM IDs (`a:1xxx` / `8:orgid:xxx`) cannot be used directly
+   * with Graph chat endpoints. This field holds the resolved `19:xxx` format ID.
+   * Null if resolution failed or not applicable.
+   */
+  graphChatId?: string | null;
 };
 
 /**
@@ -84,7 +94,7 @@ async function findConversationReference(recipient: {
     return null;
   }
 
-  const found = await recipient.store.findByUserId(recipient.id);
+  const found = await recipient.store.findPreferredDmByUserId(recipient.id);
   if (!found) {
     return null;
   }
@@ -120,17 +130,34 @@ export async function resolveMSTeamsSendContext(params: {
   }
 
   const { conversationId, ref } = found;
+
+  // Safety check: when the caller targeted a specific user (DM), verify the
+  // resolved conversation is actually a personal DM.  Without this guard a
+  // stale or mismatched conversation store could route a private DM reply
+  // into a shared channel or group chat -- see #54520.
+  if (recipient.type === "user") {
+    const resolvedType = normalizeLowercaseStringOrEmpty(ref.conversation?.conversationType ?? "");
+    if (resolvedType && resolvedType !== "personal") {
+      throw new Error(
+        `Conversation reference for user:${recipient.id} resolved to a ${resolvedType} ` +
+          `conversation (${conversationId}) instead of a personal DM. ` +
+          `The bot must receive a DM from this user before it can send proactively.`,
+      );
+    }
+  }
   const core = getMSTeamsRuntime();
   const log = core.logging.getChildLogger({ name: "msteams:send" });
 
-  const { sdk, authConfig } = await loadMSTeamsSdkWithAuth(creds);
-  const adapter = createMSTeamsAdapter(authConfig, sdk);
+  const { sdk, app } = await loadMSTeamsSdkWithAuth(creds);
+  const adapter = createMSTeamsAdapter(app, sdk);
 
-  // Create token provider for Graph API / OneDrive operations
-  const tokenProvider = new sdk.MsalTokenProvider(authConfig) as MSTeamsAccessTokenProvider;
+  // Create token provider adapter for Graph API / OneDrive operations
+  const tokenProvider: MSTeamsAccessTokenProvider = createMSTeamsTokenProvider(app);
 
   // Determine conversation type from stored reference
-  const storedConversationType = ref.conversation?.conversationType?.toLowerCase() ?? "";
+  const storedConversationType = normalizeLowercaseStringOrEmpty(
+    ref.conversation?.conversationType ?? "",
+  );
   let conversationType: MSTeamsConversationType;
   if (storedConversationType === "personal") {
     conversationType = "personal";
@@ -150,6 +177,45 @@ export async function resolveMSTeamsSendContext(params: {
     resolveChannelLimitMb: ({ cfg }) => cfg.channels?.msteams?.mediaMaxMb,
   });
 
+  // Resolve Graph API-native chat ID if needed for SharePoint per-user sharing.
+  // Bot Framework personal DM conversation IDs (e.g. `a:1xxx` or `8:orgid:xxx`) cannot
+  // be used directly with Graph /chats/{chatId} endpoints — the Graph API requires the
+  // `19:xxx@thread.tacv2` or `19:xxx@unq.gbl.spaces` format.
+  // We check the cached value first, then resolve via Graph API and cache for future sends.
+  let graphChatId: string | null | undefined = ref.graphChatId ?? undefined;
+  if (graphChatId === undefined && sharePointSiteId) {
+    // Only resolve when SharePoint is configured (the only place chatId matters currently)
+    try {
+      const resolved = await resolveGraphChatId({
+        botFrameworkConversationId: conversationId,
+        userAadObjectId: ref.user?.aadObjectId,
+        tokenProvider,
+      });
+      graphChatId = resolved;
+
+      // Cache in the conversation store so subsequent sends skip the Graph lookup.
+      // NOTE: We intentionally do NOT cache null results. Transient Graph API failures
+      // (network, 401, rate limit) should be retried on subsequent sends rather than
+      // permanently blocking file uploads for this conversation.
+      if (resolved) {
+        await store.upsert(conversationId, { ...ref, graphChatId: resolved });
+      } else {
+        log.warn?.("could not resolve Graph chat ID; file uploads may fail for this conversation", {
+          conversationId,
+        });
+      }
+    } catch (err) {
+      log.warn?.(
+        "failed to resolve Graph chat ID; file uploads may fall back to Bot Framework ID",
+        {
+          conversationId,
+          error: formatUnknownError(err),
+        },
+      );
+      graphChatId = null;
+    }
+  }
+
   return {
     appId: creds.appId,
     conversationId,
@@ -160,5 +226,6 @@ export async function resolveMSTeamsSendContext(params: {
     tokenProvider,
     sharePointSiteId,
     mediaMaxBytes,
+    graphChatId,
   };
 }

package/src/send.test.ts

@@ -1,20 +1,40 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/msteams";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { sendMessageMSTeams } from "./send.js";
+import type { OpenClawConfig } from "../runtime-api.js";
+import { deleteMessageMSTeams, editMessageMSTeams, sendMessageMSTeams } from "./send.js";
 
 const mockState = vi.hoisted(() => ({
   loadOutboundMediaFromUrl: vi.fn(),
   resolveMSTeamsSendContext: vi.fn(),
+  resolveMarkdownTableMode: vi.fn(() => "off"),
+  convertMarkdownTables: vi.fn((text: string) => text),
+  runtimeResolveMarkdownTableMode: vi.fn(() => "off"),
+  runtimeConvertMarkdownTables: vi.fn((text: string) => text),
   requiresFileConsent: vi.fn(),
   prepareFileConsentActivity: vi.fn(),
+  prepareFileConsentActivityFs: vi.fn(),
   extractFilename: vi.fn(async () => "fallback.bin"),
   sendMSTeamsMessages: vi.fn(),
+  uploadAndShareSharePoint: vi.fn(),
+  getDriveItemProperties: vi.fn(),
+  buildTeamsFileInfoCard: vi.fn(),
 }));
 
-vi.mock("openclaw/plugin-sdk/msteams", () => ({
+vi.mock("openclaw/plugin-sdk/outbound-media", () => ({
   loadOutboundMediaFromUrl: mockState.loadOutboundMediaFromUrl,
 }));
 
+vi.mock("openclaw/plugin-sdk/markdown-table-runtime", () => ({
+  resolveMarkdownTableMode: mockState.resolveMarkdownTableMode,
+}));
+
+vi.mock("openclaw/plugin-sdk/text-runtime", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("openclaw/plugin-sdk/text-runtime")>();
+  return {
+    ...actual,
+    convertMarkdownTables: mockState.convertMarkdownTables,
+  };
+});
+
 vi.mock("./send-context.js", () => ({
   resolveMSTeamsSendContext: mockState.resolveMSTeamsSendContext,
 }));
@@ -22,6 +42,7 @@ vi.mock("./send-context.js", () => ({
 vi.mock("./file-consent-helpers.js", () => ({
   requiresFileConsent: mockState.requiresFileConsent,
   prepareFileConsentActivity: mockState.prepareFileConsentActivity,
+  prepareFileConsentActivityFs: mockState.prepareFileConsentActivityFs,
 }));
 
 vi.mock("./media-helpers.js", () => ({
@@ -38,21 +59,121 @@ vi.mock("./runtime.js", () => ({
   getMSTeamsRuntime: () => ({
     channel: {
       text: {
-        resolveMarkdownTableMode: () => "off",
-        convertMarkdownTables: (text: string) => text,
+        resolveMarkdownTableMode: mockState.runtimeResolveMarkdownTableMode,
+        convertMarkdownTables: mockState.runtimeConvertMarkdownTables,
       },
     },
   }),
 }));
 
+vi.mock("./graph-upload.js", () => ({
+  uploadAndShareSharePoint: mockState.uploadAndShareSharePoint,
+  getDriveItemProperties: mockState.getDriveItemProperties,
+  uploadAndShareOneDrive: vi.fn(),
+}));
+
+vi.mock("./graph-chat.js", () => ({
+  buildTeamsFileInfoCard: mockState.buildTeamsFileInfoCard,
+}));
+
+function mockContinueConversationFailure(error: string) {
+  const mockContinueConversation = vi.fn().mockRejectedValue(new Error(error));
+  mockState.resolveMSTeamsSendContext.mockResolvedValue({
+    adapter: { continueConversation: mockContinueConversation },
+    appId: "app-id",
+    conversationId: "19:conversation@thread.tacv2",
+    ref: {
+      user: { id: "user-1" },
+      agent: { id: "agent-1" },
+      conversation: { id: "19:conversation@thread.tacv2" },
+      channelId: "msteams",
+    },
+    log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    conversationType: "personal",
+    tokenProvider: {},
+  });
+  return mockContinueConversation;
+}
+
+function createSharePointSendContext(params: {
+  conversationId: string;
+  graphChatId: string | null;
+  siteId: string;
+}) {
+  return {
+    adapter: {
+      continueConversation: vi.fn(
+        async (
+          _id: string,
+          _ref: unknown,
+          fn: (ctx: { sendActivity: () => { id: "msg-1" } }) => Promise<void>,
+        ) => fn({ sendActivity: () => ({ id: "msg-1" }) }),
+      ),
+    },
+    appId: "app-id",
+    conversationId: params.conversationId,
+    graphChatId: params.graphChatId,
+    ref: {},
+    log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    conversationType: "groupChat" as const,
+    tokenProvider: { getAccessToken: vi.fn(async () => "token") },
+    mediaMaxBytes: 8 * 1024 * 1024,
+    sharePointSiteId: params.siteId,
+  };
+}
+
+function mockSharePointPdfUpload(params: {
+  bufferSize: number;
+  fileName: string;
+  itemId: string;
+  uniqueId: string;
+}) {
+  mockState.loadOutboundMediaFromUrl.mockResolvedValueOnce({
+    buffer: Buffer.alloc(params.bufferSize, "pdf"),
+    contentType: "application/pdf",
+    fileName: params.fileName,
+    kind: "file",
+  });
+  mockState.requiresFileConsent.mockReturnValue(false);
+  mockState.uploadAndShareSharePoint.mockResolvedValue({
+    itemId: params.itemId,
+    webUrl: `https://sp.example.com/${params.fileName}`,
+    shareUrl: `https://sp.example.com/share/${params.fileName}`,
+    name: params.fileName,
+  });
+  mockState.getDriveItemProperties.mockResolvedValue({
+    eTag: `"${params.uniqueId},1"`,
+    webDavUrl: `https://sp.example.com/dav/${params.fileName}`,
+    name: params.fileName,
+  });
+  mockState.buildTeamsFileInfoCard.mockReturnValue({
+    contentType: "application/vnd.microsoft.teams.card.file.info",
+    contentUrl: `https://sp.example.com/dav/${params.fileName}`,
+    name: params.fileName,
+    content: { uniqueId: params.uniqueId, fileType: "pdf" },
+  });
+}
+
 describe("sendMessageMSTeams", () => {
   beforeEach(() => {
     mockState.loadOutboundMediaFromUrl.mockReset();
     mockState.resolveMSTeamsSendContext.mockReset();
+    mockState.resolveMarkdownTableMode.mockReset();
+    mockState.resolveMarkdownTableMode.mockReturnValue("off");
+    mockState.convertMarkdownTables.mockReset();
+    mockState.convertMarkdownTables.mockImplementation((text: string) => text);
+    mockState.runtimeResolveMarkdownTableMode.mockReset();
+    mockState.runtimeResolveMarkdownTableMode.mockReturnValue("off");
+    mockState.runtimeConvertMarkdownTables.mockReset();
+    mockState.runtimeConvertMarkdownTables.mockImplementation((text: string) => text);
     mockState.requiresFileConsent.mockReset();
     mockState.prepareFileConsentActivity.mockReset();
+    mockState.prepareFileConsentActivityFs.mockReset();
     mockState.extractFilename.mockReset();
     mockState.sendMSTeamsMessages.mockReset();
+    mockState.uploadAndShareSharePoint.mockReset();
+    mockState.getDriveItemProperties.mockReset();
+    mockState.buildTeamsFileInfoCard.mockReset();
 
     mockState.extractFilename.mockResolvedValue("fallback.bin");
     mockState.requiresFileConsent.mockReturnValue(false);
@@ -106,4 +227,267 @@ describe("sendMessageMSTeams", () => {
       }),
     );
   });
+
+  it("sends with provided cfg even when Teams runtime text helpers are unavailable", async () => {
+    mockState.runtimeResolveMarkdownTableMode.mockImplementation(() => {
+      throw new Error("MSTeams runtime not initialized");
+    });
+    mockState.runtimeConvertMarkdownTables.mockImplementation(() => {
+      throw new Error("MSTeams runtime not initialized");
+    });
+    mockState.resolveMarkdownTableMode.mockReturnValue("off");
+    mockState.convertMarkdownTables.mockReturnValue("hello");
+
+    await expect(
+      sendMessageMSTeams({
+        cfg: {} as OpenClawConfig,
+        to: "conversation:19:conversation@thread.tacv2",
+        text: "hello",
+      }),
+    ).resolves.toEqual({
+      messageId: "message-1",
+      conversationId: "19:conversation@thread.tacv2",
+    });
+
+    expect(mockState.resolveMarkdownTableMode).toHaveBeenCalledWith({
+      cfg: {},
+      channel: "msteams",
+    });
+    expect(mockState.convertMarkdownTables).toHaveBeenCalledWith("hello", "off");
+  });
+
+  it("uses graphChatId instead of conversationId when uploading to SharePoint", async () => {
+    // Simulates a group chat where Bot Framework conversationId is valid but we have
+    // a resolved Graph chat ID cached from a prior send.
+    const graphChatId = "19:graph-native-chat-id@thread.tacv2";
+    const botFrameworkConversationId = "19:bot-framework-id@thread.tacv2";
+
+    mockState.resolveMSTeamsSendContext.mockResolvedValue(
+      createSharePointSendContext({
+        conversationId: botFrameworkConversationId,
+        graphChatId,
+        siteId: "site-123",
+      }),
+    );
+    mockSharePointPdfUpload({
+      bufferSize: 100,
+      fileName: "doc.pdf",
+      itemId: "item-1",
+      uniqueId: "{GUID-123}",
+    });
+
+    await sendMessageMSTeams({
+      cfg: {} as OpenClawConfig,
+      to: "conversation:19:bot-framework-id@thread.tacv2",
+      text: "here is a file",
+      mediaUrl: "https://example.com/doc.pdf",
+    });
+
+    // The Graph-native chatId must be passed to SharePoint upload, not the Bot Framework ID
+    expect(mockState.uploadAndShareSharePoint).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: graphChatId,
+        siteId: "site-123",
+      }),
+    );
+  });
+
+  it("falls back to conversationId when graphChatId is not available", async () => {
+    const botFrameworkConversationId = "19:fallback-id@thread.tacv2";
+
+    mockState.resolveMSTeamsSendContext.mockResolvedValue(
+      createSharePointSendContext({
+        conversationId: botFrameworkConversationId,
+        graphChatId: null,
+        siteId: "site-456",
+      }),
+    );
+    mockSharePointPdfUpload({
+      bufferSize: 50,
+      fileName: "report.pdf",
+      itemId: "item-2",
+      uniqueId: "{GUID-456}",
+    });
+
+    await sendMessageMSTeams({
+      cfg: {} as OpenClawConfig,
+      to: "conversation:19:fallback-id@thread.tacv2",
+      text: "report",
+      mediaUrl: "https://example.com/report.pdf",
+    });
+
+    // Falls back to conversationId when graphChatId is null
+    expect(mockState.uploadAndShareSharePoint).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: botFrameworkConversationId,
+        siteId: "site-456",
+      }),
+    );
+  });
+});
+
+describe("editMessageMSTeams", () => {
+  beforeEach(() => {
+    mockState.resolveMSTeamsSendContext.mockReset();
+  });
+
+  it("calls continueConversation and updateActivity with correct params", async () => {
+    const mockUpdateActivity = vi.fn();
+    const mockContinueConversation = vi.fn(
+      async (_appId: string, _ref: unknown, logic: (ctx: unknown) => Promise<void>) => {
+        await logic({
+          sendActivity: vi.fn(),
+          updateActivity: mockUpdateActivity,
+          deleteActivity: vi.fn(),
+        });
+      },
+    );
+    mockState.resolveMSTeamsSendContext.mockResolvedValue({
+      adapter: { continueConversation: mockContinueConversation },
+      appId: "app-id",
+      conversationId: "19:conversation@thread.tacv2",
+      ref: {
+        user: { id: "user-1" },
+        agent: { id: "agent-1" },
+        conversation: { id: "19:conversation@thread.tacv2", conversationType: "personal" },
+        channelId: "msteams",
+      },
+      log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      conversationType: "personal",
+      tokenProvider: {},
+    });
+
+    const result = await editMessageMSTeams({
+      cfg: {} as OpenClawConfig,
+      to: "conversation:19:conversation@thread.tacv2",
+      activityId: "activity-123",
+      text: "Updated message text",
+    });
+
+    expect(result.conversationId).toBe("19:conversation@thread.tacv2");
+    expect(mockContinueConversation).toHaveBeenCalledTimes(1);
+    expect(mockContinueConversation).toHaveBeenCalledWith(
+      "app-id",
+      expect.objectContaining({ activityId: undefined }),
+      expect.any(Function),
+    );
+    expect(mockUpdateActivity).toHaveBeenCalledWith({
+      type: "message",
+      id: "activity-123",
+      text: "Updated message text",
+    });
+  });
+
+  it("throws a descriptive error when continueConversation fails", async () => {
+    mockContinueConversationFailure("Service unavailable");
+
+    await expect(
+      editMessageMSTeams({
+        cfg: {} as OpenClawConfig,
+        to: "conversation:19:conversation@thread.tacv2",
+        activityId: "activity-123",
+        text: "Updated text",
+      }),
+    ).rejects.toThrow("msteams edit failed");
+  });
+});
+
+describe("deleteMessageMSTeams", () => {
+  beforeEach(() => {
+    mockState.resolveMSTeamsSendContext.mockReset();
+  });
+
+  it("calls continueConversation and deleteActivity with correct activityId", async () => {
+    const mockDeleteActivity = vi.fn();
+    const mockContinueConversation = vi.fn(
+      async (_appId: string, _ref: unknown, logic: (ctx: unknown) => Promise<void>) => {
+        await logic({
+          sendActivity: vi.fn(),
+          updateActivity: vi.fn(),
+          deleteActivity: mockDeleteActivity,
+        });
+      },
+    );
+    mockState.resolveMSTeamsSendContext.mockResolvedValue({
+      adapter: { continueConversation: mockContinueConversation },
+      appId: "app-id",
+      conversationId: "19:conversation@thread.tacv2",
+      ref: {
+        user: { id: "user-1" },
+        agent: { id: "agent-1" },
+        conversation: { id: "19:conversation@thread.tacv2", conversationType: "groupChat" },
+        channelId: "msteams",
+      },
+      log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      conversationType: "groupChat",
+      tokenProvider: {},
+    });
+
+    const result = await deleteMessageMSTeams({
+      cfg: {} as OpenClawConfig,
+      to: "conversation:19:conversation@thread.tacv2",
+      activityId: "activity-456",
+    });
+
+    expect(result.conversationId).toBe("19:conversation@thread.tacv2");
+    expect(mockContinueConversation).toHaveBeenCalledTimes(1);
+    expect(mockContinueConversation).toHaveBeenCalledWith(
+      "app-id",
+      expect.objectContaining({ activityId: undefined }),
+      expect.any(Function),
+    );
+    expect(mockDeleteActivity).toHaveBeenCalledWith("activity-456");
+  });
+
+  it("throws a descriptive error when continueConversation fails", async () => {
+    mockContinueConversationFailure("Not found");
+
+    await expect(
+      deleteMessageMSTeams({
+        cfg: {} as OpenClawConfig,
+        to: "conversation:19:conversation@thread.tacv2",
+        activityId: "activity-456",
+      }),
+    ).rejects.toThrow("msteams delete failed");
+  });
+
+  it("passes the appId and proactive ref to continueConversation", async () => {
+    const mockContinueConversation = vi.fn(
+      async (_appId: string, _ref: unknown, logic: (ctx: unknown) => Promise<void>) => {
+        await logic({
+          sendActivity: vi.fn(),
+          updateActivity: vi.fn(),
+          deleteActivity: vi.fn(),
+        });
+      },
+    );
+    mockState.resolveMSTeamsSendContext.mockResolvedValue({
+      adapter: { continueConversation: mockContinueConversation },
+      appId: "my-app-id",
+      conversationId: "19:conv@thread.tacv2",
+      ref: {
+        activityId: "original-activity",
+        user: { id: "user-1" },
+        agent: { id: "agent-1" },
+        conversation: { id: "19:conv@thread.tacv2" },
+        channelId: "msteams",
+      },
+      log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      conversationType: "personal",
+      tokenProvider: {},
+    });
+
+    await deleteMessageMSTeams({
+      cfg: {} as OpenClawConfig,
+      to: "conversation:19:conv@thread.tacv2",
+      activityId: "activity-789",
+    });
+
+    // appId should be forwarded correctly
+    expect(mockContinueConversation.mock.calls[0]?.[0]).toBe("my-app-id");
+    // activityId on the proactive ref should be cleared (undefined) — proactive pattern
+    expect(mockContinueConversation.mock.calls[0]?.[1]).toMatchObject({
+      activityId: undefined,
+    });
+  });
 });