});

expect(setTimeoutSpy).toHaveBeenCalledTimes(1);

const [cleanupCallback, cleanupDelayMs] = setTimeoutSpy.mock.calls[0];

const cleanupCall = setTimeoutSpy.mock.calls.at(0);

if (cleanupCall === undefined) {

throw new Error("expected cleanup timeout call");

}

const [cleanupCallback, cleanupDelayMs] = cleanupCall;

expect(cleanupDelayMs).toBe(5 * 60_000);

expect(cleanupCallback).toBeTypeOf("function");

} finally {

runner.stop();

expect(runOnce).toHaveBeenCalledTimes(1);

const runOptions = runOnce.mock.calls[0]?.[0] as

const runOptions = runOnce.mock.calls.at(0)?.[0] as

| { agentId?: string; heartbeat?: { target?: string }; sessionKey?: string }

| undefined;

expect(runOptions?.agentId).toBe("main");

});

expect(sendTelegram).toHaveBeenCalledTimes(1);

const [chatId, text, options] = sendTelegram.mock.calls[0] ?? [];

const [chatId, text, options] = sendTelegram.mock.calls.at(0) ?? [];

expect(chatId).toBe(TELEGRAM_GROUP);

expect(text).toBe("Hello from heartbeat");

expect(options?.accountId).toBe(params.expectedAccountId);

expect(installFromArchive).not.toHaveBeenCalled();

const withTempDirMock = vi.mocked(withTempDir);

expect(withTempDirMock).toHaveBeenCalledTimes(1);

const [tempDirPrefix, tempDirCallback] = withTempDirMock.mock.calls[0];

const tempDirCall = withTempDirMock.mock.calls.at(0);

if (tempDirCall === undefined) {

throw new Error("expected temp dir call");

}

const [tempDirPrefix, tempDirCallback] = tempDirCall;

expect(tempDirPrefix).toBe("openclaw-test-");

expect(tempDirCallback).toBeTypeOf("function");

});

},

assertDeps: (deps: { localchat?: ReturnType<typeof vi.fn> }) => {

expect(deps.localchat).toHaveBeenCalledTimes(1);

const [to, text, options] = deps.localchat?.mock.calls[0] ?? [];

const [to, text, options] = deps.localchat?.mock.calls.at(0) ?? [];

expect(to).toBe("someone@example.com");

expect(text).toBe("hi");

expect(typeof options).toBe("object");

label = "mock first argument",

): Record<string, unknown> {

expect(mock.mock.calls).toHaveLength(1);

const [firstArg] = mock.mock.calls[0] ?? [];

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

return requireRecord(firstArg, label);

}

},

});

const copilotCall = requireRecord(

resolveCopilotApiTokenMock.mock.calls[0]?.[0],

resolveCopilotApiTokenMock.mock.calls.at(0)?.[0],

"copilot token params",

);

expect(copilotCall.githubToken).toBe("github-env-token");

await flushMicrotasks();

expect(agentCommandFromIngressMock).toHaveBeenCalledTimes(1);

const ingressOptions = agentCommandFromIngressMock.mock.calls[0]?.[0] as

const ingressOptions = agentCommandFromIngressMock.mock.calls.at(0)?.[0] as

| { timeout?: unknown }

| undefined;

expect(ingressOptions?.timeout).toBe("300");

expect(imported.label).toBe("Light Green");

const fetchMock = vi.mocked(fetchImpl);

expect(fetchMock).toHaveBeenCalledTimes(1);

const [fetchUrl, fetchOptions] = fetchMock.mock.calls[0] as [

const [fetchUrl, fetchOptions] = fetchMock.mock.calls.at(0) as [

string,

{ headers?: unknown; redirect?: unknown; signal?: unknown },

];

]);

expect(onTranscript).toHaveBeenCalledWith({ role: "user", text: "hello", final: true });

expect(onTranscript).toHaveBeenCalledWith({ role: "assistant", text: "hi", final: false });

const audioEvent = onTalkEvent.mock.calls[2]?.[0];

const audioEvent = onTalkEvent.mock.calls.at(2)?.[0];

expect(audioEvent?.payload).toStrictEqual({ byteLength: 4, mimeType: "audio/pcm;rate=24000" });

expect(audioEvent?.sessionId).toBe("main:google:provider-websocket");

expect(audioEvent?.transport).toBe("provider-websocket");