import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

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

import { createMattermostClient, createMattermostDirectChannelWithRetry } from "./client.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

describe("createMattermostDirectChannelWithRetry", () => {

const mockFetch = vi.fn<typeof fetch>();

import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

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

import { requestMatrixJson, type MatrixQaFetchLike } from "./request.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

describe("requestMatrixJson", () => {

afterEach(() => {

vi.restoreAllMocks();

import { Buffer } from "node:buffer";

import { once } from "node:events";

import http, { type IncomingMessage, type ServerResponse } from "node:http";

import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

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

vi.mock("openclaw/plugin-sdk/core", async () => {

let signalRpcRequest: typeof import("./client.js").signalRpcRequest;

let streamSignalEvents: typeof import("./client.js").streamSignalEvents;

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

const servers: http.Server[] = [];

async function readRequestBody(req: IncomingMessage): Promise<string> {

import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

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

const transcodeAudioBufferToOpusMock = vi.hoisted(() => vi.fn());

import { buildXiaomiSpeechProvider } from "./speech-provider.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

describe("buildXiaomiSpeechProvider", () => {

const provider = buildXiaomiSpeechProvider();

import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

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

import { detectZaiEndpoint } from "./detect.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

type FetchResponse = { status: number; body?: unknown };

function makeFetch(map: Record<string, FetchResponse>) {

import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

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

const { resolvePinnedHostnameWithPolicyMock } = vi.hoisted(() => ({

import { deleteWebhook, getWebhookInfo, sendChatAction, sendPhoto, type ZaloFetch } from "./api.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

function createOkFetcher() {

return vi.fn<ZaloFetch>(async () => new Response(JSON.stringify({ ok: true, result: {} })));

}

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

import { MAX_TIMER_TIMEOUT_MS } from "../shared/number-coercion.js";

import { withEnvAsync } from "../test-utils/env.js";

import { withFetchPreconnect } from "../test-utils/fetch-mock.js";

import { scanOpenRouterModels } from "./model-scan.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

function createFetchFixture(payload: unknown): typeof fetch {

return withFetchPreconnect(

async () =>

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

import { MAX_TIMER_TIMEOUT_MS } from "../../shared/number-coercion.js";

import { createArmableStallWatchdog } from "./stall-watchdog.js";

function createTestWatchdog(

vi.useRealTimers();

}

});

it("caps oversized timeout and check interval values before scheduling", async () => {

vi.useFakeTimers();

vi.setSystemTime(0);

try {

const onTimeout = vi.fn();

const intervalSpy = vi.spyOn(globalThis, "setInterval");

const watchdog = createArmableStallWatchdog({

label: "test-watchdog",

timeoutMs: Number.MAX_SAFE_INTEGER,

checkIntervalMs: Number.MAX_SAFE_INTEGER,

onTimeout,

});

watchdog.arm(0);

await vi.advanceTimersByTimeAsync(1);

expect(onTimeout).not.toHaveBeenCalled();

expect(intervalSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

watchdog.stop();

} finally {

vi.useRealTimers();

vi.restoreAllMocks();

}

});

});

import type { RuntimeEnv } from "../../runtime.js";

import { resolveTimerTimeoutMs } from "../../shared/number-coercion.js";

export type StallWatchdogTimeoutMeta = {

idleMs: number;

runtime?: RuntimeEnv;

onTimeout: (meta: StallWatchdogTimeoutMeta) => void;

}): ArmableStallWatchdog {

const timeoutMs = Math.max(1, Math.floor(params.timeoutMs));

const checkIntervalMs = Math.max(

const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);

const defaultCheckIntervalMs = Math.min(5_000, Math.max(250, timeoutMs / 6));

const checkIntervalMs = resolveTimerTimeoutMs(

params.checkIntervalMs,

defaultCheckIntervalMs,

100,

Math.floor(params.checkIntervalMs ?? Math.min(5_000, Math.max(250, timeoutMs / 6))),

);

let armed = false;

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

import { MAX_TIMER_TIMEOUT_MS } from "../shared/number-coercion.js";

import { probeGatewayUrl, probeLocalCommand } from "./probes.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

describe("crestodian probes", () => {

afterEach(() => {

vi.restoreAllMocks();