@vitest-agent/mcp 3.0.4 → 4.0.1

package/tools/overview.js

@@ -1,13 +1,9 @@
-import { publicProcedure } from "../context.js";
+import { RenderText } from "../annotations.js";
 import { Effect, Option, Schema, SchemaGetter } from "effect";
-import { DataReader } from "@vitest-agent/sdk";
+import { DataReader } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
 
 //#region src/tools/overview.ts
-/**
-* `test_overview` MCP tool — Schema-driven implementation.
-*
-* @packageDocumentation
-*/
 const ProjectRunSummary = Schema.Struct({
 	project: Schema.String,
 	lastRun: Schema.NullOr(Schema.String),
@@ -34,6 +30,11 @@ const OverviewAbsent = Schema.Struct({
 	projectFilter: Schema.optional(Schema.String),
 	reason: Schema.Literals(["no_runs", "project_filter_empty"])
 }).annotate({ identifier: "TestOverviewAbsent" });
+/**
+* The `test_overview` tool's success payload.
+*
+* @public
+*/
 const TestOverviewResult = Schema.Union([OverviewAvailable, OverviewAbsent]).annotate({
 	identifier: "TestOverviewResult",
 	title: "test_overview result",
@@ -70,7 +71,18 @@ const TestOverviewAsMarkdown = TestOverviewResult.pipe(Schema.decodeTo(Schema.St
 	decode: SchemaGetter.transform((data) => formatTestOverviewMarkdown(data)),
 	encode: SchemaGetter.forbidden(() => "TestOverviewAsMarkdown is one-way.")
 }));
-const testOverview = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+/**
+* The `test_overview` tool's parameters.
+*
+* @public
+*/
+const TestOverviewInput = Schema.Struct({ project: Schema.optionalKey(Schema.String).annotate({ description: "Filter to a specific project" }) });
+/**
+* Handler for {@link testOverviewTool}.
+*
+* @public
+*/
+const handleTestOverview = (input) => Effect.gen(function* () {
 	const reader = yield* DataReader;
 	const [manifestOpt, runs] = yield* Effect.all([reader.getManifest(), reader.getRunsByProject()], { concurrency: "unbounded" });
 	if (Option.isNone(manifestOpt) || runs.length === 0) return {
@@ -89,7 +101,18 @@ const testOverview = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Stru
 		...input.project !== void 0 && { projectFilter: input.project },
 		runs: filteredRuns
 	};
-})));
+}).pipe(Effect.orDie);
+/**
+* The Effect-native `test_overview` tool.
+*
+* @public
+*/
+const testOverviewTool = Tool.make("test_overview", {
+	description: "Use when you want a summary of the test landscape with per-project run metrics. Returns markdown in content[] and a typed JSON object in structuredContent ({ dataAvailable, projectFilter?, runs[] } or absent variant).",
+	parameters: TestOverviewInput,
+	success: TestOverviewResult,
+	dependencies: [DataReader]
+}).annotate(Tool.Title, "Test overview").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestOverviewMarkdown(encoded));
 
 //#endregion
-export { TestOverviewAsMarkdown, TestOverviewResult, formatTestOverviewMarkdown, testOverview };
+export { TestOverviewInput, TestOverviewResult, formatTestOverviewMarkdown, handleTestOverview, testOverviewTool };

package/tools/ping.js

@@ -1,22 +1,34 @@
-import { publicProcedure } from "../context.js";
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
+import { Tool } from "effect/unstable/ai";
 
 //#region src/tools/ping.ts
 /**
-* `ping` MCP tool — Schema-driven implementation.
+* The `ping` tool's success payload.
 *
-* Trivial liveness probe used to verify hot-patch reload of the MCP
-* server. Returns the canonical `pong` payload so callers can assert
-* a healthy round-trip.
-*
-* @packageDocumentation
+* @public
 */
 const PingResult = Schema.Struct({ message: Schema.Literal("pong").annotate({ description: "Constant `pong`. Presence confirms the MCP server responded." }) }).annotate({
 	identifier: "PingResult",
 	title: "ping result",
 	description: "Liveness probe. Carries no data beyond the constant `pong` discriminant."
 });
