@oh-my-pi/pi-coding-agent 3.21.0 → 3.25.0

package/src/core/tools/complete.ts

@@ -0,0 +1,131 @@
+/**
+ * Complete tool for structured subagent output.
+ *
+ * Subagents must call this tool to finish and return structured JSON output.
+ */
+
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";
+import type { ToolSession } from "./index";
+import { jtdToJsonSchema } from "./jtd-to-json-schema";
+import { subprocessToolRegistry } from "./task/subprocess-tool-registry";
+
+export interface CompleteDetails {
+	data: unknown;
+	status: "success" | "aborted";
+	error?: string;
+}
+
+const ajv = new Ajv({ allErrors: true, strict: false });
+
+function normalizeSchema(schema: unknown): { normalized?: unknown; error?: string } {
+	if (schema === undefined || schema === null) return {};
+	if (typeof schema === "string") {
+		try {
+			return { normalized: JSON.parse(schema) };
+		} catch (err) {
+			return { error: err instanceof Error ? err.message : String(err) };
+		}
+	}
+	return { normalized: schema };
+}
+
+function formatSchema(schema: unknown): string {
+	if (schema === undefined) return "No schema provided.";
+	if (typeof schema === "string") return schema;
+	try {
+		return JSON.stringify(schema, null, 2);
+	} catch {
+		return "[unserializable schema]";
+	}
+}
+
+function formatAjvErrors(errors: ErrorObject[] | null | undefined): string {
+	if (!errors || errors.length === 0) return "Unknown schema validation error.";
+	return errors
+		.map((err) => {
+			const path = err.instancePath ? `${err.instancePath}: ` : "";
+			return `${path}${err.message ?? "invalid"}`;
+		})
+		.join("; ");
+}
+
+export function createCompleteTool(session: ToolSession) {
+	const schemaResult = normalizeSchema(session.outputSchema);
+	// Convert JTD to JSON Schema if needed (auto-detected)
+	const normalizedSchema =
+		schemaResult.normalized !== undefined ? jtdToJsonSchema(schemaResult.normalized) : undefined;
+	let validate: ValidateFunction | undefined;
+	let schemaError = schemaResult.error;
+
+	if (normalizedSchema !== undefined && !schemaError) {
+		try {
+			validate = ajv.compile(normalizedSchema as any);
+		} catch (err) {
+			schemaError = err instanceof Error ? err.message : String(err);
+		}
+	}
+
+	const schemaHint = formatSchema(normalizedSchema ?? session.outputSchema);
+
+	// Use actual schema if provided, otherwise fall back to Type.Any
+	// Merge description into the JSON schema for better tool documentation
+	const dataSchema = normalizedSchema
+		? Type.Unsafe({
+				...(normalizedSchema as object),
+				description: "Structured output matching the schema:\n" + schemaHint,
+			})
+		: Type.Any({ description: "Structured JSON output (no schema specified)" });
+
+	const completeParams = Type.Object({
+		data: dataSchema,
+		status: Type.Optional(
+			Type.Union([Type.Literal("success"), Type.Literal("aborted")], {
+				default: "success",
+				description: "Use 'aborted' if the task cannot be completed",
+			}),
+		),
+		error: Type.Optional(Type.String({ description: "Error message when status is 'aborted'" })),
+	});
+
+	const tool: AgentTool<typeof completeParams, CompleteDetails> = {
+		name: "complete",
+		label: "Complete",
+		description:
+			"Finish the task with structured JSON output. Call exactly once at the end of the task.\n\n" +
+			"If you cannot complete the task, call with status='aborted' and an error message.",
+		parameters: completeParams,
+		execute: async (_toolCallId, params) => {
+			const status = params.status ?? "success";
+
+			// Skip schema validation when aborting - the agent is giving up
+			if (status === "success") {
+				if (schemaError) {
+					throw new Error(`Invalid output schema: ${schemaError}`);
+				}
+				if (validate && !validate(params.data)) {
+					throw new Error(`Output does not match schema: ${formatAjvErrors(validate.errors)}`);
+				}
+			}
+
+			const responseText =
+				status === "aborted"
+					? `Task aborted: ${params.error || "No reason provided"}`
+					: "Completion recorded.";
+
+			return {
+				content: [{ type: "text", text: responseText }],
+				details: { data: params.data, status, error: params.error },
+			};
+		},
+	};
+
+	return tool;
+}
+
+// Register subprocess tool handler for extraction + termination.
+subprocessToolRegistry.register<CompleteDetails>("complete", {
+	extractData: (event) => event.result?.details as CompleteDetails | undefined,
+	shouldTerminate: () => true,
+});

