open-multi-agent-kit 0.95.1 → 0.96.0

package/examples/extensions/subagent/subagent-extension-smoke.test.ts

@@ -11,6 +11,7 @@ interface SmokeToolResult {
 }
 
 interface SmokeTool {
+	resolveTimeoutMs?(context: { thinkingLevel?: string }): number | undefined;
 	execute(
 		toolCallId: string,
 		params: unknown,
@@ -28,26 +29,31 @@ interface SmokeDetails {
 		readonly deadline?: { readonly outcome: string; readonly attempts: readonly unknown[] };
 	}[];
 	readonly executionBudget: {
+		readonly unbounded?: boolean;
 		readonly hardDeadlineMs: number;
 		readonly plannedShards: number;
 		readonly completedShards: number;
 		readonly resumeCount: number;
 	};
+	readonly graph?: { readonly waves: readonly (readonly string[])[]; readonly completedNodeIds: readonly string[] };
 }
 
 const cleanupPaths: string[] = [];
 const originalArgvEntry = process.argv[1];
 const originalAgentDir = process.env.OMK_CODING_AGENT_DIR;
+const originalExpectedModel = process.env.OMK_EXPECTED_MODEL;
 
 afterEach(async () => {
 	process.argv[1] = originalArgvEntry;
 	if (originalAgentDir === undefined) delete process.env.OMK_CODING_AGENT_DIR;
 	else process.env.OMK_CODING_AGENT_DIR = originalAgentDir;
+	if (originalExpectedModel === undefined) delete process.env.OMK_EXPECTED_MODEL;
+	else process.env.OMK_EXPECTED_MODEL = originalExpectedModel;
 	await Promise.all(cleanupPaths.splice(0).map((entry) => fs.promises.rm(entry, { recursive: true, force: true })));
 });
 
 describe("subagent extension registration and spawn smoke", () => {
-	it("runs the registered tool through the managed process boundary without a provider API", async () => {
+	it("inherits the selected session model across the managed process boundary", async () => {
 		const cwd = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-subagent-extension-smoke-"));
 		cleanupPaths.push(cwd);
 		const projectAgentsDir = path.join(cwd, ".omk", "agents");
@@ -61,6 +67,7 @@ describe("subagent extension registration and spawn smoke", () => {
 		);
 		process.argv[1] = path.join(import.meta.dirname, "fixtures", "fake-omk-json.mjs");
 		process.env.OMK_CODING_AGENT_DIR = agentHome;
+		process.env.OMK_EXPECTED_MODEL = "openai-codex/session-selected-model";
 
 		let registered: unknown;
 		const api = {
@@ -84,7 +91,7 @@ describe("subagent extension registration and spawn smoke", () => {
 			},
 			new AbortController().signal,
 			undefined,
-			{ cwd, hasUI: false },
+			{ cwd, hasUI: false, model: { provider: "openai-codex", id: "session-selected-model" } },
 		);
 		const details = result.details as SmokeDetails;
 
@@ -105,6 +112,164 @@ describe("subagent extension registration and spawn smoke", () => {
 		});
 		expect(await fs.promises.stat(path.join(agentHome, "state", "subagent-deadline-profiles.json"))).toBeDefined();
 	}, 120_000);
+
+	it("prefers an explicit agent model over the inherited session model", async () => {
+		const cwd = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-subagent-model-smoke-"));
+		cleanupPaths.push(cwd);
+		const projectAgentsDir = path.join(cwd, ".omk", "agents");
+		const agentHome = path.join(cwd, "agent-home");
+		await fs.promises.mkdir(projectAgentsDir, { recursive: true });
+		await fs.promises.mkdir(agentHome, { recursive: true });
+		await fs.promises.writeFile(
+			path.join(projectAgentsDir, "fixture-agent.md"),
+			"---\nname: fixture-agent\ndescription: Offline extension smoke fixture\nmodel: agent-pinned-model\n---\nReturn the fixture result.\n",
+			"utf8",
+		);
+		process.argv[1] = path.join(import.meta.dirname, "fixtures", "fake-omk-json.mjs");
+		process.env.OMK_CODING_AGENT_DIR = agentHome;
+		process.env.OMK_EXPECTED_MODEL = "agent-pinned-model";
+
+		let registered: unknown;
+		const api = {
+			registerTool(tool: unknown) {
+				registered = tool;
+			},
+		} as unknown as ExtensionAPI;
+		const { default: registerSubagent } = await import("./index.ts");
+		registerSubagent(api);
+		if (!isSmokeTool(registered)) throw new Error("subagent tool was not registered");
+
+		const result = await registered.execute(
+			"fixture-model-call",
+			{
+				agent: "fixture-agent",
+				task: "Run the pinned-model fixture.",
+				agentScope: "project",
+				confirmProjectAgents: false,
+			},
+			new AbortController().signal,
+			undefined,
+			{ cwd, hasUI: false, model: { id: "session-selected-model" } },
+		);
+
+		expect(result.isError).not.toBe(true);
+		expect(result.content[0]?.text).toContain("fixture subagent completed");
+	}, 120_000);
+
+	it("runs validated graph waves and records the graph plan", async () => {
+		const cwd = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-subagent-graph-smoke-"));
+		cleanupPaths.push(cwd);
+		const projectAgentsDir = path.join(cwd, ".omk", "agents");
+		const agentHome = path.join(cwd, "agent-home");
+		await fs.promises.mkdir(projectAgentsDir, { recursive: true });
+		await fs.promises.mkdir(agentHome, { recursive: true });
+		await fs.promises.writeFile(
+			path.join(projectAgentsDir, "fixture-agent.md"),
+			"---\nname: fixture-agent\ndescription: Offline extension smoke fixture\n---\nReturn the fixture result.\n",
+			"utf8",
+		);
+		process.argv[1] = path.join(import.meta.dirname, "fixtures", "fake-omk-json.mjs");
+		process.env.OMK_CODING_AGENT_DIR = agentHome;
+
+		let registered: unknown;
+		const api = {
+			registerTool(tool: unknown) {
+				registered = tool;
+			},
+		} as unknown as ExtensionAPI;
+		const { default: registerSubagent } = await import("./index.ts");
+		registerSubagent(api);
+		if (!isSmokeTool(registered)) throw new Error("subagent tool was not registered");
+
+		const result = await registered.execute(
+			"fixture-graph-call",
+			{
+				graph: [
+					{ id: "research-a", agent: "fixture-agent", task: "Research A." },
+					{ id: "research-b", agent: "fixture-agent", task: "Research B." },
+					{
+						id: "synthesize",
+						agent: "fixture-agent",
+						task: "Synthesize:\n{dependencies}",
+						dependsOn: ["research-a", "research-b"],
+					},
+				],
+				agentScope: "project",
+				confirmProjectAgents: false,
+				executionBudgetMs: 120_000,
+			},
+			new AbortController().signal,
+			undefined,
+			{ cwd, hasUI: false },
+		);
+		const details = result.details as SmokeDetails;
+
+		expect(result.isError).not.toBe(true);
+		expect(details.mode).toBe("graph");
+		expect(details.results).toHaveLength(3);
+		expect(details.graph).toEqual({
+			waves: [["research-a", "research-b"], ["synthesize"]],
+			completedNodeIds: ["research-a", "research-b", "synthesize"],
+		});
+	}, 120_000);
+
+	it("honors an explicit internal execution budget in Ultra while removing parallel limits", async () => {
+		const cwd = await fs.promises.mkdtemp(path.join(os.tmpdir(), "omk-subagent-ultra-smoke-"));
+		cleanupPaths.push(cwd);
+		const projectAgentsDir = path.join(cwd, ".omk", "agents");
+		const agentHome = path.join(cwd, "agent-home");
+		await fs.promises.mkdir(projectAgentsDir, { recursive: true });
+		await fs.promises.mkdir(agentHome, { recursive: true });
+		await fs.promises.writeFile(
+			path.join(projectAgentsDir, "fixture-agent.md"),
+			"---\nname: fixture-agent\ndescription: Offline extension smoke fixture\n---\nReturn the fixture result.\n",
+			"utf8",
+		);
+		process.argv[1] = path.join(import.meta.dirname, "fixtures", "fake-omk-json.mjs");
+		process.env.OMK_CODING_AGENT_DIR = agentHome;
+
+		let registered: unknown;
+		const api = {
+			registerTool(tool: unknown) {
+				registered = tool;
+			},
+		} as unknown as ExtensionAPI;
+		const { default: registerSubagent } = await import("./index.ts");
+		registerSubagent(api);
+		if (!isSmokeTool(registered)) throw new Error("subagent tool was not registered");
+
+		expect(registered.resolveTimeoutMs?.({ thinkingLevel: "ultra" })).toBe(0);
+		const result = await registered.execute(
+			"fixture-ultra-call",
+			{
+				tasks: Array.from({ length: 9 }, (_, index) => ({
+					agent: "fixture-agent",
+					task: `Run bounded offline fixture ${index + 1}.`,
+				})),
+				agentScope: "project",
+				confirmProjectAgents: false,
+				executionBudgetMs: 120_000,
+				maxResumeAttempts: 1,
+			},
+			new AbortController().signal,
+			undefined,
+			{ cwd, hasUI: false, thinkingLevel: "ultra" },
+		);
+		const details = result.details as SmokeDetails;
+
+		expect(result.isError).not.toBe(true);
+		expect(details.mode).toBe("parallel");
+		expect(details.results).toHaveLength(9);
+		expect(details.results.map((entry) => ({ exitCode: entry.exitCode, outcome: entry.deadline?.outcome }))).toEqual(
+			Array.from({ length: 9 }, () => ({ exitCode: 0, outcome: "completed" })),
+		);
+		expect(details.executionBudget).toMatchObject({
+			unbounded: false,
+			hardDeadlineMs: 120_000,
+			plannedShards: 9,
+			completedShards: 9,
+		});
+	}, 120_000);
 });
 
 function isSmokeTool(value: unknown): value is SmokeTool {

package/examples/extensions/subagent/workflow-graph.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import { GraphValidationError, planTaskGraph, renderDependencyContext } from "./workflow-graph.ts";
+
+describe("subagent workflow graph", () => {
+	it("builds deterministic parallel execution waves", () => {
+		const plan = planTaskGraph([
+			{ id: "research", agent: "scout", task: "Research" },
+			{ id: "lint", agent: "reviewer", task: "Lint" },
+			{ id: "build", agent: "worker", task: "Build", dependsOn: ["research"] },
+			{ id: "review", agent: "reviewer", task: "Review", dependsOn: ["build", "lint"] },
+		]);
+
+		expect(plan.waves).toEqual([["research", "lint"], ["build"], ["review"]]);
+	});
+
+	it.each([
+		[
+			"duplicate ids",
+			[
+				{ id: "same", agent: "scout", task: "A" },
+				{ id: "same", agent: "worker", task: "B" },
+			],
+			/duplicate node id 'same'/,
+		],
+		[
+			"unknown dependencies",
+			[{ id: "build", agent: "worker", task: "Build", dependsOn: ["missing"] }],
+			/unknown node 'missing'/,
+		],
+		[
+			"self dependencies",
+			[{ id: "loop", agent: "worker", task: "Build", dependsOn: ["loop"] }],
+			/cannot depend on itself/,
+		],
+		[
+			"cycles",
+			[
+				{ id: "a", agent: "worker", task: "A", dependsOn: ["b"] },
+				{ id: "b", agent: "worker", task: "B", dependsOn: ["a"] },
+			],
+			/cycle detected: a, b/,
+		],
+	] as const)("fails closed on %s", (_name, graph, expected) => {
+		expect(() => planTaskGraph([...graph])).toThrowError(GraphValidationError);
+		expect(() => planTaskGraph([...graph])).toThrow(expected);
+	});
+
+	it("injects only declared dependency outputs", () => {
+		const task = {
+			id: "build",
+			agent: "worker",
+			task: "Use this evidence:\n{dependencies}",
+			dependsOn: ["research"],
+		};
+		const rendered = renderDependencyContext(
+			task,
+			new Map([
+				["research", "verified finding"],
+				["unrelated", "must not leak"],
+			]),
+		);
+
+		expect(rendered).toContain("### research\nverified finding");
+		expect(rendered).not.toContain("must not leak");
+	});
+
+	it("does not append dependency output unless the task opts in", () => {
+		const task = { id: "build", agent: "worker", task: "Build", dependsOn: ["research"] };
+		expect(renderDependencyContext(task, new Map([["research", "large output"]]))).toBe("Build");
+	});
+
+	it("bounds each dependency handoff without splitting UTF-8", () => {
+		const task = { id: "build", agent: "worker", task: "{dependencies}", dependsOn: ["research"] };
+		const rendered = renderDependencyContext(task, new Map([["research", "한".repeat(20_000)]]));
+
+		expect(Buffer.byteLength(rendered, "utf8")).toBeLessThan(17_000);
+		expect(rendered).toContain("[dependency output truncated]");
+		expect(rendered).not.toContain("�");
+	});
+});

package/examples/extensions/subagent/workflow-graph.ts

@@ -0,0 +1,89 @@
+export interface GraphTask {
+	readonly id: string;
+	readonly agent: string;
+	readonly task: string;
+	readonly cwd?: string;
+	readonly dependsOn?: readonly string[];
+}
+
+export interface TaskGraphPlan {
+	readonly tasks: ReadonlyMap<string, GraphTask>;
+	readonly waves: readonly (readonly string[])[];
+}
+
+export class GraphValidationError extends Error {
+	constructor(message: string) {
+		super(`Invalid task graph: ${message}`);
+		this.name = "GraphValidationError";
+	}
+}
+
+export function planTaskGraph(tasks: readonly GraphTask[]): TaskGraphPlan {
+	if (tasks.length === 0) throw new GraphValidationError("at least one node is required");
+
+	const byId = new Map<string, GraphTask>();
+	for (const task of tasks) {
+		if (task.id.trim() === "") throw new GraphValidationError("node id must not be empty");
+		if (byId.has(task.id)) throw new GraphValidationError(`duplicate node id '${task.id}'`);
+		byId.set(task.id, task);
+	}
+
+	const dependents = new Map<string, string[]>();
+	const remainingDependencies = new Map<string, number>();
+	for (const task of tasks) {
+		const dependencies = new Set(task.dependsOn ?? []);
+		if (dependencies.has(task.id)) throw new GraphValidationError(`node '${task.id}' cannot depend on itself`);
+		for (const dependency of dependencies) {
+			if (!byId.has(dependency)) {
+				throw new GraphValidationError(`node '${task.id}' depends on unknown node '${dependency}'`);
+			}
+			const targets = dependents.get(dependency) ?? [];
+			targets.push(task.id);
+			dependents.set(dependency, targets);
+		}
+		remainingDependencies.set(task.id, dependencies.size);
+	}
+
+	const waves: string[][] = [];
+	let ready = tasks.filter((task) => remainingDependencies.get(task.id) === 0).map((task) => task.id);
+	let visited = 0;
+	while (ready.length > 0) {
+		waves.push(ready);
+		visited += ready.length;
+		const next = new Set<string>();
+		for (const id of ready) {
+			for (const dependent of dependents.get(id) ?? []) {
+				const remaining = (remainingDependencies.get(dependent) ?? 0) - 1;
+				remainingDependencies.set(dependent, remaining);
+				if (remaining === 0) next.add(dependent);
+			}
+		}
+		ready = tasks.filter((task) => next.has(task.id)).map((task) => task.id);
+	}
+
+	if (visited !== tasks.length) {
+		const cycleNodes = tasks.filter((task) => (remainingDependencies.get(task.id) ?? 0) > 0).map((task) => task.id);
+		throw new GraphValidationError(`cycle detected: ${cycleNodes.join(", ")}`);
+	}
+	return { tasks: byId, waves };
+}
+
+const MAX_DEPENDENCY_OUTPUT_BYTES = 16 * 1024;
+
+function truncateUtf8(value: string): string {
+	const encoded = Buffer.from(value, "utf8");
+	if (encoded.length <= MAX_DEPENDENCY_OUTPUT_BYTES) return value;
+	const suffix = "\n\n[dependency output truncated]";
+	const bodyLimit = MAX_DEPENDENCY_OUTPUT_BYTES - Buffer.byteLength(suffix, "utf8");
+	let body = encoded.subarray(0, bodyLimit).toString("utf8");
+	if (body.endsWith("�")) body = body.slice(0, -1);
+	return `${body}${suffix}`;
+}
+
+export function renderDependencyContext(task: GraphTask, outputs: ReadonlyMap<string, string>): string {
+	if (!task.task.includes("{dependencies}")) return task.task;
+	const context = (task.dependsOn ?? [])
+		.map((id) => `### ${id}\n${truncateUtf8(outputs.get(id) ?? "(no output)")}`)
+		.join("\n\n");
+	return task.task.split("{dependencies}").join(context || "(no dependencies)");
+}

package/examples/extensions/with-deps/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "omk-extension-with-deps",
-  "version": "0.95.1",
+  "version": "0.96.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omk-extension-with-deps",
-      "version": "0.95.1",
+      "version": "0.96.0",
       "dependencies": {
         "ms": "2.1.3"
       },

package/examples/extensions/with-deps/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "omk-extension-with-deps",
 	"private": true,
-	"version": "0.95.1",
+	"version": "0.96.0",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",