openclaw/dist/background-work-DAaUk-Kp.js

Multi-channel AI gateway with extensible messaging integrations

import { s as getGatewayRestartDrainSignal } from "./gateway-work-admission-R1IpuDim.js";
import { _ as getGroupRegistry, a as getCommandLaneSnapshot, p as publishLaneConfiguration, r as enqueueCommandInLane, v as getLaneGroup } from "./command-queue-C3Fv2rcU.js";
//#region src/process/background-work.ts
const BACKGROUND_WORK_GROUP = "background-work";
const BACKGROUND_WORK_MAX_CONCURRENT = 3;
/** Register a stable core/plugin owner key, never a session or run identifier.
* Only leaf work belongs here: a coordinator holding capacity must not await
* another background task, which could need the same occupied capacity. */
function createBackgroundWorkOwner(params) {
	const owner = params.owner.trim();
	if (!owner) throw new Error("Background work requires a stable owner key");
	if (!Number.isInteger(params.maxConcurrent) || params.maxConcurrent < 1 || params.maxConcurrent > BACKGROUND_WORK_MAX_CONCURRENT) throw new Error(`Background owner concurrency must be between 1 and ${BACKGROUND_WORK_MAX_CONCURRENT}`);
	const lane = `background:${owner}`;
	const register = () => {
		if (getLaneGroup(lane)) {
			if (getCommandLaneSnapshot(lane).maxConcurrent !== params.maxConcurrent) throw new Error(`Background owner ${owner} is already registered with different concurrency`);
		} else {
			const group = getGroupRegistry().groups.get(BACKGROUND_WORK_GROUP);
			publishLaneConfiguration({
				lanes: { [lane]: params.maxConcurrent },
				groups: { [BACKGROUND_WORK_GROUP]: {
					budget: BACKGROUND_WORK_MAX_CONCURRENT,
					members: [...group?.members ?? [], lane]
				} }
			});
		}
		return lane;
	};
	return {
		get lane() {
			return register();
		},
		enqueue(task, options) {
			const restartSignal = getGatewayRestartDrainSignal();
			const signal = options?.abortSignal ? AbortSignal.any([restartSignal, options.abortSignal]) : restartSignal;
			return enqueueCommandInLane(register(), () => {
				signal.throwIfAborted();
				return task(signal);
			}, {
				...options,
				priority: "background",
				abortSignal: signal
			});
		}
	};
}
function isBackgroundWorkLane(lane) {
	return getLaneGroup(lane)?.group === BACKGROUND_WORK_GROUP;
}
function getBackgroundWorkSnapshot() {
	const members = [...getGroupRegistry().groups.get(BACKGROUND_WORK_GROUP)?.members ?? []].map((lane) => getCommandLaneSnapshot(lane));
	const activeCount = members.reduce((sum, member) => sum + member.activeCount, 0);
	return {
		lane: "background",
		activeCount,
		queuedCount: members.reduce((sum, member) => sum + member.queuedCount, 0),
		maxConcurrent: BACKGROUND_WORK_MAX_CONCURRENT,
		draining: members.some((member) => member.draining),
		generation: Math.max(0, ...members.map((member) => member.generation)),
		blockedBy: activeCount >= BACKGROUND_WORK_MAX_CONCURRENT ? "group-budget" : members.some((member) => member.queuedCount > 0 && member.blockedBy === "lane") ? "lane" : null
	};
}
//#endregion
export { getBackgroundWorkSnapshot as n, isBackgroundWorkLane as r, createBackgroundWorkOwner as t };