package/src/core/tools/context.ts

@@ -6,27 +6,34 @@ declare module "@oh-my-pi/pi-agent-core" {
 	interface AgentToolContext extends CustomToolContext {
 		ui?: ExtensionUIContext;
 		hasUI?: boolean;
+		toolNames?: string[];
 	}
 }
 
 export interface ToolContextStore {
 	getContext(): AgentToolContext;
 	setUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
+	setToolNames(names: string[]): void;
 }
 
 export function createToolContextStore(getBaseContext: () => CustomToolContext): ToolContextStore {
 	let uiContext: ExtensionUIContext | undefined;
 	let hasUI = false;
+	let toolNames: string[] = [];
 
 	return {
 		getContext: () => ({
 			...getBaseContext(),
 			ui: uiContext,
 			hasUI,
+			toolNames,
 		}),
 		setUIContext: (context, uiAvailable) => {
 			uiContext = context;
 			hasUI = uiAvailable;
 		},
+		setToolNames: (names) => {
+			toolNames = names;
+		},
 	};
 }

package/src/core/tools/edit.ts

@@ -17,7 +17,8 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "./edit-diff";
-import { type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "./lsp/index";
+import type { ToolSession } from "./index";
+import { createLspWritethrough, type FileDiagnosticsResult } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 import {
 	formatDiagnostics,
@@ -46,16 +47,11 @@ export interface EditToolDetails {
 	diagnostics?: FileDiagnosticsResult;
 }
 
-export interface EditToolOptions {
-	/** Whether to accept high-confidence fuzzy matches for whitespace/indentation (default: true) */
-	fuzzyMatch?: boolean;
-	/** Writethrough callback to get LSP diagnostics after editing a file */
-	writethrough?: WritethroughCallback;
-}
-
-export function createEditTool(cwd: string, options: EditToolOptions = {}): AgentTool<typeof editSchema> {
-	const allowFuzzy = options.fuzzyMatch ?? true;
-	const writethrough = options.writethrough ?? writethroughNoop;
+export function createEditTool(session: ToolSession): AgentTool<typeof editSchema> {
+	const allowFuzzy = session.settings?.getEditFuzzyMatch() ?? true;
+	const enableDiagnostics = session.settings?.getLspDiagnosticsOnEdit() ?? false;
+	const enableFormat = session.settings?.getLspFormatOnWrite() ?? true;
+	const writethrough = createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics });
 	return {
 		name: "edit",
 		label: "Edit",
@@ -71,7 +67,7 @@ export function createEditTool(cwd: string, options: EditToolOptions = {}): Agen
 				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
 			}
 
-			const absolutePath = resolveToCwd(path, cwd);
+			const absolutePath = resolveToCwd(path, session.cwd);
 
 			const file = Bun.file(absolutePath);
 			if (!(await file.exists())) {
@@ -203,9 +199,6 @@ export function createEditTool(cwd: string, options: EditToolOptions = {}): Agen
 	};
 }
 
-/** Default edit tool using process.cwd() - for backwards compatibility */
-export const editTool = createEditTool(process.cwd());
-
 // =============================================================================
 // TUI Renderer
 // =============================================================================

package/src/core/tools/exa/render.ts

@@ -78,10 +78,7 @@ export function renderExaResult(
 			}
 
 			if (remaining > 0) {
-				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
-					"muted",
-					formatMoreItems(remaining, "line", uiTheme),
-				)}`;
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "line", uiTheme))}`;
 			}
 
 			return new Text(text, 0, 0);