-const ping = publicProcedure.query(async () => ({ message: "pong" }));
+/**
+* The Effect-native `ping` tool. No parameters (the default
+* `Tool.EmptyParams` serves as a strict empty object; `Schema.Struct({})`
+* would serialize to a non-object JSON Schema that MCP rejects).
+*
+* @public
+*/
+const pingTool = Tool.make("ping", {
+	description: "Ping the MCP server — returns 'pong'. Used to verify hot-patch reload.",
+	success: PingResult
+}).annotate(Tool.Title, "Ping").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
+/**
+* Handler for {@link pingTool}.
+*
+* @public
+*/
+const handlePing = () => Effect.succeed({ message: "pong" });
 
 //#endregion
-export { PingResult, ping };
+export { PingResult, handlePing, pingTool };

package/tools/register-agent.js

@@ -1,6 +1,6 @@
-import { publicProcedure } from "../context.js";
 import { Effect, Option, Schema } from "effect";
-import { DataReader, DataStore, deriveIdempotencyKey } from "@vitest-agent/sdk";
+import { DataReader, DataStore, deriveIdempotencyKey } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
 
 //#region src/tools/register-agent.ts
 /**
@@ -31,16 +31,21 @@ import { DataReader, DataStore, deriveIdempotencyKey } from "@vitest-agent/sdk";
 * `AGENT_ALREADY_REGISTERED` here so MCP clients see one shape per
 * outcome.
 */
+/**
+* The `register_agent` tool's parameters.
+*
+* @public
+*/
 const RegisterAgentInput = Schema.Struct({
-	chatId: Schema.String,
-	conversationId: Schema.optional(Schema.String),
-	hostKind: Schema.optional(Schema.String),
-	agentType: Schema.String,
-	parentAgentId: Schema.optional(Schema.String),
-	clientNonce: Schema.optional(Schema.String),
-	startGitBranch: Schema.optional(Schema.String),
-	startGitCommitSha: Schema.optional(Schema.String),
-	startWorktreeDir: Schema.optional(Schema.String)
+	chatId: Schema.String.annotate({ description: "Host's chat UUID (session_id from CC hook payload, etc.)" }),
+	conversationId: Schema.optionalKey(Schema.String).annotate({ description: "Canonical conversation UUID (from session-map mapConversation)" }),
+	hostKind: Schema.optionalKey(Schema.String).annotate({ description: "Host vendor identifier; defaults to 'claude-code'" }),
+	agentType: Schema.String.annotate({ description: "Agent type; must begin with the host-kind prefix" }),
+	parentAgentId: Schema.optionalKey(Schema.String).annotate({ description: "Parent agent UUID for subagent registrations" }),
+	clientNonce: Schema.optionalKey(Schema.String).annotate({ description: "Disambiguator for sibling-subagent registrations under the same parent; the server derives a deterministic default when omitted, which collapses parallel siblings into one row" }),
+	startGitBranch: Schema.optionalKey(Schema.String),
+	startGitCommitSha: Schema.optionalKey(Schema.String),
+	startWorktreeDir: Schema.optionalKey(Schema.String)
 });
 const RegisterAgentSuccess = Schema.Struct({
 	ok: Schema.Literal(true).annotate({ description: "Discriminant — `true` when the agent row was inserted (or an existing one recovered)." }),
@@ -65,12 +70,24 @@ const RegisterAgentFailure = Schema.Struct({
 		expectedPrefix: Schema.optional(Schema.String).annotate({ description: "Present only when `code = INVALID_AGENT_TYPE_PREFIX`. The required `<hostKind>-` prefix." })
 	})
 }).annotate({ identifier: "RegisterAgentFailure" });
+/**
+* The `register_agent` tool's success payload.
+*
+* @public
+*/
 const RegisterAgentResult = Schema.Union([RegisterAgentSuccess, RegisterAgentFailure]).annotate({
 	identifier: "RegisterAgentResult",
 	title: "register_agent result",
 	description: "Discriminate on `ok`. The four failure codes are documented per their `code` literal."
 });
