const agentRunStarts = new Map<string, number>();

const pendingAgentRunErrors = new Map<string, PendingAgentRunError>();

const pendingAgentRunTimeouts = new Map<string, PendingAgentRunTerminal>();

const agentRunWaiterCounts = new Map<string, number>();

let agentRunListenerStarted = false;

type AgentRunSnapshot = {

return agentRunCache.get(runId);

}

function addAgentRunWaiter(runId: string): () => void {

agentRunWaiterCounts.set(runId, (agentRunWaiterCounts.get(runId) ?? 0) + 1);

let removed = false;

return () => {

if (removed) {

return;

}

removed = true;

const nextCount = (agentRunWaiterCounts.get(runId) ?? 1) - 1;

if (nextCount <= 0) {

agentRunWaiterCounts.delete(runId);

return;

}

agentRunWaiterCounts.set(runId, nextCount);

};

}

export async function waitForAgentJob(params: {

runId: string;

timeoutMs: number;

let pendingErrorTimer: NodeJS.Timeout | undefined;

let pendingTimeoutTimer: NodeJS.Timeout | undefined;

let onAbort: (() => void) | undefined;

let removeWaiter = () => {};

const clearPendingErrorTimer = () => {

if (!pendingErrorTimer) {

clearPendingErrorTimer();

clearPendingTimeoutTimer();

unsubscribe();

removeWaiter();

if (onAbort) {

signal?.removeEventListener("abort", onAbort);

}

recordAgentRunSnapshot(snapshot);

finish(snapshot);

});

removeWaiter = addAgentRunWaiter(runId);

const timer = setSafeTimeout(() => finish(null), timeoutMs);

onAbort = () => finish(null);

}

ensureAgentRunListener();

export const __testing = {

getWaiterCount(runId?: string): number {

if (runId) {

return agentRunWaiterCounts.get(runId) ?? 0;

}

let total = 0;

for (const count of agentRunWaiterCounts.values()) {

total += count;

}

return total;

},

resetWaiters(): void {

agentRunWaiterCounts.clear();

},

};