open-multi-agent-kit 0.91.0 → 0.92.0

package/examples/extensions/subagent/deadline-profile-store.test.ts

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { DeadlineProfileStore } from "./deadline-profile-store.ts";
+
+const cleanupPaths: string[] = [];
+
+afterEach(async () => {
+	await Promise.all(cleanupPaths.splice(0).map((entry) => fs.promises.rm(entry, { force: true, recursive: true })));
+});
+
+describe("DeadlineProfileStore", () => {
+	it("persists provider/model cutoff history across dispatcher processes", async () => {
+		const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-deadline-profile-"));
+		cleanupPaths.push(dir);
+		const filePath = path.join(dir, "profiles.json");
+		const first = new DeadlineProfileStore(filePath);
+		await first.record({
+			provider: "openai-codex",
+			model: "gpt-5.6",
+			outcome: "cutoff",
+			elapsedMs: 500,
+			estimatedTokens: 100,
+			workUnits: 2,
+		});
+
+		const reloaded = new DeadlineProfileStore(filePath);
+		expect(await reloaded.profileFor("openai-codex", "gpt-5.6")).toMatchObject({ samples: 1, cutoffs: 1 });
+	});
+
+	it("serializes concurrent samples without losing updates", async () => {
+		const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-deadline-concurrent-"));
+		cleanupPaths.push(dir);
+		const filePath = path.join(dir, "profiles.json");
+		const stores = [new DeadlineProfileStore(filePath), new DeadlineProfileStore(filePath)];
+		await Promise.all(
+			Array.from({ length: 8 }, (_, index) =>
+				stores[index % stores.length].record({
+					provider: "anthropic",
+					model: "claude-sonnet",
+					outcome: "completed",
+					elapsedMs: 100 + index,
+					estimatedTokens: 10,
+					workUnits: 1,
+				}),
+			),
+		);
+
+		const reloaded = new DeadlineProfileStore(filePath);
+		expect(await reloaded.profileFor("anthropic", "claude-sonnet")).toMatchObject({ samples: 8, completions: 8 });
+	});
+
+	it("recovers from malformed history without exposing untyped data", async () => {
+		const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-deadline-corrupt-"));
+		cleanupPaths.push(dir);
+		const filePath = path.join(dir, "profiles.json");
+		await fs.promises.writeFile(filePath, "{not-json", "utf8");
+		const store = new DeadlineProfileStore(filePath);
+
+		expect(await store.profileFor("unknown", "default")).toBeUndefined();
+		await store.record({
+			provider: "unknown",
+			model: "default",
+			outcome: "failed",
+			elapsedMs: 20,
+			estimatedTokens: 5,
+			workUnits: 1,
+		});
+		expect(JSON.parse(await fs.promises.readFile(filePath, "utf8"))).toMatchObject({ version: 1 });
+	});
+});

package/examples/extensions/subagent/deadline-profile-store.ts

