await vi.advanceTimersByTimeAsync(1);

const credentials = await credentialsPromise;

const userCodeRequest = fetchMock.mock.calls[0];

const userCodeRequest = fetchMock.mock.calls.at(0);

expect(userCodeRequest?.[0]).toBe("https://auth.openai.com/api/accounts/deviceauth/usercode");

expect(userCodeRequest?.[1]?.method).toBe("POST");

expect(userCodeRequest?.[1]?.headers).toEqual({

"User-Agent": "openclaw/2026.3.22",

});

const deviceTokenRequest = fetchMock.mock.calls[1];

const deviceTokenRequest = fetchMock.mock.calls.at(1);

expect(deviceTokenRequest?.[0]).toBe("https://auth.openai.com/api/accounts/deviceauth/token");

expect(deviceTokenRequest?.[1]?.method).toBe("POST");

expect(deviceTokenRequest?.[1]?.headers).toEqual({

"User-Agent": "openclaw/2026.3.22",

});

const oauthTokenRequest = fetchMock.mock.calls[3];

const oauthTokenRequest = fetchMock.mock.calls.at(3);

expect(oauthTokenRequest?.[0]).toBe("https://auth.openai.com/oauth/token");

expect(oauthTokenRequest?.[1]?.method).toBe("POST");

expect(oauthTokenRequest?.[1]?.headers).toEqual({

instructions: "Be concise.",

});

expect(execFileSyncMock.mock.calls[0]?.[0]).toBe("/usr/bin/security");

expect(execFileSyncMock.mock.calls[0]?.[1]).toEqual([

expect(execFileSyncMock.mock.calls.at(0)?.[0]).toBe("/usr/bin/security");

expect(execFileSyncMock.mock.calls.at(0)?.[1]).toEqual([

"find-generic-password",

"-s",

"openclaw",

"-a",

"OPENAI_REALTIME_BROWSER_TEST",

"-w",

]);

expectRecordFields(execFileSyncMock.mock.calls[0]?.[2], "security command options", {

expectRecordFields(execFileSyncMock.mock.calls.at(0)?.[2], "security command options", {

encoding: "utf8",

timeout: 5000,

});

);

expect(runtime.channel.turn.runAssembled).toHaveBeenCalledTimes(1);

expect(vi.mocked(runtime.channel.turn.runAssembled).mock.calls[0]?.[0].replyPipeline).toEqual(

{},

);

expect(

vi.mocked(runtime.channel.turn.runAssembled).mock.calls[0]?.[0].ctxPayload.WasMentioned,

vi.mocked(runtime.channel.turn.runAssembled).mock.calls.at(0)?.[0].replyPipeline,

).toEqual({});

expect(

vi.mocked(runtime.channel.turn.runAssembled).mock.calls.at(0)?.[0].ctxPayload.WasMentioned,

).toBe(true);

});

);

expect(runtime.channel.turn.runAssembled).toHaveBeenCalledTimes(1);

const ctxPayload = vi.mocked(runtime.channel.turn.runAssembled).mock.calls[0]?.[0].ctxPayload;

const ctxPayload = vi

.mocked(runtime.channel.turn.runAssembled)

.mock.calls.at(0)?.[0].ctxPayload;

expect(ctxPayload?.CommandAuthorized).toBe(true);

expect(ctxPayload?.SenderId).toBe("alice");

});

});

expect(startQaProviderServer).toHaveBeenCalledWith("mock-openai");

const gatewayOptions = startQaGatewayChild.mock.calls[0]?.[0] as

const gatewayOptions = startQaGatewayChild.mock.calls.at(0)?.[0] as

| { providerBaseUrl?: string; providerMode?: string; transportBaseUrl?: string }

| undefined;

expect(gatewayOptions?.transportBaseUrl).toBe("http://127.0.0.1:43123");

controlUiEnabled: false,

});

const [{ mutateConfig }] = startQaGatewayChild.mock.calls[0] ?? [];

const [{ mutateConfig }] = startQaGatewayChild.mock.calls.at(0) ?? [];

if (!mutateConfig) {

throw new Error("expected gateway config mutator");

}

});

expect(startQaProviderServer).toHaveBeenCalledWith("live-frontier");

const gatewayOptions = startQaGatewayChild.mock.calls[0]?.[0] as

const gatewayOptions = startQaGatewayChild.mock.calls.at(0)?.[0] as

| { providerBaseUrl?: string; providerMode?: string; transportBaseUrl?: string }

| undefined;

expect(gatewayOptions?.transportBaseUrl).toBe("http://127.0.0.1:43123");

child.emit("exit", 0);

await expect(pending).resolves.toBe("ok");

const spawnCall = spawnMock.mock.calls[0];

const spawnCall = spawnMock.mock.calls.at(0);

expect(spawnCall?.[0]).toBe("/usr/bin/node");

expect(spawnCall?.[1]).toEqual([path.join("/repo", "dist", "index.js"), "qa", "suite"]);

expect((spawnCall?.[2] as { cwd?: string; env?: unknown } | undefined)?.cwd).toBe(

child.emit("exit", 0);

await expect(pending).resolves.toBe("ok");

const spawnCall = spawnMock.mock.calls[0];

const spawnCall = spawnMock.mock.calls.at(0);

expect(spawnCall?.[0]).toBe("/usr/bin/node");

expect(spawnCall?.[1]).toEqual([

path.join("/repo", "dist", "index.js"),

message: "hello",

}),

).resolves.toEqual({ runId: "run-1" });

