const password = process.env.OPENWEBUI_ADMIN_PASSWORD ?? "";

const expectedNonce = process.env.OPENWEBUI_EXPECTED_NONCE ?? "";

const prompt = process.env.OPENWEBUI_PROMPT ?? "";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

const modelAttempts = readPositiveInt("OPENWEBUI_MODEL_ATTEMPTS", 72);

const modelRetryMs = readNonNegativeInt("OPENWEBUI_MODEL_RETRY_MS", 5000);

const fetchTimeoutMs = readPositiveInt("OPENWEBUI_FETCH_TIMEOUT_MS", 720000);

const controlTimeoutMs = readPositiveInt(

const modelRetryMs = readNonNegativeTimerMs("OPENWEBUI_MODEL_RETRY_MS", 5000);

const fetchTimeoutMs = readPositiveTimerMs("OPENWEBUI_FETCH_TIMEOUT_MS", 720000);

const controlTimeoutMs = readPositiveTimerMs(

"OPENWEBUI_CONTROL_TIMEOUT_MS",

Math.min(fetchTimeoutMs, 30000),

);

const chatTimeoutMs = readPositiveInt("OPENWEBUI_CHAT_TIMEOUT_MS", fetchTimeoutMs);

const chatTimeoutMs = readPositiveTimerMs("OPENWEBUI_CHAT_TIMEOUT_MS", fetchTimeoutMs);

const responseBodyMaxBytes = readPositiveInt("OPENWEBUI_RESPONSE_BODY_MAX_BYTES", 1024 * 1024);

const smokeMode =

process.env.OPENWEBUI_SMOKE_MODE ?? process.env.OPENCLAW_OPENWEBUI_SMOKE_MODE ?? "chat";

return parsed;

}

function clampTimerTimeoutMs(valueMs, minMs = 1) {

const min = Math.max(0, Math.floor(minMs));

const value = Number.isFinite(valueMs) ? valueMs : min;

return Math.min(Math.max(Math.floor(value), min), MAX_TIMER_TIMEOUT_MS);

}

function readPositiveTimerMs(name, fallback) {

return clampTimerTimeoutMs(readPositiveInt(name, fallback));

}

function readNonNegativeTimerMs(name, fallback) {

return clampTimerTimeoutMs(readNonNegativeInt(name, fallback), 0);

}

function createTimeoutError(label, timeoutMs) {

const error = new Error(`${label} timed out after ${timeoutMs}ms`);

error.code = "ETIMEDOUT";

return error;

}

async function withRequestTimeout(label, timeoutMs, run) {

const resolvedTimeoutMs = clampTimerTimeoutMs(timeoutMs);

const controller = new AbortController();

const timeoutError = createTimeoutError(label, timeoutMs);

const timeoutError = createTimeoutError(label, resolvedTimeoutMs);

let timer;

const timeoutPromise = new Promise((_, reject) => {

timer = setTimeout(() => {

controller.abort(timeoutError);

reject(timeoutError);

}, timeoutMs);

}, resolvedTimeoutMs);

timer.unref?.();

});

try {

function sleep(ms) {

return new Promise((resolve) => {

setTimeout(resolve, ms);

setTimeout(resolve, clampTimerTimeoutMs(ms, 0));

});

}