@@ -0,0 +1,172 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+	type DeadlineProfile,
+	type DeadlineProfileDb,
+	type DeadlineProfileSample,
+	getDeadlineProfile,
+	updateDeadlineProfiles,
+} from "./deadline-budget.ts";
+
+const MAX_PROFILE_FILE_BYTES = 1024 * 1024;
+const MAX_PROFILE_ENTRIES = 1_000;
+const LOCK_RETRY_COUNT = 200;
+const LOCK_RETRY_MS = 10;
+const STALE_LOCK_MS = 30_000;
+
+export class DeadlineProfileLockError extends Error {
+	constructor(filePath: string) {
+		super(`Timed out acquiring deadline profile lock for ${filePath}`);
+		this.name = "DeadlineProfileLockError";
+	}
+}
+
+export class DeadlineProfileStore {
+	private readonly filePath: string;
+	private db: DeadlineProfileDb = emptyDb();
+	private mutationTail: Promise<void> = Promise.resolve();
+
+	constructor(filePath: string) {
+		this.filePath = filePath;
+	}
+
+	async profileFor(provider: string, model: string): Promise<DeadlineProfile | undefined> {
+		await this.mutationTail;
+		this.db = await readDb(this.filePath);
+		return getDeadlineProfile(this.db, provider, model);
+	}
+
+	async record(sample: DeadlineProfileSample): Promise<DeadlineProfile> {
+		let recorded: DeadlineProfile | undefined;
+		const operation = this.mutationTail.then(async () => {
+			await withProfileLock(this.filePath, async () => {
+				this.db = updateDeadlineProfiles(await readDb(this.filePath), sample);
+				recorded = getDeadlineProfile(this.db, sample.provider, sample.model);
+				if (recorded === undefined) throw new Error("Deadline profile update did not produce a profile");
+				await writeAtomically(this.filePath, JSON.stringify(this.db));
+			});
+		});
+		this.mutationTail = operation.catch(() => undefined);
+		await operation;
+		if (recorded === undefined) throw new Error("Deadline profile update did not complete");
+		return recorded;
+	}
+}
+
+async function withProfileLock<T>(filePath: string, operation: () => Promise<T>): Promise<T> {
+	const lockPath = `${filePath}.lock`;
+	await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+	for (let attempt = 0; attempt < LOCK_RETRY_COUNT; attempt++) {
+		try {
+			await fs.promises.mkdir(lockPath);
+			try {
+				return await operation();
+			} finally {
+				await fs.promises.rm(lockPath, { recursive: true, force: true });
+			}
+		} catch (error) {
+			if (!isAlreadyExists(error)) throw error;
+			await removeStaleLock(lockPath);
+			await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+		}
+	}
+	throw new DeadlineProfileLockError(filePath);
+}
+
+async function removeStaleLock(lockPath: string): Promise<void> {
+	try {
+		const stats = await fs.promises.stat(lockPath);
+		if (Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
+			await fs.promises.rm(lockPath, { recursive: true, force: true });
+		}
+	} catch {
+		return;
+	}
+}
+
+function isAlreadyExists(error: unknown): boolean {
+	return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+
+async function readDb(filePath: string): Promise<DeadlineProfileDb> {
+	try {
+		const handle = await fs.promises.open(filePath, "r");
+		try {
+			const stats = await handle.stat();
+			if (stats.size > MAX_PROFILE_FILE_BYTES) return emptyDb();
+			return parseDb(JSON.parse(await handle.readFile("utf8")));
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		return emptyDb();
+	}
+}
+
+async function writeAtomically(filePath: string, content: string): Promise<void> {
+	await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+	const tempPath = `${filePath}.${process.pid}.${process.hrtime.bigint()}.tmp`;
+	try {
+		await fs.promises.writeFile(tempPath, content, { encoding: "utf8", mode: 0o600 });
+		await fs.promises.rename(tempPath, filePath);
+	} finally {
+		await fs.promises.rm(tempPath, { force: true });
+	}
+}
+
+function parseDb(value: unknown): DeadlineProfileDb {
+	if (!isRecord(value) || value.version !== 1 || !isRecord(value.profiles)) return emptyDb();
+	const profiles: Record<string, DeadlineProfile> = Object.create(null);
+	for (const [key, raw] of Object.entries(value.profiles).slice(0, MAX_PROFILE_ENTRIES)) {
+		const parsed = parseProfile(raw);
+		if (parsed !== undefined) profiles[key] = parsed;
+	}
+	return { version: 1, profiles };
+}
+
+function parseProfile(value: unknown): DeadlineProfile | undefined {
+	if (!isRecord(value) || typeof value.provider !== "string" || typeof value.model !== "string") return undefined;
+	const samples = readCount(value.samples);
+	const completions = readCount(value.completions);
+	const cutoffs = readCount(value.cutoffs);
+	const aborts = readCount(value.aborts);
+	const failures = readCount(value.failures);
+	const ewmaElapsedMs = readCount(value.ewmaElapsedMs);
+	const ewmaMsPerWorkUnit = readCount(value.ewmaMsPerWorkUnit);
+	if ([samples, completions, cutoffs, aborts, failures, ewmaElapsedMs, ewmaMsPerWorkUnit].includes(undefined)) {
+		return undefined;
+	}
+	return {
+		provider: value.provider.slice(0, 256),
+		model: value.model.slice(0, 256),
+		samples: samples ?? 0,
+		completions: completions ?? 0,
+		cutoffs: cutoffs ?? 0,
+		aborts: aborts ?? 0,
+		failures: failures ?? 0,
+		ewmaElapsedMs: ewmaElapsedMs ?? 0,
+		ewmaMsPerWorkUnit: ewmaMsPerWorkUnit ?? 0,
+		completedDurationsMs: readDurations(value.completedDurationsMs),
+		cutoffDurationsMs: readDurations(value.cutoffDurationsMs),
+	};
+}
+
+function readCount(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}
+
+function readDurations(value: unknown): number[] {
+	if (!Array.isArray(value)) return [];
+	return value
+		.map(readCount)
+		.filter((duration): duration is number => duration !== undefined && duration > 0)
+		.slice(-24);
+}
+
+function emptyDb(): DeadlineProfileDb {
+	return { version: 1, profiles: {} };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/examples/extensions/subagent/fixtures/fake-omk-json.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+process.stdout.write(
+	`${JSON.stringify({
+		type: "message_end",
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text: "fixture subagent completed" }],
+			provider: "fixture-provider",
+			model: "fixture-model",
+		},
+	})}\n`,
+);

package/examples/extensions/subagent/fixtures/hanging-process-tree.mjs

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+
+const normalOrphan = process.argv.includes("--normal-orphan");
+
+if (!process.argv.includes("--parent-exits") && !normalOrphan) {
+	process.on("SIGTERM", () => {
+		// Exercise the managed runner's SIGKILL escalation path.
+	});
+}
+
+// The grandchild ignores SIGTERM so the managed runner must escalate to
+// SIGKILL. It writes "ready" on its stdout (piped back to this parent) only
+// AFTER installing its SIGTERM handler. The parent waits for that signal
+// before exiting or settling into its keep-alive loop, so the runner never
+// signals the process group while the grandchild is still in its startup
+// window (a fresh `node -e` process needs ~50-100ms before its first JS line
+// runs). Without this handshake a SIGTERM can land before the handler is
+// installed, killing the grandchild via the default handler and making the
+// SIGKILL escalation (cleanup.killSent) a timing race.
+const grandchild = spawn(
+	process.execPath,
+	["-e", "process.on('SIGTERM', () => {}); process.stdout.write('ready'); setInterval(() => {}, 1000)"],
+	{
+		stdio: ["ignore", "pipe", "ignore"],
+	},
+);
+
+process.stdout.write(`${JSON.stringify({ grandchildPid: grandchild.pid })}\n`);
+
+const startMain = () => {
+	if (normalOrphan) setTimeout(() => process.exit(0), 20);
+	else setInterval(() => {}, 1000);
+};
+
+let started = false;
+grandchild.stdout.on("data", () => {
+	if (started) return;
+	started = true;
+	startMain();
+});