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

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

import { createTypingCallbacks } from "./typing.js";

type TypingCallbackOverrides = Partial<Parameters<typeof createTypingCallbacks>[0]>;

});

});

it("clamps oversized keepalive intervals before arming timers", async () => {

await withFakeTimers(async () => {

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

const { callbacks } = createTypingHarness({

keepaliveIntervalMs: Number.MAX_SAFE_INTEGER,

});

await callbacks.onReplyStart();

await flushMicrotasks();

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

callbacks.onCleanup?.();

});

});

it("does not restart keepalive when breaker trips on initial start", async () => {

await withFakeTimers(async () => {

const { start, onStartError, callbacks } = createTypingHarness({

});

});

it("clamps oversized TTLs before arming timers", async () => {

await withFakeTimers(async () => {

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

const { callbacks } = createTypingHarness({

maxDurationMs: Number.MAX_SAFE_INTEGER,

});

await callbacks.onReplyStart();

await flushMicrotasks();

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

callbacks.onCleanup?.();

});

});

it("resets TTL timer on restart after idle", async () => {

await withFakeTimers(async () => {

const { stop, callbacks } = createTypingHarness({ maxDurationMs: 10_000 });

import { parseFiniteNumber } from "@openclaw/normalization-core/number-coercion";

import {

parseFiniteNumber,

resolveTimerTimeoutMs,

} from "@openclaw/normalization-core/number-coercion";

import { createTypingKeepaliveLoop } from "./typing-lifecycle.js";

import { createTypingStartGuard } from "./typing-start-guard.js";

}

function resolveKeepaliveIntervalMs(value: number | undefined): number {

const parsed = parseFiniteNumber(value);

return parsed === undefined ? 3_000 : Math.floor(parsed);

return resolveTimerTimeoutMs(value, 3_000, 0);

}

function resolveDurationMsOption(value: number | undefined, fallback: number): number {

const parsed = parseFiniteNumber(value);

return parsed === undefined ? fallback : Math.floor(parsed);

return resolveTimerTimeoutMs(value, fallback, 0);

}

export function createTypingCallbacks(params: CreateTypingCallbacksParams): TypingCallbacks {