@@ -168,17 +165,11 @@ export function renderExaResult(
 		text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", title)}${domainPart}`;
 
 		if (res.url) {
-			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
-				"mdLinkUrl",
-				res.url,
-			)}`;
+			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("mdLinkUrl", res.url)}`;
 		}
 
 		if (res.author) {
-			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
-				"muted",
-				`Author: ${res.author}`,
-			)}`;
+			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", `Author: ${res.author}`)}`;
 		}
 
 		if (res.publishedDate) {
@@ -206,10 +197,7 @@ export function renderExaResult(
 		}
 
 		if (res.highlights?.length) {
-			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
-				"accent",
-				"Highlights",
-			)}`;
+			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("accent", "Highlights")}`;
 			const maxHighlights = Math.min(res.highlights.length, 3);
 			for (let j = 0; j < maxHighlights; j++) {
 				const h = res.highlights[j];

package/src/core/tools/find.ts

@@ -10,6 +10,7 @@ import findDescription from "../../prompts/tools/find.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { untilAborted } from "../utils";
+import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
 import {
 	formatCount,
@@ -55,7 +56,7 @@ export interface FindToolDetails {
 	error?: string;
 }
 
-export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
+export function createFindTool(session: ToolSession): AgentTool<typeof findSchema> {
 	return {
 		name: "find",
 		label: "Find",
@@ -87,9 +88,9 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 					throw new Error("fd is not available and could not be downloaded");
 				}
 
-				const searchPath = resolveToCwd(searchDir || ".", cwd);
+				const searchPath = resolveToCwd(searchDir || ".", session.cwd);
 				const scopePath = (() => {
-					const relative = path.relative(cwd, searchPath).replace(/\\/g, "/");
+					const relative = path.relative(session.cwd, searchPath).replace(/\\/g, "/");
 					return relative.length === 0 ? "." : relative;
 				})();
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
@@ -261,9 +262,6 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 	};
 }
 
-/** Default find tool using process.cwd() - for backwards compatibility */
-export const findTool = createFindTool(process.cwd());
-
 // =============================================================================
 // TUI Renderer
 // =============================================================================
@@ -332,10 +330,7 @@ export const findToolRenderer = {
 				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", displayLines[i])}`;
 			}
 			if (remaining > 0) {
-				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
-					"muted",
-					formatMoreItems(remaining, "file", uiTheme),
-				)}`;
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "file", uiTheme))}`;
 			}
 			return new Text(text, 0, 0);
 		}
