openclaw/dist/session-active-runs-CCNuJW7B.js

Multi-channel AI gateway with extensible messaging integrations

import { n as normalizeAgentId } from "./agent-id-CeT3w4ap.js";
import { O as parseAgentSessionKey } from "./session-key-BnWWjqNc.js";
import { t as buildProjectedAgentRunIndex, x as resolveProjectedAgentRunProgressState } from "./agent-run-registry-CKYKdfNd.js";
import { T as resolveEmbeddedAgentRunProgressState } from "./runs-Cb42qain.js";
import { P as isSwarmRunWaitingForCapacity, d as isSubagentRunLive, f as isSubagentRunQueued, o as getLatestLiveSubagentRunByChildSessionKey } from "./subagent-registry-read-DeFf_9Nz.js";
import { r as resolveChatRunOwnerAgentId } from "./chat-run-owner-DPtcuc7L.js";
import { t as isAgentRunWaitingForCapacity } from "./agent-run-capacity-wait-uKhiNyQF.js";
//#region src/gateway/server-methods/session-active-runs.ts
function collectTrackedActiveSessionRuns(context, includeTerminalPersistence = false) {
	const runs = [];
	if (!(context.chatAbortControllers instanceof Map)) return runs;
	for (const [runId, active] of context.chatAbortControllers) {
		const terminalPersistence = includeTerminalPersistence && active.projectSessionActive === false && active.projectSessionTerminalPending === true;
		if ((active.projectSessionActive !== false || terminalPersistence) && active.controlUiVisible !== false) {
			const sessionKey = active.sessionKey?.trim();
			const sessionId = active.sessionId?.trim();
			if (!sessionKey && !sessionId) continue;
			runs.push({
				runId,
				...sessionKey ? { sessionKey } : {},
				...sessionId ? { sessionId } : {},
				agentId: typeof active.agentId === "string" ? normalizeAgentId(active.agentId) : void 0,
				...terminalPersistence ? { terminalPersistence: true } : {}
			});
		}
	}
	return runs;
}
function isTrackedActiveSessionRunForKey(active, key, agentId, defaultAgentId) {
	if (!active.sessionKey || active.sessionKey !== key) return false;
	const requestedAgentId = resolveChatRunOwnerAgentId({
		agentId,
		sessionKey: key,
		defaultAgentId
	});
	if (!requestedAgentId) return false;
	const activeAgentId = resolveChatRunOwnerAgentId({
		agentId: active.agentId,
		sessionKey: active.sessionKey,
		defaultAgentId
	});
	return activeAgentId ? normalizeAgentId(activeAgentId) === normalizeAgentId(requestedAgentId) : false;
}
function isTrackedActiveSessionRunForSessionId(active, sessionId, agentId, defaultAgentId) {
	if (active.sessionId !== sessionId) return false;
	const requestedAgentId = agentId ?? defaultAgentId;
	if (!requestedAgentId) return false;
	return resolveChatRunOwnerAgentId({
		agentId: active.agentId,
		sessionKey: active.sessionKey,
		defaultAgentId
	}) === normalizeAgentId(requestedAgentId);
}
function hasRegisteredChatRunForSessionKey(params) {
	const controllers = params.context.chatAbortControllers;
	return controllers instanceof Map && [...controllers.values()].some((active) => isTrackedActiveSessionRunForKey(active, params.sessionKey, params.agentId, params.defaultAgentId));
}
/** Returns true when either requested or canonical session key has a visible active run. */
function hasTrackedActiveSessionRun(params) {
	return collectTrackedActiveSessionRuns(params.context).some((active) => !params.excludeRunIds?.has(active.runId) && (isTrackedActiveSessionRunForKey(active, params.canonicalKey, params.agentId, params.defaultAgentId) || isTrackedActiveSessionRunForKey(active, params.requestedKey, params.agentId, params.defaultAgentId)));
}
function resolveVisibleActiveSessionRunState(params) {
	const sessionId = params.sessionId?.trim();
	const resolvedAgentId = params.agentId ?? parseAgentSessionKey(params.canonicalKey)?.agentId ?? parseAgentSessionKey(params.requestedKey)?.agentId;
	const matchesRequestedSession = (active) => isTrackedActiveSessionRunForKey(active, params.canonicalKey, resolvedAgentId, params.defaultAgentId) || isTrackedActiveSessionRunForKey(active, params.requestedKey, resolvedAgentId, params.defaultAgentId) || sessionId !== void 0 && isTrackedActiveSessionRunForSessionId(active, sessionId, resolvedAgentId, params.defaultAgentId);
	const matchingTrackedRuns = (params.trackedActiveRuns ?? collectTrackedActiveSessionRuns(params.context, params.includeTerminalPersistence)).filter(matchesRequestedSession);
	const hasTerminalPersistence = matchingTrackedRuns.some((active) => active.terminalPersistence);
	const runIds = matchingTrackedRuns.filter((active) => !active.terminalPersistence).map((active) => active.runId);
	const directSubagent = getLatestLiveSubagentRunByChildSessionKey(params.canonicalKey);
	const matchesDirectSubagentSession = Boolean(directSubagent && isTrackedActiveSessionRunForKey({ sessionKey: directSubagent.childSessionKey }, params.canonicalKey, resolvedAgentId, params.defaultAgentId));
	const hasLiveSubagent = matchesDirectSubagentSession && isSubagentRunLive(directSubagent);
	const hasQueuedSubagent = matchesDirectSubagentSession && isSubagentRunQueued(directSubagent);
	if ((hasLiveSubagent || hasQueuedSubagent) && directSubagent && !runIds.includes(directSubagent.runId)) runIds.push(directSubagent.runId);
	const subagentCapacityWait = (hasLiveSubagent || hasQueuedSubagent) && directSubagent && (isAgentRunWaitingForCapacity(directSubagent.runId) || isSwarmRunWaitingForCapacity(directSubagent.schedulerSlotId ?? directSubagent.runId, directSubagent));
	const projectedRunState = resolveProjectedAgentRunProgressState({
		sessionKeys: [params.requestedKey, params.canonicalKey],
		...sessionId ? { sessionId } : {},
		...resolvedAgentId ? { agentId: resolvedAgentId } : {},
		...params.defaultAgentId ? { defaultAgentId: params.defaultAgentId } : {},
		...params.projectedAgentRunIndex ? { index: params.projectedAgentRunIndex } : {}
	});
	const embeddedRunState = sessionId === void 0 ? void 0 : resolveEmbeddedAgentRunProgressState(sessionId);
	const running = (hasLiveSubagent || hasQueuedSubagent) && !subagentCapacityWait || matchingTrackedRuns.some((active) => !isAgentRunWaitingForCapacity(active.runId)) || projectedRunState === "running" || embeddedRunState === "running";
	const active = running || hasTerminalPersistence || runIds.length > 0 || embeddedRunState === "queued" || projectedRunState === "queued";
	return {
		active,
		...projectedRunState !== "running" && projectedRunState !== "queued" && embeddedRunState === void 0 && !hasTerminalPersistence ? { runIds: runIds.toSorted() } : {},
		...active && !running && (subagentCapacityWait || projectedRunState === "queued" || projectedRunState === "capacity-wait") ? { status: "queued" } : {}
	};
}
/** Request-scoped index; candidate selection must not rescan all controllers per row. */
function createVisibleActiveSessionRunProjector(context) {
	const byKey = /* @__PURE__ */ new Map();
	const byId = /* @__PURE__ */ new Map();
	for (const run of collectTrackedActiveSessionRuns(context)) for (const [index, key] of [[byKey, run.sessionKey], [byId, run.sessionId]]) if (key) {
		const entries = index.get(key) ?? [];
		entries.push(run);
		index.set(key, entries);
	}
	const projectedAgentRunIndex = buildProjectedAgentRunIndex();
	return (params) => resolveVisibleActiveSessionRunState({
		...params,
		context,
		projectedAgentRunIndex,
		trackedActiveRuns: [.../* @__PURE__ */ new Set([
			...byKey.get(params.canonicalKey) ?? [],
			...byKey.get(params.requestedKey) ?? [],
			...byId.get(params.sessionId?.trim() ?? "") ?? []
		])]
	});
}
//#endregion
export { resolveVisibleActiveSessionRunState as i, hasRegisteredChatRunForSessionKey as n, hasTrackedActiveSessionRun as r, createVisibleActiveSessionRunProjector as t };