import { beforeEach, describe, expect, it, vi } from "vitest";

const { realtimeTalkCtor, startMock, stopMock } = vi.hoisted(() => ({

realtimeTalkCtor: vi.fn(),

startMock: vi.fn(),

stopMock: vi.fn(),

}));

describe("OpenClawApp Talk controls", () => {

beforeEach(() => {

vi.restoreAllMocks();

vi.resetModules();

vi.doMock("./chat/realtime-talk.ts", () => ({

RealtimeTalkSession: realtimeTalkCtor,

}));

realtimeTalkCtor.mockReset();

startMock.mockReset();

stopMock.mockReset();

realtimeTalkCtor.mockImplementation(

function MockRealtimeTalkSession(this: { start: typeof startMock; stop: typeof stopMock }) {

this.start = startMock;

this.stop = stopMock;

},

);

startMock.mockResolvedValue(undefined);

});

it("retries Talk immediately when the previous session is already in error state", async () => {

await import("./app.ts");

const app = document.createElement("openclaw-app") as unknown as {

const { OpenClawApp } = await import("./app.ts");

const staleStop = vi.fn();

const app: {

client: unknown;

connected: boolean;

lastError: string | null;

realtimeTalkActive: boolean;

realtimeTalkStatus: string;

realtimeTalkSession: { stop(): void } | null;

sessionKey: string;

toggleRealtimeTalk(): Promise<void>;

} = {

client: { request: vi.fn() },

connected: true,

lastError: null,

realtimeTalkActive: true,

realtimeTalkStatus: "error",

realtimeTalkSession: { stop: staleStop },

sessionKey: "main",

};

const staleStop = vi.fn();

const request = vi.fn().mockRejectedValue(new Error("session unavailable"));

app.client = { request } as never;

app.connected = true;

app.sessionKey = "main";

app.realtimeTalkActive = true;

app.realtimeTalkStatus = "error";

app.realtimeTalkSession = { stop: staleStop };

await app.toggleRealtimeTalk();

await OpenClawApp.prototype.toggleRealtimeTalk.call(app as never);

expect(staleStop).toHaveBeenCalledOnce();

expect(request).toHaveBeenCalledOnce();

expect(request).toHaveBeenCalledWith("talk.realtime.session", { sessionKey: "main" });

expect(app.realtimeTalkStatus).toBe("error");

expect(app.realtimeTalkSession).toBeNull();

expect(realtimeTalkCtor).toHaveBeenCalledOnce();

expect(startMock).toHaveBeenCalledOnce();

expect(stopMock).not.toHaveBeenCalled();

expect(app.realtimeTalkStatus).toBe("connecting");

expect(app.realtimeTalkSession).not.toBeNull();

});

});