const gatewayArgs = gatewayCall.mock.calls[0] as unknown as

const gatewayArgs = gatewayCall.mock.calls.at(0) as unknown as

| [string, unknown, unknown]

| undefined;

expect(gatewayArgs?.[0]).toBe("agent");

textStyles: [{ start: 0, length: 4, style: "BOLD" }],

});

const callArgs = mockFetch.mock.calls[0];

const callArgs = mockFetch.mock.calls.at(0);

if (callArgs === undefined) {

throw new Error("expected container fetch call");

}

const body = JSON.parse(callArgs[1].body);

expect(body.message).toBe("**Bold** \\* not italic");

});

textStyles: [{ start: 0, length: 4, style: "BOLD" }],

});

const callArgs = mockFetch.mock.calls[0];

const callArgs = mockFetch.mock.calls.at(0);

if (callArgs === undefined) {

throw new Error("expected container fetch call");

}

const body = JSON.parse(callArgs[1].body);

expect(body.message).toBe("**Bold** C:\\Temp\\file and /foo\\bar/");

});

attachments: [tmpFile],

});

const callArgs = mockFetch.mock.calls[0];

const callArgs = mockFetch.mock.calls.at(0);

if (callArgs === undefined) {

throw new Error("expected container fetch call");

}

const body = JSON.parse(callArgs[1].body);

expect(body.attachments).toBeUndefined();

if (!Array.isArray(body.base64_attachments)) {

to: "12345",

text: "hi **boss**",

});

expect(sendMessageTelegram.mock.calls[0]?.[2]).not.toHaveProperty("textMode");

expect(sendMessageTelegram.mock.calls.at(0)?.[2]).not.toHaveProperty("textMode");

await sendText({

cfg: createTelegramConfig(),

to: "12345",

text: "<b>hi boss</b>",

formatting: { parseMode: "HTML" },

});

expect(sendMessageTelegram.mock.calls[1]?.[2]?.textMode).toBe("html");

expect(sendMessageTelegram.mock.calls.at(1)?.[2]?.textMode).toBe("html");

});

it("preserves explicit HTML parse mode for payload media captions", async () => {

formatting: { parseMode: "HTML" },

});

expect(sendMessageTelegram.mock.calls[0]?.[2]?.textMode).toBe("html");

expect(sendMessageTelegram.mock.calls.at(0)?.[2]?.textMode).toBe("html");

});

});

cfg: {},

});

const createCall = fetchMock.mock.calls[0];

const createCall = fetchMock.mock.calls.at(0);

expect(createCall?.[0]).toBe("https://www.vydra.ai/api/v1/models/veo3");

const createInit = createCall?.[1] as { method?: string; body?: unknown } | undefined;

expect(createInit?.method).toBe("POST");

expect(createInit?.body).toBe(JSON.stringify({ prompt: "tiny city at sunrise" }));

const pollCall = fetchMock.mock.calls[1];

const pollCall = fetchMock.mock.calls.at(1);

expect(pollCall?.[0]).toBe("https://www.vydra.ai/api/v1/jobs/job-123");

const pollInit = pollCall?.[1] as { method?: string } | undefined;

expect(pollInit?.method).toBe("GET");

inputImages: [{ url: "https://example.com/reference.png" }],

});

const createCall = fetchMock.mock.calls[0];

const createCall = fetchMock.mock.calls.at(0);

expect(createCall?.[0]).toBe("https://www.vydra.ai/api/v1/models/kling");

const createInit = createCall?.[1] as { method?: string; body?: unknown } | undefined;

expect(createInit?.method).toBe("POST");

await loginWeb(false, waitForWaConnectionMock as never, runtime);

expect(createWaSocketMock).toHaveBeenCalledTimes(2);

expect(createWaSocketMock.mock.calls[0]?.[0]).toBe(false);

const initialOpts = createWaSocketMock.mock.calls[0]?.[2] as

expect(createWaSocketMock.mock.calls.at(0)?.[0]).toBe(false);

const initialOpts = createWaSocketMock.mock.calls.at(0)?.[2] as

| { onQr?: (qr: string) => void }

| undefined;

const restartOpts = createWaSocketMock.mock.calls[1]?.[2] as

const restartOpts = createWaSocketMock.mock.calls.at(1)?.[2] as

| { onQr?: (qr: string) => void }

| undefined;

expect(initialOpts?.onQr).toBe(restartOpts?.onQr);

await settleInboundWork();

expect(onMessage).toHaveBeenCalledTimes(1);

const payload = onMessage.mock.calls[0][0];

const payload = onMessage.mock.calls.at(0)?.[0];

expect(payload.chatType).toBe("group");

expect(payload.senderE164).toBe("+999");

// Should call onMessage because sender is in groupAllowFrom

expect(onMessage).toHaveBeenCalledTimes(1);

const payload = onMessage.mock.calls[0][0];

const payload = onMessage.mock.calls.at(0)?.[0];

expect(payload.chatType).toBe("group");

expect(payload.senderE164).toBe("+15551234567");

// Should call onMessage because wildcard allows all senders

expect(onMessage).toHaveBeenCalledTimes(1);

const payload = onMessage.mock.calls[0][0];

const payload = onMessage.mock.calls.at(0)?.[0];

expect(payload.chatType).toBe("group");

await listener.close();