@openclaw/msteams 2026.3.13 → 2026.5.2-beta.1

package/src/send.ts

@@ -1,12 +1,12 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/msteams";
-import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/msteams";
-import { createMSTeamsConversationStoreFs } from "./conversation-store-fs.js";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { convertMarkdownTables } from "openclaw/plugin-sdk/text-runtime";
+import { loadOutboundMediaFromUrl, type OpenClawConfig } from "../runtime-api.js";
 import {
   classifyMSTeamsSendError,
   formatMSTeamsSendErrorHint,
   formatUnknownError,
 } from "./errors.js";
-import { prepareFileConsentActivity, requiresFileConsent } from "./file-consent-helpers.js";
+import { prepareFileConsentActivityFs, requiresFileConsent } from "./file-consent-helpers.js";
 import { buildTeamsFileInfoCard } from "./graph-chat.js";
 import {
   getDriveItemProperties,
@@ -15,11 +15,12 @@ import {
 } from "./graph-upload.js";
 import { extractFilename, extractMessageId } from "./media-helpers.js";
 import { buildConversationReference, sendMSTeamsMessages } from "./messenger.js";
+import { setPendingUploadActivityIdFs } from "./pending-uploads-fs.js";
+import { setPendingUploadActivityId } from "./pending-uploads.js";
 import { buildMSTeamsPollCard } from "./polls.js";
-import { getMSTeamsRuntime } from "./runtime.js";
 import { resolveMSTeamsSendContext, type MSTeamsProactiveContext } from "./send-context.js";
 
-export type SendMSTeamsMessageParams = {
+type SendMSTeamsMessageParams = {
   /** Full config (for credentials) */
   cfg: OpenClawConfig;
   /** Conversation ID or user ID to send to */
@@ -28,10 +29,13 @@ export type SendMSTeamsMessageParams = {
   text: string;
   /** Optional media URL */
   mediaUrl?: string;
+  /** Optional filename override for uploaded media/files */
+  filename?: string;
   mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
 };
 
-export type SendMSTeamsMessageResult = {
+type SendMSTeamsMessageResult = {
   messageId: string;
   conversationId: string;
   /** If a FileConsentCard was sent instead of the file, this contains the upload ID */
@@ -47,7 +51,7 @@ const FILE_CONSENT_THRESHOLD_BYTES = 4 * 1024 * 1024; // 4MB
  */
 const MSTEAMS_MAX_MEDIA_BYTES = 100 * 1024 * 1024;
 
-export type SendMSTeamsPollParams = {
+type SendMSTeamsPollParams = {
   /** Full config (for credentials) */
   cfg: OpenClawConfig;
   /** Conversation ID or user ID to send to */
@@ -60,13 +64,13 @@ export type SendMSTeamsPollParams = {
   maxSelections?: number;
 };
 
-export type SendMSTeamsPollResult = {
+type SendMSTeamsPollResult = {
   pollId: string;
   messageId: string;
   conversationId: string;
 };
 
-export type SendMSTeamsCardParams = {
+type SendMSTeamsCardParams = {
   /** Full config (for credentials) */
   cfg: OpenClawConfig;
   /** Conversation ID or user ID to send to */
@@ -75,7 +79,7 @@ export type SendMSTeamsCardParams = {
   card: Record<string, unknown>;
 };
 
-export type SendMSTeamsCardResult = {
+type SendMSTeamsCardResult = {
   messageId: string;
   conversationId: string;
 };
@@ -94,12 +98,12 @@ export type SendMSTeamsCardResult = {
 export async function sendMessageMSTeams(
   params: SendMSTeamsMessageParams,
 ): Promise<SendMSTeamsMessageResult> {
-  const { cfg, to, text, mediaUrl, mediaLocalRoots } = params;
-  const tableMode = getMSTeamsRuntime().channel.text.resolveMarkdownTableMode({
+  const { cfg, to, text, mediaUrl, filename, mediaLocalRoots, mediaReadFile } = params;
+  const tableMode = resolveMarkdownTableMode({
     cfg,
     channel: "msteams",
   });
-  const messageText = getMSTeamsRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
+  const messageText = convertMarkdownTables(text ?? "", tableMode);
   const ctx = await resolveMSTeamsSendContext({ cfg, to });
   const {
     adapter,
@@ -125,11 +129,12 @@ export async function sendMessageMSTeams(
     const media = await loadOutboundMediaFromUrl(mediaUrl, {
       maxBytes: mediaMaxBytes,
       mediaLocalRoots,
+      mediaReadFile,
     });
     const isLargeFile = media.buffer.length >= FILE_CONSENT_THRESHOLD_BYTES;
     const isImage = media.contentType?.startsWith("image/") ?? false;
     const fallbackFileName = await extractFilename(mediaUrl);
-    const fileName = media.fileName ?? fallbackFileName;
+    const fileName = filename?.trim() || media.fileName || fallbackFileName;
 
     log.debug?.("processing media", {
       fileName,
@@ -149,7 +154,11 @@ export async function sendMessageMSTeams(
         thresholdBytes: FILE_CONSENT_THRESHOLD_BYTES,
       })
     ) {
-      const { activity, uploadId } = prepareFileConsentActivity({
+      // Proactive CLI sends run in a different process from the gateway's
+      // monitor that receives the fileConsent/invoke callback. Use the FS-
+      // backed helper so the invoke handler can find the pending upload when
+      // the user clicks "Allow".
+      const { activity, uploadId } = await prepareFileConsentActivityFs({
         media: { buffer: media.buffer, filename: fileName, contentType: media.contentType },
         conversationId,
         description: messageText || undefined,
@@ -165,6 +174,12 @@ export async function sendMessageMSTeams(
         errorPrefix: "msteams consent card send",
       });
 
+      // Store the activity ID so the accept handler can replace the consent
+      // card in-place. Mirror it into the FS store too because the invoke
+      // callback may be delivered to a different process than the CLI send.
+      setPendingUploadActivityId(uploadId, messageId);
+      await setPendingUploadActivityIdFs(uploadId, messageId);
+
       log.info("sent file consent card", { conversationId, messageId, uploadId });
 
       return {
@@ -206,7 +221,9 @@ export async function sendMessageMSTeams(
           contentType: media.contentType,
           tokenProvider,
           siteId: sharePointSiteId,
-          chatId: conversationId,
+          // Use the Graph-native chat ID (19:xxx format) — the Bot Framework conversationId
+          // for personal DMs uses a different format that Graph API rejects.
+          chatId: ctx.graphChatId ?? conversationId,
           usePerUserSharing: conversationType === "groupChat",
         });
 
@@ -509,21 +526,112 @@ export async function sendAdaptiveCardMSTeams(
   };
 }
 
+type EditMSTeamsMessageParams = {
+  /** Full config (for credentials) */
+  cfg: OpenClawConfig;
+  /** Conversation ID or user ID */
+  to: string;
+  /** Activity ID of the message to edit */
+  activityId: string;
+  /** New message text */
+  text: string;
+};
+
+type EditMSTeamsMessageResult = {
+  conversationId: string;
+};
+
+type DeleteMSTeamsMessageParams = {
+  /** Full config (for credentials) */
+  cfg: OpenClawConfig;
+  /** Conversation ID or user ID */
+  to: string;
+  /** Activity ID of the message to delete */
+  activityId: string;
+};
+
+type DeleteMSTeamsMessageResult = {
+  conversationId: string;
+};
+
 /**
- * List all known conversation references (for debugging/CLI).
+ * Edit (update) a previously sent message in a Teams conversation.
+ *
+ * Uses the Bot Framework `continueConversation` → `updateActivity` flow
+ * for proactive edits outside of the original turn context.
  */
-export async function listMSTeamsConversations(): Promise<
-  Array<{
-    conversationId: string;
-    userName?: string;
-    conversationType?: string;
-  }>
-> {
-  const store = createMSTeamsConversationStoreFs();
-  const all = await store.list();
-  return all.map(({ conversationId, reference }) => ({
-    conversationId,
-    userName: reference.user?.name,
-    conversationType: reference.conversation?.conversationType,
-  }));
+export async function editMessageMSTeams(
+  params: EditMSTeamsMessageParams,
+): Promise<EditMSTeamsMessageResult> {
+  const { cfg, to, activityId, text } = params;
+  const { adapter, appId, conversationId, ref, log } = await resolveMSTeamsSendContext({
+    cfg,
+    to,
+  });
+
+  log.debug?.("editing proactive message", { conversationId, activityId, textLength: text.length });
+
+  const baseRef = buildConversationReference(ref);
+  const proactiveRef = { ...baseRef, activityId: undefined };
+
+  try {
+    await adapter.continueConversation(appId, proactiveRef, async (ctx) => {
+      await ctx.updateActivity({
+        type: "message",
+        id: activityId,
+        text,
+      });
+    });
+  } catch (err) {
+    const classification = classifyMSTeamsSendError(err);
+    const hint = formatMSTeamsSendErrorHint(classification);
+    const status = classification.statusCode ? ` (HTTP ${classification.statusCode})` : "";
+    throw new Error(
+      `msteams edit failed${status}: ${formatUnknownError(err)}${hint ? ` (${hint})` : ""}`,
+      { cause: err },
+    );
+  }
+
+  log.info("edited proactive message", { conversationId, activityId });
+
+  return { conversationId };
+}
+
+/**
+ * Delete a previously sent message in a Teams conversation.
+ *
+ * Uses the Bot Framework `continueConversation` → `deleteActivity` flow
+ * for proactive deletes outside of the original turn context.
+ */
+export async function deleteMessageMSTeams(
+  params: DeleteMSTeamsMessageParams,
+): Promise<DeleteMSTeamsMessageResult> {
+  const { cfg, to, activityId } = params;
+  const { adapter, appId, conversationId, ref, log } = await resolveMSTeamsSendContext({
+    cfg,
+    to,
+  });
+
+  log.debug?.("deleting proactive message", { conversationId, activityId });
+
+  const baseRef = buildConversationReference(ref);
+  const proactiveRef = { ...baseRef, activityId: undefined };
+
+  try {
+    await adapter.continueConversation(appId, proactiveRef, async (ctx) => {
+      await ctx.deleteActivity(activityId);
+    });
+  } catch (err) {
+    const classification = classifyMSTeamsSendError(err);
+    const hint = formatMSTeamsSendErrorHint(classification);
+    const status = classification.statusCode ? ` (HTTP ${classification.statusCode})` : "";
+    throw new Error(
+      `msteams delete failed${status}: ${formatUnknownError(err)}${hint ? ` (${hint})` : ""}`,
+      { cause: err },
+    );
+  }
+
+  log.info("deleted proactive message", { conversationId, activityId });
+
+  return { conversationId };
 }

package/src/sent-message-cache.ts

@@ -1,44 +1,56 @@
 const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MSTEAMS_SENT_MESSAGES_KEY = Symbol.for("openclaw.msteamsSentMessages");
 
-type CacheEntry = {
-  timestamps: Map<string, number>;
-};
+let sentMessageCache: Map<string, Map<string, number>> | undefined;
 
-const sentMessages = new Map<string, CacheEntry>();
+function getSentMessageCache(): Map<string, Map<string, number>> {
+  if (!sentMessageCache) {
+    const globalStore = globalThis as Record<PropertyKey, unknown>;
+    sentMessageCache =
+      (globalStore[MSTEAMS_SENT_MESSAGES_KEY] as Map<string, Map<string, number>> | undefined) ??
+      new Map<string, Map<string, number>>();
+    globalStore[MSTEAMS_SENT_MESSAGES_KEY] = sentMessageCache;
+  }
+  return sentMessageCache;
+}
 
-function cleanupExpired(entry: CacheEntry): void {
-  const now = Date.now();
-  for (const [msgId, timestamp] of entry.timestamps) {
+function cleanupExpired(scopeKey: string, entry: Map<string, number>, now: number): void {
+  for (const [id, timestamp] of entry) {
     if (now - timestamp > TTL_MS) {
-      entry.timestamps.delete(msgId);
+      entry.delete(id);
     }
   }
+  if (entry.size === 0) {
+    getSentMessageCache().delete(scopeKey);
+  }
 }
 
 export function recordMSTeamsSentMessage(conversationId: string, messageId: string): void {
   if (!conversationId || !messageId) {
     return;
   }
-  let entry = sentMessages.get(conversationId);
+  const now = Date.now();
+  const store = getSentMessageCache();
+  let entry = store.get(conversationId);
   if (!entry) {
-    entry = { timestamps: new Map() };
-    sentMessages.set(conversationId, entry);
+    entry = new Map<string, number>();
+    store.set(conversationId, entry);
   }
-  entry.timestamps.set(messageId, Date.now());
-  if (entry.timestamps.size > 200) {
-    cleanupExpired(entry);
+  entry.set(messageId, now);
+  if (entry.size > 200) {
+    cleanupExpired(conversationId, entry, now);
   }
 }
 
 export function wasMSTeamsMessageSent(conversationId: string, messageId: string): boolean {
-  const entry = sentMessages.get(conversationId);
+  const entry = getSentMessageCache().get(conversationId);
   if (!entry) {
     return false;
   }
-  cleanupExpired(entry);
-  return entry.timestamps.has(messageId);
+  cleanupExpired(conversationId, entry, Date.now());
+  return entry.has(messageId);
 }
 
 export function clearMSTeamsSentMessageCache(): void {
-  sentMessages.clear();
+  getSentMessageCache().clear();
 }

package/src/session-route.ts

@@ -0,0 +1,40 @@
+import {
+  buildChannelOutboundSessionRoute,
+  stripChannelTargetPrefix,
+  stripTargetKindPrefix,
+  type ChannelOutboundSessionRouteParams,
+} from "openclaw/plugin-sdk/channel-core";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+
+export function resolveMSTeamsOutboundSessionRoute(params: ChannelOutboundSessionRouteParams) {
+  let trimmed = stripChannelTargetPrefix(params.target, "msteams", "teams");
+  if (!trimmed) {
+    return null;
+  }
+
+  const lower = normalizeLowercaseStringOrEmpty(trimmed);
+  const isUser = lower.startsWith("user:");
+  const rawId = stripTargetKindPrefix(trimmed);
+  if (!rawId) {
+    return null;
+  }
+  const conversationId = rawId.split(";")[0] ?? rawId;
+  const isChannel = !isUser && /@thread\.tacv2/i.test(conversationId);
+  return buildChannelOutboundSessionRoute({
+    cfg: params.cfg,
+    agentId: params.agentId,
+    channel: "msteams",
+    accountId: params.accountId,
+    peer: {
+      kind: isUser ? "direct" : isChannel ? "channel" : "group",
+      id: conversationId,
+    },
+    chatType: isUser ? "direct" : isChannel ? "channel" : "group",
+    from: isUser
+      ? `msteams:${conversationId}`
+      : isChannel
+        ? `msteams:channel:${conversationId}`
+        : `msteams:group:${conversationId}`,
+    to: isUser ? `user:${conversationId}` : `conversation:${conversationId}`,
+  });
+}

package/src/setup-core.ts

@@ -0,0 +1,160 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import {
+  createStandardChannelSetupStatus,
+  DEFAULT_ACCOUNT_ID,
+  type ChannelSetupAdapter,
+  type ChannelSetupWizard,
+  type WizardPrompter,
+} from "openclaw/plugin-sdk/setup";
+import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { normalizeSecretInputString } from "./secret-input.js";
+import { hasConfiguredMSTeamsCredentials, resolveMSTeamsCredentials } from "./token.js";
+
+export const msteamsSetupAdapter: ChannelSetupAdapter = {
+  resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+  applyAccountConfig: ({ cfg }) => ({
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      msteams: {
+        ...cfg.channels?.msteams,
+        enabled: true,
+      },
+    },
+  }),
+};
+
+const channel = "msteams" as const;
+
+async function promptMSTeamsCredentials(prompter: WizardPrompter): Promise<{
+  appId: string;
+  appPassword: string;
+  tenantId: string;
+}> {
+  const appId = (
+    await prompter.text({
+      message: "Enter MS Teams App ID",
+      validate: (value) => (value?.trim() ? undefined : "Required"),
+    })
+  ).trim();
+  const appPassword = (
+    await prompter.text({
+      message: "Enter MS Teams App Password",
+      validate: (value) => (value?.trim() ? undefined : "Required"),
+    })
+  ).trim();
+  const tenantId = (
+    await prompter.text({
+      message: "Enter MS Teams Tenant ID",
+      validate: (value) => (value?.trim() ? undefined : "Required"),
+    })
+  ).trim();
+  return { appId, appPassword, tenantId };
+}
+
+async function noteMSTeamsCredentialHelp(prompter: WizardPrompter): Promise<void> {
+  await prompter.note(
+    [
+      "1) Azure Bot registration -> get App ID + Tenant ID",
+      "2) Add a client secret (App Password)",
+      "3) Set webhook URL + messaging endpoint",
+      "Tip: you can also set MSTEAMS_APP_ID / MSTEAMS_APP_PASSWORD / MSTEAMS_TENANT_ID.",
+      `Docs: ${formatDocsLink("/channels/msteams", "msteams")}`,
+    ].join("\n"),
+    "MS Teams credentials",
+  );
+}
+
+export function createMSTeamsSetupWizardBase(): Pick<
+  ChannelSetupWizard,
+  | "channel"
+  | "resolveAccountIdForConfigure"
+  | "resolveShouldPromptAccountIds"
+  | "status"
+  | "credentials"
+  | "finalize"
+> {
+  return {
+    channel,
+    resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
+    resolveShouldPromptAccountIds: () => false,
+    status: createStandardChannelSetupStatus({
+      channelLabel: "MS Teams",
+      configuredLabel: "configured",
+      unconfiguredLabel: "needs app credentials",
+      configuredHint: "configured",
+      unconfiguredHint: "needs app creds",
+      configuredScore: 2,
+      unconfiguredScore: 0,
+      includeStatusLine: true,
+      resolveConfigured: ({ cfg }) =>
+        Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)) ||
+        hasConfiguredMSTeamsCredentials(cfg.channels?.msteams),
+    }),
+    credentials: [],
+    finalize: async ({ cfg, prompter }) => {
+      const resolved = resolveMSTeamsCredentials(cfg.channels?.msteams);
+      const hasConfigCreds = hasConfiguredMSTeamsCredentials(cfg.channels?.msteams);
+      const canUseEnv = Boolean(
+        !hasConfigCreds &&
+        normalizeSecretInputString(process.env.MSTEAMS_APP_ID) &&
+        normalizeSecretInputString(process.env.MSTEAMS_APP_PASSWORD) &&
+        normalizeSecretInputString(process.env.MSTEAMS_TENANT_ID),
+      );
+
+      let next: OpenClawConfig = cfg;
+      let appId: string | null = null;
+      let appPassword: string | null = null;
+      let tenantId: string | null = null;
+
+      if (!resolved && !hasConfigCreds) {
+        await noteMSTeamsCredentialHelp(prompter);
+      }
+
+      if (canUseEnv) {
+        const keepEnv = await prompter.confirm({
+          message:
+            "MSTEAMS_APP_ID + MSTEAMS_APP_PASSWORD + MSTEAMS_TENANT_ID detected. Use env vars?",
+          initialValue: true,
+        });
+        if (keepEnv) {
+          next = msteamsSetupAdapter.applyAccountConfig({
+            cfg: next,
+            accountId: DEFAULT_ACCOUNT_ID,
+            input: {},
+          });
+        } else {
+          ({ appId, appPassword, tenantId } = await promptMSTeamsCredentials(prompter));
+        }
+      } else if (hasConfigCreds) {
+        const keep = await prompter.confirm({
+          message: "MS Teams credentials already configured. Keep them?",
+          initialValue: true,
+        });
+        if (!keep) {
+          ({ appId, appPassword, tenantId } = await promptMSTeamsCredentials(prompter));
+        }
+      } else {
+        ({ appId, appPassword, tenantId } = await promptMSTeamsCredentials(prompter));
+      }
+
+      if (appId && appPassword && tenantId) {
+        next = {
+          ...next,
+          channels: {
+            ...next.channels,
+            msteams: {
+              ...next.channels?.msteams,
+              enabled: true,
+              appId,
+              appPassword,
+              tenantId,
+            },
+          },
+        };
+      }
+
+      return { cfg: next, accountId: DEFAULT_ACCOUNT_ID };
+    },
+  };
+}