import type { OpenClawConfig } from "../config/types.openclaw.js";

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

import {

DEFAULT_MODEL_CATALOG_BROWSE_TIMEOUT_MS,

loadModelCatalogForBrowse,

restoreModelCatalogBrowseTestDeps,

setModelCatalogBrowseTestDeps,

} from "./model-catalog-browse.js";

import type { ModelCatalogEntry } from "./model-catalog.types.js";

const DEFAULT_MODEL_CATALOG_BROWSE_TIMEOUT_MS = 750;

const readOnlyCatalog: ModelCatalogEntry[] = [

{ id: "gpt-readonly", name: "GPT Readonly", provider: "openai" },

];

vi.clearAllTimers();

vi.restoreAllMocks();

vi.useRealTimers();

restoreModelCatalogBrowseTestDeps();

});

it("uses the read-only catalog for default browse views", async () => {

});

it("returns an empty catalog when read-only catalog loading times out with provider wildcards", async () => {

vi.useFakeTimers();

const onTimeout = vi.fn();

const timeoutHandle = { unref: vi.fn() } as unknown as NodeJS.Timeout;

const clearTimeout = vi.fn();

setModelCatalogBrowseTestDeps({

setTimeout: vi.fn((callback: () => void) => {

queueMicrotask(callback);

return timeoutHandle;

}) as unknown as typeof globalThis.setTimeout,

clearTimeout: clearTimeout as unknown as typeof globalThis.clearTimeout,

});

const loadCatalog = vi.fn(() => new Promise<ModelCatalogEntry[]>(() => {}));

const resultPromise = loadModelCatalogForBrowse({

onTimeout,

});

await vi.advanceTimersByTimeAsync(5);

await expect(resultPromise).resolves.toEqual([]);

expect(onTimeout).toHaveBeenCalledExactlyOnceWith(5);

expect(timeoutHandle["unref"]).toHaveBeenCalledOnce();

expect(clearTimeout).toHaveBeenCalledExactlyOnceWith(timeoutHandle);

});

it("uses the default timeout when timeoutMs is non-finite", async () => {

const onTimeout = vi.fn();

const timeoutHandle = { unref: vi.fn() } as unknown as NodeJS.Timeout;

const setTimeout = vi.fn(() => timeoutHandle);

const clearTimeout = vi.fn();

setModelCatalogBrowseTestDeps({

setTimeout: setTimeout as unknown as typeof globalThis.setTimeout,

clearTimeout: clearTimeout as unknown as typeof globalThis.clearTimeout,

});

const setTimeout = vi.spyOn(globalThis, "setTimeout");

const clearTimeout = vi.spyOn(globalThis, "clearTimeout");

const loadCatalog = vi.fn(async () => readOnlyCatalog);

const resultPromise = loadModelCatalogForBrowse({

expect.any(Function),

DEFAULT_MODEL_CATALOG_BROWSE_TIMEOUT_MS,

);

expect(clearTimeout).toHaveBeenCalledExactlyOnceWith(timeoutHandle);

expect(clearTimeout).toHaveBeenCalledOnce();

expect(onTimeout).not.toHaveBeenCalled();

});

it("caps oversized browse timeouts before scheduling the fallback timer", async () => {

const timeoutHandle = { unref: vi.fn() } as unknown as NodeJS.Timeout;

const setTimeout = vi.fn(() => timeoutHandle);

const clearTimeout = vi.fn();

setModelCatalogBrowseTestDeps({

setTimeout: setTimeout as unknown as typeof globalThis.setTimeout,

clearTimeout: clearTimeout as unknown as typeof globalThis.clearTimeout,

});

const setTimeout = vi.spyOn(globalThis, "setTimeout");

const clearTimeout = vi.spyOn(globalThis, "clearTimeout");

const loadCatalog = vi.fn(async () => readOnlyCatalog);

const resultPromise = loadModelCatalogForBrowse({

await expect(resultPromise).resolves.toBe(readOnlyCatalog);

expect(setTimeout).toHaveBeenCalledExactlyOnceWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

expect(clearTimeout).toHaveBeenCalledExactlyOnceWith(timeoutHandle);

expect(clearTimeout).toHaveBeenCalledOnce();

});

});