@openclaw/msteams 2026.5.2 → 2026.5.3-beta.1

package/src/reply-dispatcher.ts

@@ -1,346 +0,0 @@
-import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/text-runtime";
-import {
-  createChannelReplyPipeline,
-  logTypingFailure,
-  resolveChannelMediaMaxBytes,
-  type OpenClawConfig,
-  type MSTeamsReplyStyle,
-  type RuntimeEnv,
-} from "../runtime-api.js";
-import type { MSTeamsAccessTokenProvider } from "./attachments/types.js";
-import type { StoredConversationReference } from "./conversation-store.js";
-import {
-  classifyMSTeamsSendError,
-  formatMSTeamsSendErrorHint,
-  formatUnknownError,
-} from "./errors.js";
-import {
-  buildConversationReference,
-  type MSTeamsAdapter,
-  type MSTeamsRenderedMessage,
-  renderReplyPayloadsToMessages,
-  sendMSTeamsMessages,
-} from "./messenger.js";
-import type { MSTeamsMonitorLogger } from "./monitor-types.js";
-import { createTeamsReplyStreamController } from "./reply-stream-controller.js";
-import { withRevokedProxyFallback } from "./revoked-context.js";
-import { getMSTeamsRuntime } from "./runtime.js";
-import type { MSTeamsTurnContext } from "./sdk-types.js";
-
-export { pickInformativeStatusText } from "./reply-stream-controller.js";
-
-export function createMSTeamsReplyDispatcher(params: {
-  cfg: OpenClawConfig;
-  agentId: string;
-  sessionKey: string;
-  accountId?: string;
-  runtime: RuntimeEnv;
-  log: MSTeamsMonitorLogger;
-  adapter: MSTeamsAdapter;
-  appId: string;
-  conversationRef: StoredConversationReference;
-  context: MSTeamsTurnContext;
-  replyStyle: MSTeamsReplyStyle;
-  textLimit: number;
-  onSentMessageIds?: (ids: string[]) => void;
-  tokenProvider?: MSTeamsAccessTokenProvider;
-  sharePointSiteId?: string;
-}) {
-  const core = getMSTeamsRuntime();
-  const msteamsCfg = params.cfg.channels?.msteams;
-  const conversationType = normalizeOptionalLowercaseString(
-    params.conversationRef.conversation?.conversationType,
-  );
-  const isTypingSupported = conversationType === "personal" || conversationType === "groupchat";
-
-  /**
-   * Keepalive cadence for the typing indicator while the bot is running
-   * (including long tool chains). Bot Framework 1:1 TurnContext proxies
-   * expire after ~30s of inactivity; sending a typing activity every 8s
-   * keeps the proxy alive so the post-tool reply can still land via the
-   * turn context. Sits in the middle of the 5-10s range recommended in
-   * #59731.
-   */
-  const TYPING_KEEPALIVE_INTERVAL_MS = 8_000;
-
-  /**
-   * TTL ceiling for the typing keepalive loop. The default in
-   * createTypingCallbacks is 60s, which is too short for the Teams long tool
-   * chains described in #59731 (60s+ total runs are common). Give tool
-   * chains up to 10 minutes before auto-stopping the keepalive.
-   */
-  const TYPING_KEEPALIVE_MAX_DURATION_MS = 10 * 60_000;
-
-  // Forward reference: sendTypingIndicator is built before the stream
-  // controller exists, but the keepalive tick needs to check stream state so
-  // we don't overlay "..." typing on the visible streaming card. The ref is
-  // wired once the stream controller is constructed below.
-  const streamActiveRef: { current: () => boolean } = { current: () => false };
-
-  const rawSendTypingIndicator = async () => {
-    await withRevokedProxyFallback({
-      run: async () => {
-        await params.context.sendActivity({ type: "typing" });
-      },
-      onRevoked: async () => {
-        const baseRef = buildConversationReference(params.conversationRef);
-        await params.adapter.continueConversation(
-          params.appId,
-          { ...baseRef, activityId: undefined },
-          async (ctx) => {
-            await ctx.sendActivity({ type: "typing" });
-          },
-        );
-      },
-      onRevokedLog: () => {
-        params.log.debug?.("turn context revoked, sending typing via proactive messaging");
-      },
-    });
-  };
-
-  const sendTypingIndicator = isTypingSupported
-    ? async () => {
-        // While the streaming card is actively being updated the user
-        // already sees a live indicator in the stream — don't overlay a
-        // plain "..." typing on top of it. Between segments (tool chain)
-        // the stream is finalized, so typing indicators are appropriate
-        // and they are what keep the TurnContext alive. See #59731.
-        if (streamActiveRef.current()) {
-          return;
-        }
-        await rawSendTypingIndicator();
-      }
-    : async () => {};
-
-  const { onModelSelected, typingCallbacks, ...replyPipeline } = createChannelReplyPipeline({
-    cfg: params.cfg,
-    agentId: params.agentId,
-    channel: "msteams",
-    accountId: params.accountId,
-    typing: {
-      start: sendTypingIndicator,
-      keepaliveIntervalMs: TYPING_KEEPALIVE_INTERVAL_MS,
-      maxDurationMs: TYPING_KEEPALIVE_MAX_DURATION_MS,
-      onStartError: (err) => {
-        logTypingFailure({
-          log: (message) => params.log.debug?.(message),
-          channel: "msteams",
-          action: "start",
-          error: err,
-        });
-      },
-    },
-  });
-
-  const chunkMode = core.channel.text.resolveChunkMode(params.cfg, "msteams");
-  const tableMode = core.channel.text.resolveMarkdownTableMode({
-    cfg: params.cfg,
-    channel: "msteams",
-  });
-  const mediaMaxBytes = resolveChannelMediaMaxBytes({
-    cfg: params.cfg,
-    resolveChannelLimitMb: ({ cfg }) => cfg.channels?.msteams?.mediaMaxMb,
-  });
-  const feedbackLoopEnabled = params.cfg.channels?.msteams?.feedbackEnabled !== false;
-  const streamController = createTeamsReplyStreamController({
-    conversationType,
-    context: params.context,
-    feedbackLoopEnabled,
-    log: params.log,
-  });
-  // Wire the forward-declared gate used by sendTypingIndicator.
-  streamActiveRef.current = () => streamController.isStreamActive();
-
-  const blockStreamingEnabled =
-    typeof msteamsCfg?.blockStreaming === "boolean" ? msteamsCfg.blockStreaming : false;
-  const typingIndicatorEnabled =
-    typeof msteamsCfg?.typingIndicator === "boolean" ? msteamsCfg.typingIndicator : true;
-
-  const pendingMessages: MSTeamsRenderedMessage[] = [];
-
-  const sendMessages = async (messages: MSTeamsRenderedMessage[]): Promise<string[]> => {
-    return sendMSTeamsMessages({
-      replyStyle: params.replyStyle,
-      adapter: params.adapter,
-      appId: params.appId,
-      conversationRef: params.conversationRef,
-      context: params.context,
-      messages,
-      retry: {},
-      onRetry: (event) => {
-        params.log.debug?.("retrying send", {
-          replyStyle: params.replyStyle,
-          ...event,
-        });
-      },
-      tokenProvider: params.tokenProvider,
-      sharePointSiteId: params.sharePointSiteId,
-      mediaMaxBytes,
-      feedbackLoopEnabled,
-    });
-  };
-
-  const queueDeliveryFailureSystemEvent = (failure: {
-    failed: number;
-    total: number;
-    error: unknown;
-  }) => {
-    const classification = classifyMSTeamsSendError(failure.error);
-    const errorText = formatUnknownError(failure.error);
-    const failedAll = failure.failed >= failure.total;
-    const summary = failedAll
-      ? "the previous reply was not delivered"
-      : `${failure.failed} of ${failure.total} message blocks were not delivered`;
-    const sentences = [
-      `Microsoft Teams delivery failed: ${summary}.`,
-      `The user may not have received ${failedAll ? "that reply" : "the full reply"}.`,
-      `Error: ${errorText}.`,
-      classification.statusCode != null ? `Status: ${classification.statusCode}.` : undefined,
-      classification.kind === "transient" || classification.kind === "throttled"
-        ? "Retrying later may succeed."
-        : undefined,
-    ].filter(Boolean);
-    core.system.enqueueSystemEvent(sentences.join(" "), {
-      sessionKey: params.sessionKey,
-      contextKey: `msteams:delivery-failure:${params.conversationRef.conversation?.id ?? "unknown"}`,
-    });
-  };
-
-  const flushPendingMessages = async () => {
-    if (pendingMessages.length === 0) {
-      return;
-    }
-    const toSend = pendingMessages.splice(0);
-    const total = toSend.length;
-    let ids: string[];
-    try {
-      ids = await sendMessages(toSend);
-    } catch (batchError) {
-      ids = [];
-      let failed = 0;
-      let lastFailedError: unknown = batchError;
-      for (const msg of toSend) {
-        try {
-          const msgIds = await sendMessages([msg]);
-          ids.push(...msgIds);
-        } catch (msgError) {
-          failed += 1;
-          lastFailedError = msgError;
-          params.log.debug?.("individual message send failed, continuing with remaining blocks");
-        }
-      }
-      if (failed > 0) {
-        params.log.warn?.(`failed to deliver ${failed} of ${total} message blocks`, {
-          failed,
-          total,
-        });
-        queueDeliveryFailureSystemEvent({
-          failed,
-          total,
-          error: lastFailedError,
-        });
-      }
-    }
-    if (ids.length > 0) {
-      params.onSentMessageIds?.(ids);
-    }
-  };
-
-  const {
-    dispatcher,
-    replyOptions,
-    markDispatchIdle: baseMarkDispatchIdle,
-  } = core.channel.reply.createReplyDispatcherWithTyping({
-    ...replyPipeline,
-    humanDelay: core.channel.reply.resolveHumanDelayConfig(params.cfg, params.agentId),
-    onReplyStart: async () => {
-      await streamController.onReplyStart();
-      // Always start the typing keepalive loop when typing is enabled and
-      // supported by this conversation type. The sendTypingIndicator gate
-      // skips actual sends while the stream card is visually active, so
-      // during the first text segment the user only sees the streaming UI.
-      // Once the stream finalizes (between segments / during tool chains),
-      // the loop starts sending typing activities and keeps the Bot Framework
-      // TurnContext alive so the post-tool reply can still land. See #59731.
-      if (typingIndicatorEnabled) {
-        await typingCallbacks?.onReplyStart?.();
-      }
-    },
-    typingCallbacks,
-    deliver: async (payload) => {
-      const preparedPayload = streamController.preparePayload(payload);
-      if (!preparedPayload) {
-        return;
-      }
-
-      const messages = renderReplyPayloadsToMessages([preparedPayload], {
-        textChunkLimit: params.textLimit,
-        chunkText: true,
-        mediaMode: "split",
-        tableMode,
-        chunkMode,
-      });
-      pendingMessages.push(...messages);
-
-      // When block streaming is enabled, flush immediately so blocks are
-      // delivered progressively instead of batching until markDispatchIdle.
-      if (blockStreamingEnabled) {
-        await flushPendingMessages();
-      }
-    },
-    onError: (err, info) => {
-      const errMsg = formatUnknownError(err);
-      const classification = classifyMSTeamsSendError(err);
-      const hint = formatMSTeamsSendErrorHint(classification);
-      params.runtime.error?.(
-        `msteams ${info.kind} reply failed: ${errMsg}${hint ? ` (${hint})` : ""}`,
-      );
-      params.log.error("reply failed", {
-        kind: info.kind,
-        error: errMsg,
-        classification,
-        hint,
-      });
-    },
-  });
-
-  const markDispatchIdle = (): Promise<void> => {
-    return flushPendingMessages()
-      .catch((err) => {
-        const errMsg = formatUnknownError(err);
-        const classification = classifyMSTeamsSendError(err);
-        const hint = formatMSTeamsSendErrorHint(classification);
-        params.runtime.error?.(`msteams flush reply failed: ${errMsg}${hint ? ` (${hint})` : ""}`);
-        params.log.error("flush reply failed", {
-          error: errMsg,
-          classification,
-          hint,
-        });
-      })
-      .then(() => {
-        return streamController.finalize().catch((err) => {
-          params.log.debug?.("stream finalize failed", { error: formatUnknownError(err) });
-        });
-      })
-      .finally(() => {
-        baseMarkDispatchIdle();
-      });
-  };
-
-  return {
-    dispatcher,
-    replyOptions: {
-      ...replyOptions,
-      ...(streamController.hasStream()
-        ? {
-            onPartialReply: (payload: { text?: string }) =>
-              streamController.onPartialReply(payload),
-          }
-        : {}),
-      disableBlockStreaming:
-        typeof msteamsCfg?.blockStreaming === "boolean" ? !msteamsCfg.blockStreaming : undefined,
-      onModelSelected,
-    },
-    markDispatchIdle,
-  };
-}