@@ -355,10 +350,7 @@ export const findToolRenderer = {
 		const hasMoreFiles = files.length > maxFiles;
 		const expandHint = formatExpandHint(expanded, hasMoreFiles, uiTheme);
 
-		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(
-			truncated,
-			uiTheme,
-		)}${scopeLabel}${expandHint}`;
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${scopeLabel}${expandHint}`;
 
 		const truncationReasons: string[] = [];
 		if (details?.resultLimitReached) {
@@ -394,10 +386,7 @@ export const findToolRenderer = {
 		}
 
 		if (hasTruncation) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
-				"warning",
-				`truncated: ${truncationReasons.join(", ")}`,
-			)}`;
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
 		}
 
 		return new Text(text, 0, 0);

package/src/core/tools/git.ts

@@ -2,6 +2,7 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { type GitParams, gitTool as gitToolCore, type ToolResponse } from "@oh-my-pi/pi-git-tool";
 import { type Static, Type } from "@sinclair/typebox";
 import gitDescription from "../../prompts/tools/git.md" with { type: "text" };
+import type { ToolSession } from "./index";
 
 const gitSchema = Type.Object({
 	operation: Type.Union([
@@ -192,7 +193,10 @@ const gitSchema = Type.Object({
 
 export type GitToolDetails = ToolResponse<unknown>;
 
-export function createGitTool(cwd: string): AgentTool<typeof gitSchema, GitToolDetails> {
+export function createGitTool(session: ToolSession): AgentTool<typeof gitSchema, GitToolDetails> | null {
+	if (session.settings?.getGitToolEnabled() === false) {
+		return null;
+	}
 	return {
 		name: "git",
 		label: "Git",
@@ -203,7 +207,7 @@ export function createGitTool(cwd: string): AgentTool<typeof gitSchema, GitToolD
 				throw new Error("Git commit requires a message to avoid an interactive editor. Provide `message`.");
 			}
 
-			const result = await gitToolCore(params as GitParams, cwd);
+			const result = await gitToolCore(params as GitParams, session.cwd);
 			if ("error" in result) {
 				const message = result._rendered ?? result.error;
 				return { content: [{ type: "text", text: message }], details: result };
@@ -217,4 +221,10 @@ export function createGitTool(cwd: string): AgentTool<typeof gitSchema, GitToolD
 	};
 }
 
-export const gitTool = createGitTool(process.cwd());
+export const gitTool = createGitTool({
+	cwd: process.cwd(),
+	hasUI: false,
+	rulebookRules: [],
+	getSessionFile: () => null,
+	getSessionSpawns: () => null,
+})!;

package/src/core/tools/grep.ts

@@ -9,6 +9,7 @@ import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/t
 import grepDescription from "../../prompts/tools/grep.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
 import type { RenderResultOptions } from "../custom-tools/types";
+import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
 import {
 	formatCount,
@@ -79,7 +80,7 @@ export interface GrepToolDetails {
 	error?: string;
 }
 
-export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
+export function createGrepTool(session: ToolSession): AgentTool<typeof grepSchema> {
 	return {
 		name: "grep",
 		label: "Grep",
@@ -127,9 +128,9 @@ export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
 				throw new Error("ripgrep (rg) is not available and could not be downloaded");
 			}
 
-			const searchPath = resolveToCwd(searchDir || ".", cwd);
+			const searchPath = resolveToCwd(searchDir || ".", session.cwd);
 			const scopePath = (() => {
-				const relative = nodePath.relative(cwd, searchPath).replace(/\\/g, "/");
+				const relative = nodePath.relative(session.cwd, searchPath).replace(/\\/g, "/");
 				return relative.length === 0 ? "." : relative;
 			})();
 			let searchStat: Stats;
@@ -595,9 +596,6 @@ export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
 	};
 }
 
-/** Default grep tool using process.cwd() - for backwards compatibility */
-export const grepTool = createGrepTool(process.cwd());
-
 // =============================================================================
 // TUI Renderer
 // =============================================================================
@@ -681,10 +679,7 @@ export const grepToolRenderer = {
 			}
 
 			if (remaining > 0) {
-				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
-					"muted",
-					formatMoreItems(remaining, "item", uiTheme),
-				)}`;
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "item", uiTheme))}`;
 			}
 
 			return new Text(text, 0, 0);
@@ -715,10 +710,7 @@ export const grepToolRenderer = {
 		const hasMoreFiles = fileEntries.length > maxFiles;
 		const expandHint = formatExpandHint(expanded, hasMoreFiles, uiTheme);
 
-		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(
-			truncated,
-			uiTheme,
-		)}${scopeLabel}${expandHint}`;
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${scopeLabel}${expandHint}`;
 
 		const truncationReasons: string[] = [];
 		if (details?.matchLimitReached) {
@@ -764,10 +756,7 @@ export const grepToolRenderer = {
 		}
 
 		if (hasTruncation) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
-				"warning",
-				`truncated: ${truncationReasons.join(", ")}`,
-			)}`;
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
 		}
 
 		return new Text(text, 0, 0);

