return lastContextSendActivity;

}

type DispatcherOptions = {

onReplyStart?: () => Promise<void> | void;

deliver: (payload: { text: string }) => Promise<void> | void;

};

type PipelineArgs = {

typing?: {

keepaliveIntervalMs?: number;

maxDurationMs?: number;

start?: () => Promise<void>;

};

};

function dispatcherOptions(): DispatcherOptions {

const [call] = createReplyDispatcherWithTypingMock.mock.calls;

if (!call) {

throw new Error("expected reply dispatcher factory call");

}

return call[0] as DispatcherOptions;

}

function pipelineArgs(): PipelineArgs {

const [call] = createChannelMessageReplyPipelineMock.mock.calls;

if (!call) {

throw new Error("expected reply pipeline factory call");

}

return call[0] as PipelineArgs;

}

function pipelineTypingStart(): () => Promise<void> {

const sendTyping = pipelineArgs().typing?.start;

if (typeof sendTyping !== "function") {

throw new Error("expected typing start callback");

}

return sendTyping;

}

function firstSystemEventCall(): [string, unknown] {

const [call] = enqueueSystemEventMock.mock.calls;

if (!call) {

throw new Error("expected system event call");

}

return call as [string, unknown];

}

async function triggerPartialReply(text: string): Promise<void> {

if (!lastCreatedDispatcher) {

throw new Error("createDispatcher must be called first");

it("sends an informative status update once work expands in personal chats", async () => {

const dispatcher = createDispatcher("personal", { streaming: { mode: "progress" } });

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.onReplyStart?.();

await dispatcher.replyOptions.onToolStart?.({ name: "exec" });

it("starts the typing keepalive in personal chats so the TurnContext survives long tool chains", async () => {

createDispatcher("personal");

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.onReplyStart?.();

it("skips the typing keepalive in personal chats when typingIndicator=false", async () => {

createDispatcher("personal", { typingIndicator: false });

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.onReplyStart?.();

it("passes a longer keepalive TTL so the loop survives long tool chains", () => {

createDispatcher("personal");

const pipelineArgs = createChannelMessageReplyPipelineMock.mock.calls[0]?.[0];

expect(pipelineArgs?.typing?.keepaliveIntervalMs).toBeGreaterThan(3_000);

expect(pipelineArgs?.typing?.keepaliveIntervalMs).toBeLessThanOrEqual(10_000);

const args = pipelineArgs();

expect(args.typing?.keepaliveIntervalMs).toBeGreaterThan(3_000);

expect(args.typing?.keepaliveIntervalMs).toBeLessThanOrEqual(10_000);

// Issue #59731 reports 60s+ tool chains — the default 60s TTL is too

// tight so the dispatcher passes its own generous ceiling.

expect(pipelineArgs?.typing?.maxDurationMs).toBeGreaterThanOrEqual(300_000);

expect(args.typing?.maxDurationMs).toBeGreaterThanOrEqual(300_000);

});

it("allows typing keepalive sends before any stream tokens arrive", async () => {

createDispatcher("personal");

const pipelineArgs = createChannelMessageReplyPipelineMock.mock.calls[0]?.[0];

const sendTyping = pipelineArgs?.typing?.start as () => Promise<void>;

const sendTyping = pipelineTypingStart();

// No onPartialReply has been called yet, so the stream is not active.

// The typing keepalive should be allowed to warm the TurnContext.

it("suppresses typing keepalive sends while the stream card is actively chunking", async () => {

createDispatcher("personal");

const pipelineArgs = createChannelMessageReplyPipelineMock.mock.calls[0]?.[0];

const sendTyping = pipelineArgs?.typing?.start as () => Promise<void>;

const sendTyping = pipelineTypingStart();

// Simulate the stream actively receiving a partial chunk. While the

// stream card is live we do not want a plain "..." typing indicator

it("resumes typing keepalive sends once the stream finalizes between tool rounds", async () => {

createDispatcher("personal");

const pipelineArgs = createChannelMessageReplyPipelineMock.mock.calls[0]?.[0];

const sendTyping = pipelineArgs?.typing?.start as () => Promise<void>;

const sendTyping = pipelineTypingStart();

// First segment: tokens flow, stream is active, typing is gated off.

await triggerPartialReply("first segment tokens");

it("fires native typing in group chats (no stream) because the gate never applies", async () => {

createDispatcher("groupchat");

const pipelineArgs = createChannelMessageReplyPipelineMock.mock.calls[0]?.[0];

const sendTyping = pipelineArgs?.typing?.start as () => Promise<void>;

const sendTyping = pipelineTypingStart();

// In group chats we don't create a stream, so isStreamActive() always

// returns false and the typing indicator still fires normally.

it("is a no-op for channel conversations (typing unsupported)", async () => {

createDispatcher("channel");

const pipelineArgs = createChannelMessageReplyPipelineMock.mock.calls[0]?.[0];

const sendTyping = pipelineArgs?.typing?.start as () => Promise<void>;

const sendTyping = pipelineTypingStart();

const contextSendActivity = getContextSendActivity();

contextSendActivity.mockClear();

it("sends native typing indicator for channel conversations by default", async () => {

createDispatcher("channel");

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.onReplyStart?.();

it("skips native typing indicator when typingIndicator=false", async () => {

createDispatcher("channel", { typingIndicator: false });

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.onReplyStart?.();

sendMSTeamsMessagesMock.mockResolvedValue(["id-1"] as never);

const dispatcher = createDispatcher("personal", { streaming: { mode: "block" } });

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.deliver({ text: "block content" });

sendMSTeamsMessagesMock.mockResolvedValue(["id-1"] as never);

createDispatcher("personal", { blockStreaming: true });

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

// Call deliver — with blockStreaming enabled it should flush immediately

await options.deliver({ text: "block content" });

renderReplyPayloadsToMessagesMock.mockReturnValue([{ content: "hello" }] as never);

createDispatcher("personal", { blockStreaming: false });

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.deliver({ text: "block content" });

{ blockStreaming: false },

{ onSentMessageIds },

);

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.deliver({ text: "block content" });

await dispatcher.markDispatchIdle();

expect(onSentMessageIds).toHaveBeenCalledWith(["id-1"]);

expect(enqueueSystemEventMock).toHaveBeenCalledTimes(1);

const [message, context] = enqueueSystemEventMock.mock.calls[0] ?? [];

const [message, context] = firstSystemEventCall();

expect(message).toContain("Microsoft Teams delivery failed");

expect(message).toContain("1 of 2 message blocks were not delivered");

expect(message).toContain("The user may not have received the full reply");

sendMSTeamsMessagesMock.mockResolvedValue(["id-1"] as never);

const dispatcher = createDispatcher("personal", { blockStreaming: false });

const options = createReplyDispatcherWithTypingMock.mock.calls[0]?.[0];

const options = dispatcherOptions();

await options.deliver({ text: "block content" });

await dispatcher.markDispatchIdle();