package/src/reply-stream-controller.test.ts

@@ -1,235 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const streamInstances = vi.hoisted(
-  () =>
-    [] as Array<{
-      hasContent: boolean;
-      isFinalized: boolean;
-      isFailed: boolean;
-      streamedLength: number;
-      sendInformativeUpdate: ReturnType<typeof vi.fn>;
-      update: ReturnType<typeof vi.fn>;
-      finalize: ReturnType<typeof vi.fn>;
-    }>,
-);
-
-vi.mock("./streaming-message.js", () => ({
-  TeamsHttpStream: class {
-    hasContent = false;
-    isFinalized = false;
-    isFailed = false;
-    streamedLength = 0;
-    sendInformativeUpdate = vi.fn(async () => {});
-    update = vi.fn(function (
-      this: { hasContent: boolean; streamedLength: number },
-      payloadText?: string,
-    ) {
-      this.hasContent = true;
-      this.streamedLength = payloadText?.length ?? 0;
-    });
-    finalize = vi.fn(async function (this: { isFinalized: boolean }) {
-      this.isFinalized = true;
-    });
-
-    constructor() {
-      streamInstances.push(this as never);
-    }
-  },
-}));
-
-import { createTeamsReplyStreamController } from "./reply-stream-controller.js";
-
-describe("createTeamsReplyStreamController", () => {
-  function createController() {
-    streamInstances.length = 0;
-    return createTeamsReplyStreamController({
-      conversationType: "personal",
-      context: { sendActivity: vi.fn(async () => ({ id: "a" })) } as never,
-      feedbackLoopEnabled: false,
-      log: { debug: vi.fn() } as never,
-    });
-  }
-
-  it("suppresses fallback for first text segment that was streamed", () => {
-    const ctrl = createController();
-    ctrl.onPartialReply({ text: "Hello world" });
-
-    const result = ctrl.preparePayload({ text: "Hello world" });
-    expect(result).toBeUndefined();
-  });
-
-  it("when stream fails after partial delivery, fallback sends only remaining text", () => {
-    const ctrl = createController();
-    const fullText = "a".repeat(4000) + "b".repeat(200);
-
-    ctrl.onPartialReply({ text: fullText });
-    streamInstances[0].hasContent = false;
-    streamInstances[0].isFailed = true;
-    streamInstances[0].isFinalized = true;
-    streamInstances[0].streamedLength = 4000;
-
-    const result = ctrl.preparePayload({ text: fullText });
-    expect(result).toEqual({ text: "b".repeat(200) });
-  });
-
-  it("when stream fails before sending content, fallback sends full text", () => {
-    const ctrl = createController();
-    const fullText = "Failure at first chunk";
-
-    ctrl.onPartialReply({ text: fullText });
-    streamInstances[0].hasContent = false;
-    streamInstances[0].isFailed = true;
-    streamInstances[0].isFinalized = true;
-    streamInstances[0].streamedLength = 0;
-
-    const result = ctrl.preparePayload({ text: fullText });
-    expect(result).toEqual({ text: fullText });
-  });
-
-  it("allows fallback delivery for second text segment after tool calls", () => {
-    const ctrl = createController();
-
-    // First text segment: streaming tokens arrive
-    ctrl.onPartialReply({ text: "First segment" });
-
-    // First segment complete: preparePayload suppresses (stream handled it)
-    const result1 = ctrl.preparePayload({ text: "First segment" });
-    expect(result1).toBeUndefined();
-
-    // Tool calls happen... then second text segment arrives via deliver()
-    // preparePayload should allow fallback delivery for this segment
-    const result2 = ctrl.preparePayload({ text: "Second segment after tools" });
-    expect(result2).toEqual({ text: "Second segment after tools" });
-  });
-
-  it("finalizes the stream when suppressing first segment", () => {
-    const ctrl = createController();
-    ctrl.onPartialReply({ text: "Streamed text" });
-
-    ctrl.preparePayload({ text: "Streamed text" });
-
-    expect(streamInstances[0]?.finalize).toHaveBeenCalled();
-  });
-
-  it("uses fallback even when onPartialReply fires after stream finalized", () => {
-    const ctrl = createController();
-
-    // First text segment: streaming tokens arrive
-    ctrl.onPartialReply({ text: "First segment" });
-
-    // First segment complete: preparePayload suppresses and finalizes stream
-    const result1 = ctrl.preparePayload({ text: "First segment" });
-    expect(result1).toBeUndefined();
-    expect(streamInstances[0]?.isFinalized).toBe(true);
-
-    // Post-tool partial replies fire again (stream.update is a no-op since finalized)
-    ctrl.onPartialReply({ text: "Second segment" });
-
-    // Must still use fallback because stream is finalized and can't deliver
-    const result2 = ctrl.preparePayload({ text: "Second segment" });
-    expect(result2).toEqual({ text: "Second segment" });
-  });
-
-  it("delivers all segments across 3+ tool call rounds", () => {
-    const ctrl = createController();
-
-    // Round 1: text → tool
-    ctrl.onPartialReply({ text: "Segment 1" });
-    expect(ctrl.preparePayload({ text: "Segment 1" })).toBeUndefined();
-
-    // Round 2: text → tool
-    ctrl.onPartialReply({ text: "Segment 2" });
-    const r2 = ctrl.preparePayload({ text: "Segment 2" });
-    expect(r2).toEqual({ text: "Segment 2" });
-
-    // Round 3: final text
-    ctrl.onPartialReply({ text: "Segment 3" });
-    const r3 = ctrl.preparePayload({ text: "Segment 3" });
-    expect(r3).toEqual({ text: "Segment 3" });
-  });
-
-  it("passes media+text payload through fully after stream finalized", () => {
-    const ctrl = createController();
-
-    // First segment streamed and finalized
-    ctrl.onPartialReply({ text: "Streamed text" });
-    ctrl.preparePayload({ text: "Streamed text" });
-
-    // Second segment has both text and media — should pass through fully
-    const result = ctrl.preparePayload({
-      text: "Post-tool text with image",
-      mediaUrl: "https://example.com/tool-output.png",
-    });
-    expect(result).toEqual({
-      text: "Post-tool text with image",
-      mediaUrl: "https://example.com/tool-output.png",
-    });
-  });
-
-  it("still strips text from media payloads when stream handled text", () => {
-    const ctrl = createController();
-    ctrl.onPartialReply({ text: "Some text" });
-
-    const result = ctrl.preparePayload({
-      text: "Some text",
-      mediaUrl: "https://example.com/image.png",
-    });
-    expect(result).toEqual({
-      text: undefined,
-      mediaUrl: "https://example.com/image.png",
-    });
-  });
-
-  describe("isStreamActive", () => {
-    it("returns false before any tokens arrive so typing keepalive can warm up", () => {
-      const ctrl = createController();
-      expect(ctrl.isStreamActive()).toBe(false);
-    });
-
-    it("returns false after the informative update but before tokens arrive", async () => {
-      const ctrl = createController();
-      await ctrl.onReplyStart();
-      expect(ctrl.isStreamActive()).toBe(false);
-    });
-
-    it("returns true while the stream is actively receiving tokens", () => {
-      const ctrl = createController();
-      ctrl.onPartialReply({ text: "Streaming tokens" });
-      expect(ctrl.isStreamActive()).toBe(true);
-    });
-
-    it("returns false after the stream is finalized between tool rounds", () => {
-      const ctrl = createController();
-
-      ctrl.onPartialReply({ text: "First segment" });
-      expect(ctrl.isStreamActive()).toBe(true);
-
-      // First segment complete: stream is finalized so the typing keepalive
-      // can resume during the tool chain that follows.
-      ctrl.preparePayload({ text: "First segment" });
-      expect(ctrl.isStreamActive()).toBe(false);
-    });
-
-    it("returns false when the stream has failed", () => {
-      const ctrl = createController();
-
-      ctrl.onPartialReply({ text: "First segment" });
-      expect(ctrl.isStreamActive()).toBe(true);
-
-      streamInstances[0].isFailed = true;
-      expect(ctrl.isStreamActive()).toBe(false);
-    });
-
-    it("returns false when conversationType is not personal", () => {
-      streamInstances.length = 0;
-      const ctrl = createTeamsReplyStreamController({
-        conversationType: "channel",
-        context: { sendActivity: vi.fn() } as never,
-        feedbackLoopEnabled: false,
-        log: { debug: vi.fn() } as never,
-      });
-      ctrl.onPartialReply({ text: "anything" });
-      expect(ctrl.isStreamActive()).toBe(false);
-    });
-  });
-});