package/src/core/tools/index.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from "bun:test";
+import { BUILTIN_TOOLS, createTools, HIDDEN_TOOLS, type ToolSession } from "./index";
+
+function createTestSession(overrides: Partial<ToolSession> = {}): ToolSession {
+	return {
+		cwd: "/tmp/test",
+		hasUI: false,
+		rulebookRules: [],
+		getSessionFile: () => null,
+		getSessionSpawns: () => "*",
+		...overrides,
+	};
+}
+
+describe("createTools", () => {
+	it("creates all builtin tools by default", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		// Core tools should always be present
+		expect(names).toContain("bash");
+		expect(names).toContain("read");
+		expect(names).toContain("edit");
+		expect(names).toContain("write");
+		expect(names).toContain("grep");
+		expect(names).toContain("find");
+		expect(names).toContain("ls");
+		expect(names).toContain("lsp");
+		expect(names).toContain("notebook");
+		expect(names).toContain("task");
+		expect(names).toContain("output");
+		expect(names).toContain("web_fetch");
+		expect(names).toContain("web_search");
+	});
+
+	it("respects requested tool subset", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session, ["read", "write"]);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toEqual(["read", "write"]);
+	});
+
+	it("includes hidden tools when explicitly requested", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session, ["report_finding"]);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toEqual(["report_finding"]);
+	});
+
+	it("includes complete tool when required", async () => {
+		const session = createTestSession({ requireCompleteTool: true });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("complete");
+	});
+
+	it("excludes ask tool when hasUI is false", async () => {
+		const session = createTestSession({ hasUI: false });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("ask");
+	});
+
+	it("includes ask tool when hasUI is true", async () => {
+		const session = createTestSession({ hasUI: true });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("ask");
+	});
+
+	it("excludes rulebook tool when no rules provided", async () => {
+		const session = createTestSession({ rulebookRules: [] });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("rulebook");
+	});
+
+	it("includes rulebook tool when rules provided", async () => {
+		const session = createTestSession({
+			rulebookRules: [
+				{
+					path: "/test/rule.md",
+					name: "Test Rule",
+					content: "Test content",
+					description: "A test rule",
+					_source: { provider: "test", providerName: "Test", path: "/test", level: "project" },
+				},
+			],
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("rulebook");
+	});
+
+	it("excludes git tool when disabled in settings", async () => {
+		const session = createTestSession({
+			settings: {
+				getImageAutoResize: () => true,
+				getLspFormatOnWrite: () => true,
+				getLspDiagnosticsOnWrite: () => true,
+				getLspDiagnosticsOnEdit: () => false,
+				getEditFuzzyMatch: () => true,
+				getGitToolEnabled: () => false,
+				getBashInterceptorEnabled: () => true,
+			},
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("git");
+	});
+
+	it("includes git tool when enabled in settings", async () => {
+		const session = createTestSession({
+			settings: {
+				getImageAutoResize: () => true,
+				getLspFormatOnWrite: () => true,
+				getLspDiagnosticsOnWrite: () => true,
+				getLspDiagnosticsOnEdit: () => false,
+				getEditFuzzyMatch: () => true,
+				getGitToolEnabled: () => true,
+				getBashInterceptorEnabled: () => true,
+			},
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("git");
+	});
+
+	it("includes git tool when no settings provided (default enabled)", async () => {
+		const session = createTestSession({ settings: undefined });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("git");
+	});
+
+	it("always includes output tool when task tool is present", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		// Both should be present together
+		expect(names).toContain("task");
+		expect(names).toContain("output");
+	});
+
+	it("BUILTIN_TOOLS contains all expected tools", () => {
+		const expectedTools = [
+			"ask",
+			"bash",
+			"edit",
+			"find",
+			"git",
+			"grep",
+			"ls",
+			"lsp",
+			"notebook",
+			"output",
+			"read",
+			"rulebook",
+			"task",
+			"web_fetch",
+			"web_search",
+			"write",
+		];
+
+		for (const tool of expectedTools) {
+			expect(BUILTIN_TOOLS).toHaveProperty(tool);
+		}
+
+		// Ensure we haven't missed any
+		expect(Object.keys(BUILTIN_TOOLS).sort()).toEqual(expectedTools.sort());
+	});
+
+	it("HIDDEN_TOOLS contains review tools", () => {
+		expect(Object.keys(HIDDEN_TOOLS).sort()).toEqual(["complete", "report_finding", "submit_review"]);
+	});
+});