describe("createFeishuReplyDispatcher streaming behavior", () => {

type ReplyDispatcherArgs = Parameters<typeof createFeishuReplyDispatcher>[0];

type TypingDispatcherOptions = {

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

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

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

};

beforeEach(() => {

vi.clearAllMocks();

chatId: "oc_chat",

});

return createReplyDispatcherWithTypingMock.mock.calls.at(0)?.[0];

return firstMockArg(createReplyDispatcherWithTypingMock, "reply dispatcher options");

}

function createRuntimeLogger() {

callIndex = 0,

argIndex = 0,

): Record<string, unknown> {

return expectRecordFields(mock.mock.calls.at(callIndex)?.[argIndex], label, expected);

return expectRecordFields(mockArg(mock, callIndex, argIndex, label), label, expected);

}

function mockArg(

mock: ReturnType<typeof vi.fn>,

callIndex: number,

argIndex: number,

label: string,

) {

const call = mock.mock.calls[callIndex];

if (!call) {

throw new Error(`missing ${label} call ${callIndex + 1}`);

}

return call[argIndex];

}

function firstMockArg(mock: ReturnType<typeof vi.fn>, label: string, argIndex = 0) {

return mockArg(mock, 0, argIndex, label);

}

function firstTypingDispatcherOptions(): TypingDispatcherOptions {

return firstMockArg(

createReplyDispatcherWithTypingMock,

"reply dispatcher options",

) as TypingDispatcherOptions;

}

function firstStreamingCloseText(instanceIndex = 0): string {

const close = streamingInstances[instanceIndex]?.close;

if (!close) {

throw new Error(`Expected streaming instance ${instanceIndex}`);

}

return String(firstMockArg(close, "streaming close"));

}

function expectLastMockArgFields(

if (!start) {

throw new Error(`Expected streaming instance ${instanceIndex}`);

}

expect(start.mock.calls.at(0)?.[0]).toBe("oc_chat");

expect(start.mock.calls.at(0)?.[1]).toBe("chat_id");

return expectRecordFields(start.mock.calls.at(0)?.[2], "streaming start options", expected);

expect(firstMockArg(start, "streaming start")).toBe("oc_chat");

expect(firstMockArg(start, "streaming start", 1)).toBe("chat_id");

return expectRecordFields(

firstMockArg(start, "streaming start", 2),

"streaming start options",

expected,

);

}

function streamingUpdateTexts(instanceIndex = 0): string[] {

replyToMessageId: "om_parent",

});

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

const options = firstTypingDispatcherOptions();

await options.onReplyStart?.();

expect(addTypingIndicatorMock).not.toHaveBeenCalled();

messageCreateTimeMs: Date.now() - 3 * 60_000,

});

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

const options = firstTypingDispatcherOptions();

await options.onReplyStart?.();

expect(addTypingIndicatorMock).not.toHaveBeenCalled();

messageCreateTimeMs: Math.floor((Date.now() - 3 * 60_000) / 1000),

});

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

const options = firstTypingDispatcherOptions();

await options.onReplyStart?.();

expect(addTypingIndicatorMock).not.toHaveBeenCalled();

messageCreateTimeMs: Date.now() - 30_000,

});

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

const options = firstTypingDispatcherOptions();

await options.onReplyStart?.();

expect(addTypingIndicatorMock).toHaveBeenCalledTimes(1);

await options.deliver({ text: "plain text" }, { kind: "final" });

expect(sendMessageFeishuMock).toHaveBeenCalledTimes(1);

expect(sendMessageFeishuMock.mock.calls.at(0)?.[0]).not.toHaveProperty("mentions");

expect(firstMockArg(sendMessageFeishuMock, "send message params")).not.toHaveProperty(

"mentions",

);

});

it("does not attach automatic mentions to card replies", async () => {

await options.deliver({ text: "card text" }, { kind: "final" });

expect(sendStructuredCardFeishuMock).toHaveBeenCalledTimes(1);

expect(sendStructuredCardFeishuMock.mock.calls.at(0)?.[0]).not.toHaveProperty("mentions");

expect(firstMockArg(sendStructuredCardFeishuMock, "structured card params")).not.toHaveProperty(

"mentions",

);

});

it("suppresses internal block payload delivery", async () => {

}

expect(streamingInstances[0].close).toHaveBeenCalledTimes(1);

const closeArg = streamingInstances[0].close.mock.calls.at(0)?.[0] as string;

const closeArg = firstStreamingCloseText();

expect(closeArg).toContain("> 💭 **Thinking**");

expect(closeArg).toContain("---");

expect(closeArg).toContain("answer part final");

expect(streamingInstances).toHaveLength(1);

expect(streamingInstances[0].close).toHaveBeenCalledTimes(1);

const closeArg = streamingInstances[0].close.mock.calls.at(0)?.[0] as string;

const closeArg = firstStreamingCloseText();

expect(closeArg).toContain("> 💭 **Thinking**");

expect(closeArg).toContain("> deep thought");

expect(closeArg).not.toContain("Reasoning:");

await options.onIdle?.();

expect(streamingInstances).toHaveLength(1);

const closeArg = streamingInstances[0].close.mock.calls.at(0)?.[0] as string;

const closeArg = firstStreamingCloseText();

expect(closeArg).not.toContain("Thinking");

expect(closeArg).toBe("```ts\ncode\n```");

});

chatId: "oc_chat",

});

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

const options = firstTypingDispatcherOptions();

// First deliver with markdown triggers startStreaming - which will fail

await options.deliver({ text: "```ts\nconst x = 1\n```" }, { kind: "final" });