-const registerAgent = publicProcedure.input(Schema.toStandardSchemaV1(RegisterAgentInput)).mutation(async ({ ctx, input }) => {
+/**
+* Handler for {@link registerAgentTool}. Idempotency is the tool's own
+* business rule (the `agents` idempotency key), not the generic
+* `withIdempotency` combinator.
+*
+* @public
+*/
+const handleRegisterAgent = (input) => Effect.gen(function* () {
 	const expectedPrefix = `${input.hostKind ?? "claude-code"}-`;
 	if (!input.agentType.startsWith(expectedPrefix)) return {
 		ok: false,
@@ -86,55 +103,64 @@ const registerAgent = publicProcedure.input(Schema.toStandardSchemaV1(RegisterAg
 		parentAgentId: input.parentAgentId ?? null,
 		clientNonce
 	});
-	return ctx.runtime.runPromise(Effect.gen(function* () {
-		const reader = yield* DataReader;
-		const store = yield* DataStore;
-		const sessionOpt = yield* reader.getSessionByChatId(input.chatId);
-		if (Option.isNone(sessionOpt)) return {
-			ok: false,
-			error: {
-				code: "SESSION_NOT_FOUND",
-				message: `chat ${input.chatId} has not been registered; the host must call its SessionStart equivalent first`
-			}
-		};
-		const sessionRowId = sessionOpt.value.id;
-		const result = yield* store.registerAgent({
-			sessionId: sessionRowId,
-			agentType: input.agentType,
-			parentAgentId: input.parentAgentId ?? null,
-			conversationId: input.conversationId ?? null,
-			startedAt: Math.floor(Date.now() / 1e3),
-			...input.startGitBranch !== void 0 && { startGitBranch: input.startGitBranch },
-			...input.startGitCommitSha !== void 0 && { startGitCommitSha: input.startGitCommitSha },
-			...input.startWorktreeDir !== void 0 && { startWorktreeDir: input.startWorktreeDir },
-			idempotencyKey
-		}).pipe(Effect.catchTag("RegistrationConflictError", (e) => Effect.succeed({
-			_tag: "Conflict",
-			reason: e.reason
-		})));
-		if ("_tag" in result && result._tag === "Conflict") return {
-			ok: false,
-			error: {
-				code: "PARENT_AGENT_NOT_FOUND",
-				message: result.reason
-			}
-		};
-		if ("_tag" in result && result._tag === "IdempotencyHit") return {
-			ok: false,
-			error: {
-				code: "AGENT_ALREADY_REGISTERED",
-				message: "agent already registered for (chatId, agentType, parentAgentId, clientNonce); use existingAgentId",
-				existingAgentId: result.existingAgentId
-			}
-		};
-		return {
-			ok: true,
-			agentId: result.agentId,
-			conversationId: result.conversationId,
-			idempotencyKey: result.idempotencyKey
-		};
-	}));
-});
+	const reader = yield* DataReader;
+	const store = yield* DataStore;
+	const sessionOpt = yield* reader.getSessionByChatId(input.chatId);
+	if (Option.isNone(sessionOpt)) return {
+		ok: false,
+		error: {
+			code: "SESSION_NOT_FOUND",
+			message: `chat ${input.chatId} has not been registered; the host must call its SessionStart equivalent first`
+		}
+	};
+	const sessionRowId = sessionOpt.value.id;
+	const result = yield* store.registerAgent({
+		sessionId: sessionRowId,
+		agentType: input.agentType,
+		parentAgentId: input.parentAgentId ?? null,
+		conversationId: input.conversationId ?? null,
+		startedAt: Math.floor(Date.now() / 1e3),
+		...input.startGitBranch !== void 0 && { startGitBranch: input.startGitBranch },
+		...input.startGitCommitSha !== void 0 && { startGitCommitSha: input.startGitCommitSha },
+		...input.startWorktreeDir !== void 0 && { startWorktreeDir: input.startWorktreeDir },
+		idempotencyKey
+	}).pipe(Effect.catchTag("RegistrationConflictError", (e) => Effect.succeed({
+		_tag: "Conflict",
+		reason: e.reason
+	})));
+	if ("_tag" in result && result._tag === "Conflict") return {
+		ok: false,
+		error: {
+			code: "PARENT_AGENT_NOT_FOUND",
+			message: result.reason
+		}
+	};
+	if ("_tag" in result && result._tag === "IdempotencyHit") return {
+		ok: false,
+		error: {
+			code: "AGENT_ALREADY_REGISTERED",
+			message: "agent already registered for (chatId, agentType, parentAgentId, clientNonce); use existingAgentId",
+			existingAgentId: result.existingAgentId
+		}
+	};
+	return {
+		ok: true,
+		agentId: result.agentId,
+		conversationId: result.conversationId,
+		idempotencyKey: result.idempotencyKey
+	};
+}).pipe(Effect.orDie);
+/**
+* The Effect-native `register_agent` tool.
+*
+* @public
+*/
+const registerAgentTool = Tool.make("register_agent", {
+	description: "Use when an LLM-agent invocation starts and must be recorded in the per-project store. Idempotent on (chatId, agentType, parentAgentId, clientNonce). Returns ok:true with agentId on insert, or ok:false with error.code='AGENT_ALREADY_REGISTERED'/'PARENT_AGENT_NOT_FOUND'/'SESSION_NOT_FOUND'/'INVALID_AGENT_TYPE_PREFIX' on the four documented failure modes. agentType must begin with the host-kind prefix (e.g., 'claude-code-main').",
+	parameters: RegisterAgentInput,
+	success: RegisterAgentResult,
+	dependencies: [DataReader, DataStore]
+}).annotate(Tool.Title, "Register agent").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
-export { RegisterAgentResult, registerAgent };
+export { RegisterAgentInput, RegisterAgentResult, handleRegisterAgent, registerAgentTool };

package/tools/run-tests.js

@@ -1,7 +1,10 @@
-import { publicProcedure } from "../context.js";
+import { RenderText } from "../annotations.js";
+import { McpSession } from "../session.js";
 import { createRequire } from "node:module";
 import { Data, Effect, Schema, SchemaGetter, Semaphore } from "effect";
-import { AgentReport, DataReader, DataStore, buildAgentReport, buildConsoleLeaks, coerceErrorField, collectConsoleLeakEntries, formatScopedCoverageNote } from "@vitest-agent/sdk";
+import { DataReader, DataStore } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
+import { AgentReport, buildAgentReport, buildConsoleLeaks, coerceErrorField, collectConsoleLeakEntries, formatScopedCoverageNote } from "@vitest-agent/sdk";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { execFile } from "node:child_process";
 import { existsSync, mkdtempSync, rmSync } from "node:fs";
@@ -14,9 +17,9 @@ import { promisify } from "node:util";
 
 //#region src/tools/run-tests.ts
 const TagFilter = Schema.Struct({
-	all: Schema.optional(Schema.Array(Schema.String)),
-	any: Schema.optional(Schema.Array(Schema.String)),
-	none: Schema.optional(Schema.Array(Schema.String))
+	all: Schema.optionalKey(Schema.Array(Schema.String)).annotate({ description: "Require every listed tag" }),
+	any: Schema.optionalKey(Schema.Array(Schema.String)).annotate({ description: "Require at least one listed tag" }),
+	none: Schema.optionalKey(Schema.Array(Schema.String)).annotate({ description: "Exclude any listed tag" })
 }).annotate({
 	identifier: "TagFilter",
 	description: "All three sub-filters AND together with `project` and `files`. `all` requires every listed tag on the test. `any` requires at least one. `none` excludes any test carrying a listed tag."
@@ -57,6 +60,11 @@ const RunTestsNoMatch = Schema.Struct({
 		resolvedExpression: Schema.NullOr(Schema.String)
 	})
 }).annotate({ identifier: "RunTestsNoMatch" });
+/**
+* The `run_tests` tool's success payload.
+*
+* @public
+*/
 const RunTestsResult = Schema.Union([
 	RunTestsOk,
 	RunTestsTimeout,
@@ -155,7 +163,7 @@ function ensureStdioPatched() {
 /**
 * Run `fn` with `process.stdout.write` and `process.stderr.write`
 * diverted to `stream.write` for code executing inside the call's
-* async context. Code in other async contexts (concurrent tRPC
+* async context. Code in other async contexts (concurrent tool
 * procedure handlers, the MCP stdio transport) sees the original
 * writes unchanged.
 *
@@ -366,9 +374,6 @@ function resolveVitestNodeEntry(root) {
 */
 const vitestLoader = { load: (entry) => import(entry) };
 const runTestsSemaphore = Effect.runSync(Semaphore.make(1));
-function serializeRunTests(fn) {
-	return Effect.runPromise(Semaphore.withPermit(runTestsSemaphore, Effect.promise(() => fn())));
-}
 /**
 * Coerce unknown Vitest unhandled errors into VitestModuleError shape.
 *
@@ -511,19 +516,31 @@ function formatReportMarkdown(report, classifications, scopedNote) {
 	}
 	return lines.join("\n");
 }
-const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
-	files: Schema.optional(Schema.Array(Schema.String)),
-	project: Schema.optional(Schema.String),
-	tags: Schema.optional(TagFilter),
-	passWithNoTests: Schema.optional(Schema.Boolean),
-	timeout: Schema.optional(Schema.Number),
-	projectRoot: Schema.optional(Schema.String),
-	_sessionContext: Schema.optional(Schema.Struct({
+/**
+* The `run_tests` tool's parameters. `tags` and `_sessionContext` are
+* nested structs and are served strict at their own level (issue #243).
+*
+* @public
+*/
+const RunTestsInput = Schema.Struct({
+	files: Schema.optionalKey(Schema.Array(Schema.String)).annotate({ description: "Test file paths to run" }),
+	project: Schema.optionalKey(Schema.String).annotate({ description: "Project name to filter" }),
+	projectRoot: Schema.optionalKey(Schema.String).annotate({ description: "Explicit Vitest root for this call, used verbatim. Omit it to get the config-anchored default (walk up from the server's boot dir for a vitest/vite config, bounded at the git root). Prefer an absolute path; a relative path is resolved against ctx.cwd, not the server process's cwd. Validated: must be an existing directory in the same git repository as ctx.cwd (same git-common-dir, e.g. a sibling worktree). Rejected with { kind: 'error' } naming both paths otherwise." }),
+	tags: Schema.optionalKey(TagFilter).annotate({ description: "Structured tag filter; all/any/none AND together with each other and with project/files" }),
+	passWithNoTests: Schema.optionalKey(Schema.Boolean).annotate({ description: "Per-call override of Vitest's native test.passWithNoTests" }),
+	timeout: Schema.optionalKey(Schema.Finite).annotate({ description: "Timeout in seconds (default: 120)" }),
+	_sessionContext: Schema.optionalKey(Schema.Struct({
 		chatId: Schema.String,
 		conversationId: Schema.String,
 		mainAgentId: Schema.String
-	}))
-}))).mutation(({ ctx, input }) => serializeRunTests(async () => {
+	})).annotate({ description: "Hook-injected session attribution UUIDs; do not pass manually." })
+});
+/**
+* The run body, promise-shaped because it drives Vitest's promise API and
+* the AsyncLocalStorage stdio capture; every failure is folded into the
+* `{ kind: "error" }` envelope, so it never rejects.
+*/
+const runTestsBody = async (input, ctx) => {
 	const files = input.files ? sanitizeTestArgs(input.files) : [];
 	const project = input.project ? sanitizeTestArgs([input.project])[0] : void 0;
 	const tagsInput = input.tags;
@@ -614,7 +631,7 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 		} : baseReport;
 		let classifications;
 		try {
-			classifications = await ctx.runtime.runPromise(Effect.gen(function* () {
+			classifications = await ctx.runPromise(Effect.gen(function* () {
 				const reader = yield* DataReader;
 				const projects = project ? [project] : yield* reader.getRunsByProject().pipe(Effect.map((rs) => rs.map((r) => r.project)));
 				const entries = [];
@@ -626,7 +643,7 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 			}));
 		} catch {}
 		const chatId = ctx.currentSessionId.get();
-		if (chatId !== null) ctx.runtime.runPromise(Effect.gen(function* () {
+		if (chatId !== null) ctx.runPromise(Effect.gen(function* () {
 			yield* (yield* DataStore).associateLatestRunWithSession({
 				chatId,
 				invocationMethod: "mcp"
@@ -679,7 +696,43 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 			} catch {}
 		}
 	}
-}));
+};
+/**
+* Handler for {@link runTestsTool}. Serialized through a one-permit
+* semaphore: the body assigns the active attribution UUIDs into
+* `process.env.VITEST_AGENT_*` and then awaits `createVitest` /
+* `vitest.start`, which spawns the worker pool that snapshots env at
+* spawn time — two interleaved calls would race, attributing one call's
+* results to the other's agent.
+*
+* @public
+*/
+const handleRunTests = (input) => Effect.gen(function* () {
+	const session = yield* McpSession;
+	const services = yield* Effect.context();
+	const ctx = {
+		cwd: session.cwd,
+		currentSessionId: session.currentSessionId,
+		sessionContext: session.sessionContext,
+		runPromise: (effect) => Effect.runPromise(Effect.provideContext(effect, services))
+	};
+	return yield* Semaphore.withPermit(runTestsSemaphore, Effect.promise(() => runTestsBody(input, ctx)));
+});
+/**
+* The Effect-native `run_tests` tool.
+*
+* @public
+*/
+const runTestsTool = Tool.make("run_tests", {
+	description: "Use to run Vitest tests, with optional file, project, and tag filters. structuredContent carries the typed AgentReport plus per-test classifications (discriminate on `kind`: ok, timeout, error, no-match). Unknown parameters are rejected — accepted keys are files, project, tags, passWithNoTests, timeout, projectRoot. When projectRoot is omitted, the server anchors the Vitest root at the directory of the vitest (or vite) config Vitest would load anyway, walking up from its boot dir and stopping at the git root — so a server booted inside a package subtree still resolves the root config's relative globalSetup/setupFiles correctly. projectRoot overrides that for this call and is used verbatim, but only after validation: it must be an existing directory belonging to the same git repository as ctx.cwd (checked via `git rev-parse --git-common-dir`, which is identical across a repo and all its worktrees, including a sibling worktree checked out from the same repo). A path in a different repository, or a non-existent path, is rejected with `{ kind: \"error\" }` naming both paths — never a silent fallback to ctx.cwd. The resolved root actually used is always echoed back on success. The legacy format=json arg is dropped — structuredContent supersedes it.",
+	parameters: RunTestsInput,
+	success: RunTestsResult,
+	dependencies: [
+		McpSession,
+		DataReader,
+		DataStore
+	]
+}).annotate(Tool.Title, "Run tests").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, false).annotate(RenderText, (encoded) => formatRunTestsMarkdown(encoded));
 
 //#endregion
-export { RunTestsAsMarkdown, RunTestsResult, coerceErrors, composeTagExpression, formatNoMatchMarkdown, formatReportMarkdown, formatRunTestsMarkdown, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveAnchoredConfigFile, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTests, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };
+export { RunTestsInput, RunTestsResult, coerceErrors, composeTagExpression, formatNoMatchMarkdown, formatReportMarkdown, formatRunTestsMarkdown, handleRunTests, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveAnchoredConfigFile, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTestsTool, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };

package/tools/settings-list.js

@@ -1,17 +1,18 @@
-import { publicProcedure } from "../context.js";
+import { RenderText } from "../annotations.js";
 import { Effect, Schema, SchemaGetter } from "effect";
-import { DataReader } from "@vitest-agent/sdk";
+import { DataReader } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
 
 //#region src/tools/settings-list.ts
-/**
-* `settings_list` MCP tool — Schema-driven implementation.
-*
-* @packageDocumentation
-*/
 const SettingsRow = Schema.Struct({
 	hash: Schema.String.annotate({ description: "Stable SHA-1 of the captured Vitest settings; FK target on test_runs." }),
 	capturedAt: Schema.String.annotate({ description: "ISO-8601 timestamp the settings row was first written." })
 }).annotate({ identifier: "SettingsListRow" });
+/**
+* The `settings_list` tool's success payload.
+*
+* @public
+*/
 const SettingsListResult = Schema.Struct({
 	count: Schema.Number,
 	settings: Schema.Array(SettingsRow).annotate({ description: "Distinct captured settings hashes the reporter has written, newest first." })
@@ -35,13 +36,29 @@ const SettingsListAsMarkdown = SettingsListResult.pipe(Schema.decodeTo(Schema.St
 	decode: SchemaGetter.transform((data) => formatSettingsListMarkdown(data)),
 	encode: SchemaGetter.forbidden(() => "SettingsListAsMarkdown is one-way.")
 }));
-const settingsList = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({}))).query(async ({ ctx }) => ctx.runtime.runPromise(Effect.gen(function* () {
+/**
+* Handler for {@link settingsListTool}.
+*
+* @public
+*/
+const handleSettingsList = () => Effect.gen(function* () {
 	const settings = yield* (yield* DataReader).listSettings();
 	return {
 		count: settings.length,
 		settings
 	};
-})));
+}).pipe(Effect.orDie);
+/**
+* The Effect-native `settings_list` tool. No parameters (the default
+* `Tool.EmptyParams` serves as a strict empty object).
+*
+* @public
+*/
+const settingsListTool = Tool.make("settings_list", {
+	description: "Use when you need every captured settings snapshot and its hash. Returns markdown in content[] and a typed JSON object in structuredContent ({ count, settings[] }).",
+	success: SettingsListResult,
+	dependencies: [DataReader]
+}).annotate(Tool.Title, "Settings list").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatSettingsListMarkdown(encoded));
 
 //#endregion
-export { SettingsListAsMarkdown, SettingsListResult, formatSettingsListMarkdown, settingsList };
+export { SettingsListResult, formatSettingsListMarkdown, handleSettingsList, settingsListTool };

package/tools/status.js

@@ -1,13 +1,10 @@
-import { publicProcedure } from "../context.js";
+import { RenderText } from "../annotations.js";
 import { Effect, Option, Schema, SchemaGetter } from "effect";
-import { CacheManifestEntry, DataReader } from "@vitest-agent/sdk";
+import { DataReader } from "@vitest-agent/engine";
+import { Tool } from "effect/unstable/ai";
+import { CacheManifestEntry } from "@vitest-agent/sdk";
 
 //#region src/tools/status.ts
-/**
-* `test_status` MCP tool — Schema-driven implementation.
-*
-* @packageDocumentation
-*/
 const StatusAvailable = Schema.Struct({
 	dataAvailable: Schema.Literal(true).annotate({ description: "Discriminant — `true` when at least one project entry exists in the manifest." }),
 	manifestUpdatedAt: Schema.String,
@@ -19,6 +16,11 @@ const StatusAbsent = Schema.Struct({
 	projectFilter: Schema.optional(Schema.String),
 	reason: Schema.Literals(["no_manifest", "project_filter_empty"])
 }).annotate({ identifier: "TestStatusAbsent" });
+/**
+* The `test_status` tool's success payload.
+*
+* @public
+*/
 const TestStatusResult = Schema.Union([StatusAvailable, StatusAbsent]).annotate({
 	identifier: "TestStatusResult",
 	title: "test_status result",
@@ -47,7 +49,19 @@ const TestStatusAsMarkdown = TestStatusResult.pipe(Schema.decodeTo(Schema.String
 	decode: SchemaGetter.transform((data) => formatTestStatusMarkdown(data)),
 	encode: SchemaGetter.forbidden(() => "TestStatusAsMarkdown is one-way.")
 }));
-const testStatus = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({ project: Schema.optional(Schema.String) }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
+/**
+* The `test_status` tool's parameters.
+*
+* @public
+*/
+const TestStatusInput = Schema.Struct({ project: Schema.optionalKey(Schema.String).annotate({ description: "Filter to a specific project" }) });
+/**
+* Handler for {@link testStatusTool}: the single implementation of the
+* tool.
+*
+* @public
+*/
+const handleTestStatus = (input) => Effect.gen(function* () {
 	const manifestOpt = yield* (yield* DataReader).getManifest();
 	if (Option.isNone(manifestOpt)) return {
 		dataAvailable: false,
@@ -67,7 +81,18 @@ const testStatus = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct
 		...input.project !== void 0 && { projectFilter: input.project },
 		entries
 	};
-})));
+}).pipe(Effect.orDie);
+/**
+* The Effect-native `test_status` tool.
+*
+* @public
+*/
+const testStatusTool = Tool.make("test_status", {
+	description: "Use when you need each project's current pass/fail state from the most recent run. Returns markdown in content[] and a typed JSON object in structuredContent ({ dataAvailable, manifestUpdatedAt, projectFilter?, entries[] } or absent variant).",
+	parameters: TestStatusInput,
+	success: TestStatusResult,
+	dependencies: [DataReader]
+}).annotate(Tool.Title, "Test status").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true).annotate(RenderText, (encoded) => formatTestStatusMarkdown(encoded));
 
 //#endregion
-export { TestStatusAsMarkdown, TestStatusResult, formatTestStatusMarkdown, testStatus };
+export { TestStatusInput, TestStatusResult, formatTestStatusMarkdown, handleTestStatus, testStatusTool };