};

});

import { createFeishuReplyDispatcher } from "./reply-dispatcher.js";

import {

clearFeishuStreamingStartBackoffForTests,

createFeishuReplyDispatcher,

} from "./reply-dispatcher.js";

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

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

beforeEach(() => {

vi.clearAllMocks();

clearFeishuStreamingStartBackoffForTests();

streamingInstances.length = 0;

sendMediaFeishuMock.mockResolvedValue(undefined);

sendStructuredCardFeishuMock.mockResolvedValue(undefined);

);

});

it("recovers streaming after start() throws (HTTP 400)", async () => {

it("backs off streaming retries after start() throws (HTTP 400)", async () => {

const errorMock = vi.fn();

let shouldFailStart = true;

const nowSpy = vi.spyOn(Date, "now").mockReturnValue(1_000);

// Intercept streaming instance creation to make first start() reject

const origPush = streamingInstances.push.bind(streamingInstances);

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

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

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

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

// Wait for the async error to propagate

await vi.waitFor(() => {

expect(errorMock).toHaveBeenCalledWith(expect.stringContaining("streaming start failed"));

});

expect(streamingInstances).toHaveLength(1);

expect(sendStructuredCardFeishuMock).toHaveBeenCalledTimes(1);

// Second deliver should create a NEW streaming session (not stuck)

// Immediate next markdown reply should skip a new streaming start and

// fall back directly to a normal card instead of paying the 400 latency.

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

// Two instances created: first failed, second succeeded and closed

expect(streamingInstances).toHaveLength(1);

expect(sendStructuredCardFeishuMock).toHaveBeenCalledTimes(2);

// After the short backoff expires, retry streaming so fixed permissions

// or transient Feishu failures recover without a process restart.

nowSpy.mockReturnValue(62_000);

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

expect(streamingInstances).toHaveLength(2);

expect(streamingInstances[1].start).toHaveBeenCalled();

expect(streamingInstances[1].close).toHaveBeenCalled();

} finally {

streamingInstances.push = origPush;

nowSpy.mockRestore();

}

});

});