@vitest-agent/mcp 4.3.2 → 5.0.1

package/tools/tdd-task.js

@@ -1,4 +1,5 @@
 import { IdempotentReplayMarker } from "../utils/replay-marker.js";
+import { McpToolkit, ToolFailure, ToolOutputSchema, ToolRefusal } from "@effected/mcp";
 import { Effect, Match, Option, Schema } from "effect";
 import { DataReader, DataStore } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
@@ -82,14 +83,14 @@ const TddTaskResumeMissing = Schema.Struct({
 	found: Schema.Literal(false),
 	tddTaskId: Schema.Number
 }).annotate({ identifier: "TddTaskResumeMissing" });
-const TddTaskResult = Schema.Union([
+const TddTaskResult = ToolOutputSchema.objectRooted(Schema.Union([
 	TddTaskStartOk,
 	TddTaskEndOk,
 	TddTaskGetFound,
 	TddTaskGetMissing,
 	TddTaskResumeFound,
 	TddTaskResumeMissing
-]).annotate({
+])).annotate({
 	identifier: "TddTaskResult",
 	title: "tdd_task result",
 	description: "Discriminate on `action`. `get` and `resume` further discriminate on `found`. `get` carries the full nested task tree."
@@ -134,8 +135,9 @@ const TddTaskInput = Schema.Union([
 ]);
 /**
 * Handler for {@link tddTaskTool}. A `start` with neither `sessionId` nor
-* `chatId`, an unknown `chatId`, or a blank `runId` fails as a defect (the
-* `UnexpectedToolError` envelope on the wire), as the retired tRPC procedure did.
+* `chatId`, an unknown `sessionId` or `chatId`, or a blank `runId` fails with a
+* {@link ToolRefusal} (an `isError` result naming the fix). A store failure is
+* a defect.
 *
 * @public
 */
@@ -144,13 +146,23 @@ const handleTddTask = (input) => Match.value(input).pipe(Match.discriminatorsExh
 		const reader = yield* DataReader;
 		const store = yield* DataStore;
 		let sessionId;
-		if (variant.sessionId !== void 0) sessionId = variant.sessionId;
-		else if (variant.chatId !== void 0) {
+		if (variant.sessionId !== void 0) {
+			if (Option.isNone(yield* reader.getSessionById(variant.sessionId))) return yield* Effect.fail(ToolRefusal.refuse(`Unknown sessionId ${variant.sessionId}.`, { hint: "Pass chatId (the host chat UUID) instead, or a sessionId that exists." }));
+			sessionId = variant.sessionId;
+		} else if (variant.chatId !== void 0) {
 			const opt = yield* reader.getSessionByChatId(variant.chatId);
-			if (Option.isNone(opt)) return yield* Effect.fail(/* @__PURE__ */ new Error(`Unknown chatId: ${variant.chatId}. Run record session-start first.`));
+			if (Option.isNone(opt)) return yield* Effect.fail(ToolRefusal.refuse(`Unknown chatId ${ToolFailure.truncate(variant.chatId)}: no session is recorded for it.`, { hint: "The plugin's SessionStart hook records the session (vitest-agent agent record session-start); check that it ran for this chat, or pass a sessionId that exists." }));
 			sessionId = opt.value.id;
-		} else return yield* Effect.fail(/* @__PURE__ */ new Error("tdd_task action=start: provide sessionId or chatId"));
-		if (variant.runId !== void 0 && variant.runId.trim().length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("tdd_task action=start: runId must not be blank"));
+		} else return yield* Effect.fail(ToolRefusal.refuse("tdd_task action='start' needs a session.", {
+			hint: "Pass sessionId (sessions.id) or chatId (the host chat UUID).",
+			suggestedTool: "tdd_task",
+			suggestedArgs: { action: "start" }
+		}));
+		if (variant.runId !== void 0 && variant.runId.trim().length === 0) return yield* Effect.fail(ToolRefusal.refuse("tdd_task action='start': runId must not be blank.", {
+			hint: "Omit runId, or pass a non-empty dispatch id.",
+			suggestedTool: "tdd_task",
+			suggestedArgs: { action: "start" }
+		}));
 		return {
 			action: "start",
 			tddTaskId: yield* store.writeTddTask({
@@ -234,18 +246,18 @@ const handleTddTask = (input) => Match.value(input).pipe(Match.discriminatorsExh
 			artifactsRecorded: tdd.artifacts.length
 		};
 	})
-})).pipe(Effect.orDie);
+})).pipe(Effect.catchTag("DataStoreError", Effect.die));
 /**
 * The Effect-native `tdd_task` tool.
 *
 * @public
 */
-const tddTaskTool = Tool.make("tdd_task", {
+const tddTaskTool = McpToolkit.unionTool("tdd_task", {
 	description: "Use to manage a TDD task lifecycle, with an action discriminator: action='start' (goal, sessionId|chatId, parentTddTaskId?, startedAt?, runId?) opens a new task; action='end' (tddTaskId, outcome, summaryNoteId?) closes one; action='get' (tddTaskId) returns the full task detail; action='resume' (tddTaskId) returns a compact digest.",
 	parameters: TddTaskInput,
 	success: TddTaskResult,
-	dependencies: [DataReader, DataStore]
-}).annotate(Tool.Title, "TDD task").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
+	failure: ToolRefusal
+}).addDependency(DataReader).addDependency(DataStore).annotate(Tool.Title, "TDD task").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
 export { TddTaskInput, TddTaskResult, handleTddTask, tddTaskTool };

package/tools/test.js

@@ -1,4 +1,5 @@
 import { collectProjectRows, resolveProjectTargets } from "./_project-groups.js";
+import { McpToolkit, ToolOutputSchema, ToolRefusal } from "@effected/mcp";
 import { Effect, Match, Option, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
@@ -149,7 +150,7 @@ const TestArtifactsResult = Schema.Struct({
 *
 * @public
 */
-const TestResult = Schema.Union([
+const TestResult = ToolOutputSchema.objectRooted(Schema.Union([
 	TestListResult,
 	TestGetFound,
 	TestGetMissing,
@@ -157,7 +158,7 @@ const TestResult = Schema.Union([
 	TestForTagResult,
 	TestAnnotationsResult,
 	TestArtifactsResult
-]).annotate({
+])).annotate({
 	identifier: "TestResult",
 	title: "test result",
 	description: "Discriminate on `action`. `get` further discriminates on `found`. `list`, `for_file`, `for_tag`, `annotations`, and `artifacts` all carry counted arrays — `list` and `for_tag` group by project; `annotations` and `artifacts` are scoped to one test and return attachment descriptors — an inline `body` comes back only when `maxBytes` is passed and the running total stays inside it."
@@ -335,12 +336,12 @@ const handleTest = (input) => Match.value(input).pipe(Match.discriminatorsExhaus
 *
 * @public
 */
-const testTool = Tool.make("test", {
+const testTool = McpToolkit.unionTool("test", {
 	description: "Use to inspect tests, with an action discriminator: action='list' (project?, state?, module?, limit?) returns matching tests; action='get' (fullName, project?, modulePath?) returns details + errors + run history — a fullName that exists in more than one module returns found=false with ambiguous=true and candidateModules[], so pass modulePath to disambiguate; action='for_file' (filePath) returns test modules covering a source file; action='for_tag' (tag, project?) returns tests carrying a tag, grouped by project; action='annotations' (fullName, project?, modulePath?) returns the test annotations the author recorded via context.annotate; action='artifacts' (fullName, project?, modulePath?) returns the test artifacts recorded for the test — both return attachment descriptors (contentType, path, byteSize) and omit inline bodies unless maxBytes (a non-negative integer byte budget for the whole response, default 0) is passed, and neither has anything to do with TDD artifacts (see tdd_artifact_list). structuredContent carries the typed payload (discriminate on `action`, then on `found` for get).",
 	parameters: TestInput,
 	success: TestResult,
-	dependencies: [DataReader]
-}).annotate(Tool.Title, "Test").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
+	failure: ToolRefusal
+}).addDependency(DataReader).annotate(Tool.Title, "Test").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.OpenWorld, false).annotate(Tool.Idempotent, true);
 
 //#endregion
 export { TestInput, TestResult, handleTest, testTool };

package/tools/trends.js

@@ -1,3 +1,4 @@
+import { ToolOutputSchema } from "@effected/mcp";
 import { Effect, Option, Schema } from "effect";
 import { DataReader } from "@vitest-agent/engine";
 import { Tool } from "effect/unstable/ai";
@@ -18,7 +19,7 @@ const TrendsAbsent = Schema.Struct({
 *
 * @public
 */
-const TestTrendsResult = Schema.Union([TrendsAvailable, TrendsAbsent]).annotate({
+const TestTrendsResult = ToolOutputSchema.objectRooted(Schema.Union([TrendsAvailable, TrendsAbsent])).annotate({
 	identifier: "TestTrendsResult",
 	title: "test_trends result",
 	description: "Coverage trend record per project. Discriminate on `dataAvailable` to handle the cold-start case."

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.2"
+      "packageVersion": "7.59.1"
     }
   ]
 }

package/version.js

@@ -7,7 +7,7 @@
 *
 * @public
 */
-const CURRENT_MCP_VERSION = "4.3.2";
+const CURRENT_MCP_VERSION = "5.0.1";
 
 //#endregion
 export { CURRENT_MCP_VERSION };

package/register-toolkit.js

@@ -1,328 +0,0 @@
-import { buildUnexpectedToolErrorEnvelope } from "./utils/tool-error-envelope.js";
-import { Cause, Context, Effect, ErrorReporter, Layer, Option, References, Result, Schema, Stream } from "effect";
-import { AiError, McpSchema, McpServer, Tool, Toolkit } from "effect/unstable/ai";
-import { HttpServerRequest } from "effect/unstable/http";
-
-//#region src/register-toolkit.ts
-const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-/** Top-level discriminants a union of parameter shapes may dispatch on. */
-const DISCRIMINANT_KEYS = ["action", "kind"];
-/** Length cap for every echoed unknown key, so a hostile payload cannot balloon the error. */
-const ECHO_LIMIT = 200;
-const truncate = (value) => value.length > ECHO_LIMIT ? `${value.slice(0, ECHO_LIMIT)}…` : value;
-const literalValues = (node) => {
-	if (!isPlainObject(node)) return void 0;
-	if (Array.isArray(node.enum)) return node.enum;
-	if ("const" in node) return [node.const];
-};
-/**
-* The discriminant every member of a union shares as a literal-valued
-* property, or `undefined` when the members do not form such a union.
-*/
-const findDiscriminant = (members) => {
-	if (members.length === 0) return void 0;
-	for (const key of DISCRIMINANT_KEYS) if (members.every((member) => {
-		if (!isPlainObject(member) || !isPlainObject(member.properties)) return false;
-		return literalValues(member.properties[key]) !== void 0;
-	})) return key;
-};
-const REF_PREFIX = "#/$defs/";
-const lookupRef = (ref, root) => {
-	if (typeof ref !== "string" || !ref.startsWith(REF_PREFIX)) return void 0;
-	const defs = root.$defs;
-	if (!isPlainObject(defs)) return void 0;
-	const target = defs[ref.slice(8)];
-	return isPlainObject(target) ? target : void 0;
-};
-/**
-* Replace a `$ref` node with its `$defs` target merged under the node's
-* own keywords (the node's keys win). Follows chained refs; gives up on a
-* cycle or a dangling ref and returns the node as-is.
-*/
-const inlineRef = (node, root, seen = /* @__PURE__ */ new Set()) => {
-	const target = lookupRef(node.$ref, root);
-	if (target === void 0 || seen.has(node.$ref)) return node;
-	const { $ref, ...rest } = node;
-	return inlineRef({
-		...target,
-		...rest
-	}, root, /* @__PURE__ */ new Set([...seen, $ref]));
-};
-/**
-* A schema whose root (or whose top-level union members) is a `$ref` —
-* what Effect emits for any schema carrying an `identifier` annotation —
-* is inlined so the object / discriminant checks below see the real
-* shape. `$defs` is kept for any nested references.
-*
-* @internal
-*/
-const inlineRootRefs = (schema) => {
-	const root = inlineRef(schema, schema);
-	const combinator = Array.isArray(root.anyOf) ? "anyOf" : Array.isArray(root.oneOf) ? "oneOf" : void 0;
-	if (combinator === void 0) return root;
-	const members = root[combinator].map((member) => isPlainObject(member) ? inlineRef(member, schema) : member);
-	return {
-		...root,
-		[combinator]: members
-	};
-};
-/**
-* Make an input JSON Schema servable as an MCP tool input: inline a `$ref`
-* root (and `$ref` members of a top-level union), and rewrite a top-level
-* union of discriminated object shapes to `{ type: "object", oneOf,
-* "x-discriminator" }` so it satisfies MCP's object-root requirement. The
-* object nodes themselves are left as Effect emitted them — closed, when the
-* document was built with `onExcessProperty: "error"`.
-*
-* @internal
-*/
-const objectRootedInputSchema = (schema) => {
-	const root = inlineRootRefs(schema);
-	const members = root.anyOf ?? root.oneOf;
-	if (Array.isArray(members) && root.type === void 0) {
-		const discriminant = findDiscriminant(members);
-		if (discriminant !== void 0) {
-			const { anyOf: _anyOf, oneOf: _oneOf, ...rest } = root;
-			return {
-				type: "object",
-				...rest,
-				oneOf: members,
-				"x-discriminator": discriminant
-			};
-		}
-	}
-	return root;
-};
-const resolveRef = (node, root) => lookupRef(node.$ref, root) ?? node;
-/** Pick the union member a payload object matches, or `undefined` when none does unambiguously. */
-const selectMember = (members, value, root) => {
-	const resolved = members.map((m) => isPlainObject(m) ? resolveRef(m, root) : m);
-	const discriminant = findDiscriminant(resolved);
-	if (discriminant !== void 0) {
-		const actual = value[discriminant];
-		return resolved.find((member) => {
-			if (!isPlainObject(member) || !isPlainObject(member.properties)) return false;
-			return literalValues(member.properties[discriminant])?.includes(actual) ?? false;
-		});
-	}
-	const objectMembers = resolved.filter((m) => isPlainObject(m) && isPlainObject(m.properties));
-	return objectMembers.length === 1 ? objectMembers[0] : void 0;
-};
-/**
-* Walk `value` against `schema`, collecting — at every object level — the
-* keys the payload carries that the schema does not declare.
-*
-* @internal
-*/
-const collectUnknownKeys = (value, schema) => {
-	const out = [];
-	const walk = (current, rawNode, path) => {
-		if (!isPlainObject(rawNode)) return;
-		const node = resolveRef(rawNode, schema);
-		if (Array.isArray(node.allOf)) {
-			const merged = {};
-			for (const member of node.allOf) {
-				const resolvedMember = isPlainObject(member) ? resolveRef(member, schema) : member;
-				if (isPlainObject(resolvedMember) && isPlainObject(resolvedMember.properties)) Object.assign(merged, resolvedMember.properties);
-			}
-			if (Object.keys(merged).length > 0) {
-				walk(current, {
-					...node,
-					allOf: void 0,
-					properties: {
-						...merged,
-						...isPlainObject(node.properties) ? node.properties : {}
-					}
-				}, path);
-				return;
-			}
-		}
-		if (isPlainObject(node.properties)) {
-			if (!isPlainObject(current)) return;
-			const accepted = Object.keys(node.properties);
-			const unknown = Object.keys(current).filter((key) => !accepted.includes(key));
-			if (unknown.length > 0 && node.additionalProperties !== true && !isPlainObject(node.additionalProperties)) out.push({
-				path,
-				unknown,
-				accepted
-			});
-			for (const key of accepted) if (key in current) walk(current[key], node.properties[key], [...path, key]);
-			if (isPlainObject(node.additionalProperties)) for (const key of unknown) walk(current[key], node.additionalProperties, [...path, key]);
-			return;
-		}
-		const members = node.oneOf ?? node.anyOf;
-		if (Array.isArray(members)) {
-			if (!isPlainObject(current)) return;
-			const member = selectMember(members, current, schema);
-			if (member !== void 0) walk(current, member, path);
-			return;
-		}
-		if (Array.isArray(current)) {
-			if (Array.isArray(node.prefixItems)) for (const [index, item] of node.prefixItems.entries()) walk(current[index], item, [...path, String(index)]);
-			if (isPlainObject(node.items)) for (const [index, item] of current.entries()) walk(item, node.items, [...path, String(index)]);
-			return;
-		}
-		if (isPlainObject(current) && node.type === "object" && node.additionalProperties === false) {
-			const unknown = Object.keys(current);
-			if (unknown.length > 0) out.push({
-				path,
-				unknown,
-				accepted: []
-			});
-		}
-	};
-	walk(value, schema, []);
-	return out;
-};
-/**
-* The exact wording the pre-Effect `strict()` helper produced, so agents
-* that learned to self-correct on it keep working.
-*/
-const formatUnknownKeys = (levels) => levels.map((level) => {
-	const qualify = (key) => truncate([...level.path, key].join("."));
-	const accepted = level.accepted.length === 0 ? "(none)" : level.accepted.join(", ");
-	return `Unrecognized parameter(s): ${level.unknown.map(qualify).join(", ")}. Accepted params: ${accepted}`;
-}).join(" ");
-/**
-* MCP models `structuredContent` as a JSON object, so a `null`, array or
-* primitive encoded result is omitted rather than sent through as-is.
-*/
-const toStructuredContent = (value) => isPlainObject(value) ? value : void 0;
-const toolErrorResult = (message) => new McpSchema.CallToolResult({
-	isError: true,
-	content: [{
-		type: "text",
-		text: message
-	}]
-});
-const toolResultContent = (encoded) => encoded === void 0 ? [] : [{
-	type: "text",
-	text: JSON.stringify(encoded)
-}];
-const omitRequestServices = Context.omit(McpSchema.McpRequestContext, McpSchema.McpServerClient, HttpServerRequest.HttpServerRequest, References.CurrentLogLevel);
-const isParameterValidationError = (error) => AiError.isAiError(error) && error.reason._tag === "ToolParameterValidationError";
-/**
-* The input JSON Schema a tool is served with: the document rc.116's
-* `toolInputJsonSchema` builds for a strict tool (`Schema.toJsonSchemaDocument`
-* with `onExcessProperty: "error"`, so every object node carries
-* `additionalProperties: false`; definitions attached as `$defs`), made
-* object-rooted by {@link objectRootedInputSchema}.
-*
-* @internal
-*/
-const servedInputJsonSchema = (schema) => {
-	const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: "error" });
-	return objectRootedInputSchema(Object.keys(document.definitions).length === 0 ? document.schema : {
-		...document.schema,
-		$defs: document.definitions
-	});
-};
-const envelopeResult = (toolName, err) => {
-	const envelope = buildUnexpectedToolErrorEnvelope(toolName, err);
-	return new McpSchema.CallToolResult({
-		isError: true,
-		structuredContent: envelope,
-		content: [{
-			type: "text",
-			text: JSON.stringify(envelope)
-		}]
-	});
-};
-/**
-* Register every tool of `toolkit` with the ambient `McpServer` under the
-* strict contract described in the module docs. A port of rc.116's
-* `McpServer.registerToolkit`; the deviations are enumerated in the module
-* header.
-*
-* @internal
-*/
-const registerStrictToolkitEffect = Effect.fnUntraced(function* (toolkit) {
-	const registry = yield* McpServer.McpServer;
-	const built = yield* toolkit.pipe(Effect.updateContext((context) => {
-		const services = new Map(context.mapUnsafe);
-		for (const tool of Object.values(toolkit.tools)) {
-			const handler = services.get(tool.id);
-			if (handler !== void 0) services.set(tool.id, {
-				...handler,
-				context: omitRequestServices(handler.context)
-			});
-		}
-		return Context.makeUnsafe(services);
-	}));
-	const services = omitRequestServices(yield* Effect.context());
-	const reportCause = (cause) => Effect.provideContext(ErrorReporter.report(cause), services);
-	const registrations = [];
-	for (const tool of Object.values(built.tools)) {
-		const internalToolError = (cause) => {
-			const failure = Cause.findFail(cause);
-			return Result.isFailure(failure) && !Cause.hasDies(cause) ? Effect.failCause(failure.failure) : Effect.logError(`tool ${tool.name} failed`, cause).pipe(Effect.andThen(reportCause(cause)), Effect.as(envelopeResult(tool.name, Result.isSuccess(failure) ? failure.success.error : Cause.squash(cause))));
-		};
-		if (Tool.isDynamic(tool)) return yield* Effect.die(`McpServer cannot strictly validate the raw JSON Schema for tool '${tool.name}'; use an Effect Schema instead`);
-		const decodeOptions = { onExcessProperty: "error" };
-		const annotations = tool.annotations;
-		const toolMeta = Context.getOrUndefined(annotations, Tool.Meta);
-		const isDeclaredFailure = Schema.is(tool.failureSchema);
-		const encodeFailure = Schema.encodeUnknownEffect(tool.failureSchema);
-		const declaredFailureResult = (error) => error instanceof Error ? Effect.succeed(toolErrorResult(error.message)) : Effect.map(encodeFailure(error), (encoded) => new McpSchema.CallToolResult({
-			isError: true,
-			content: toolResultContent(encoded)
-		}));
-		const handleCause = (cause) => {
-			const failure = Cause.findFail(cause);
-			if (Result.isSuccess(failure)) {
-				const error = failure.success.error;
-				const origin = Context.get(Cause.reasonAnnotations(failure.success), Toolkit.FailureOrigin);
-				if (origin === "parameters" && isParameterValidationError(error)) return Effect.fail(new McpSchema.InvalidParams({ message: error.reason.message }));
-				if (origin === "handler" && isDeclaredFailure(error)) return Effect.catchCause(declaredFailureResult(error), internalToolError);
-			}
-			return internalToolError(cause);
-		};
-		const outputJsonSchema = inlineRootRefs(Tool.getJsonSchemaFromSchema(tool.successSchema));
-		const outputSchema = outputJsonSchema.type === "object" ? yield* Schema.decodeUnknownEffect(McpSchema.ToolOutputJson)(outputJsonSchema).pipe(Effect.orDie) : void 0;
-		const servedInput = servedInputJsonSchema(tool.parametersSchema);
-		const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJson)(servedInput).pipe(Effect.orDie);
-		const description = Tool.getDescription(tool);
-		const mcpTool = new McpSchema.Tool({
-			name: tool.name,
-			...description === void 0 ? {} : { description },
-			inputSchema,
-			...outputSchema === void 0 ? {} : { outputSchema },
-			annotations: {
-				...Context.getOption(annotations, Tool.Title).pipe(Option.map((title) => ({ title })), Option.getOrUndefined),
-				readOnlyHint: Context.get(annotations, Tool.Readonly),
-				destructiveHint: Context.get(annotations, Tool.Destructive),
-				idempotentHint: Context.get(annotations, Tool.Idempotent),
-				openWorldHint: Context.get(annotations, Tool.OpenWorld)
-			},
-			...toolMeta === void 0 ? {} : { _meta: toolMeta }
-		});
-		registrations.push({
-			tool: mcpTool,
-			annotations,
-			handle(payload) {
-				const raw = payload ?? {};
-				const unknownKeys = collectUnknownKeys(raw, servedInput);
-				if (unknownKeys.length > 0) return Effect.fail(new McpSchema.InvalidParams({ message: formatUnknownKeys(unknownKeys) }));
-				return built.handle(tool.name, raw, void 0, decodeOptions).pipe(Stream.unwrap, Stream.runLast, Effect.flatMap(Effect.fromOption), Effect.flatMap((result) => result.isFailure && result.failureOrigin !== "handler" ? Effect.failCause(Cause.annotate(Cause.fail(result.result), Context.make(Toolkit.FailureOrigin, result.failureOrigin ?? "result"))) : Effect.succeed(new McpSchema.CallToolResult({
-					isError: result.isFailure,
-					structuredContent: result.isFailure ? void 0 : toStructuredContent(result.encodedResult),
-					content: toolResultContent(result.encodedResult)
-				}))), Effect.catchCause(handleCause), Effect.provideContext(services));
-			}
-		});
-	}
-	for (const registration of registrations) yield* registry.addTool(registration);
-});
-/**
-* A layer that registers `toolkit` with the strict contract. Same shape
-* as `McpServer.toolkit`: it requires the toolkit's handlers (from
-* `kit.toLayer(handlers)`) and every service the tools declare in
-* `dependencies`, and shares the memoized `McpServer` with the transport
-* layer it is provided into.
-*
-* @public
-*/
-const registerStrictToolkit = (toolkit) => Layer.effectDiscard(registerStrictToolkitEffect(toolkit)).pipe(Layer.provide(McpServer.McpServer.layer));
-
-//#endregion
-export { collectUnknownKeys, inlineRootRefs, objectRootedInputSchema, registerStrictToolkit, registerStrictToolkitEffect, servedInputJsonSchema };

package/utils/crash-guards.js

@@ -1,13 +0,0 @@
-//#region src/utils/crash-guards.ts
-/**
-* @param transportConnected - whether `server.connect(transport)` has
-*   already resolved for this process
-* @returns `true` when the process should exit rather than continue
-* @public
-*/
-function shouldExitOnUncaughtException(transportConnected) {
-	return !transportConnected;
-}
-
-//#endregion
-export { shouldExitOnUncaughtException };

package/utils/tool-error-envelope.js

@@ -1,61 +0,0 @@
-//#region src/utils/tool-error-envelope.ts
-/**
-* Fixed fallback used when even *introspecting* the thrown value throws.
-* Deliberately a constant — anything derived from `err` could throw again
-* on the recovery path.
-*/
-const UNREADABLE_THROWN_VALUE = "<unreadable thrown value>";
-/**
-* Coerces an unknown thrown value into a display-safe message without
-* risking a second throw (a getter-backed `.message` can itself throw —
-* see `@vitest-agent/sdk`'s `coerceErrorField` for the same concern on
-* raw Vitest error objects).
-*
-* The outer guard matters as much as the inner one: `err instanceof
-* Error` walks the prototype chain, which a `Proxy` `getPrototypeOf`
-* trap can hijack and throw from, and `String(err)` invokes
-* `Symbol.toPrimitive` / `toString`, which a trap can hijack too. A
-* throw here escapes the envelope builder entirely and the agent gets
-* nothing structured back — the exact degradation this module exists to
-* prevent (issue #243).
-*/
-function coerceThrownMessage(err) {
-	try {
-		if (typeof err === "string") return err;
-		if (err instanceof Error) try {
-			const message = err.message;
-			return typeof message === "string" ? message : String(message);
-		} catch {
-			return "<unreadable Error.message>";
-		}
-		return String(err);
-	} catch {
-		return UNREADABLE_THROWN_VALUE;
-	}
-}
-/**
-* Builds the structured envelope a tool's catch-all wrapper returns
-* when its handler throws unexpectedly.
-*
-* @param toolName - the MCP tool name under which the handler was registered
-* @param err - the value thrown or the rejection reason
-* @public
-*/
-function buildUnexpectedToolErrorEnvelope(toolName, err) {
-	return {
-		ok: false,
-		error: {
-			_tag: "UnexpectedToolError",
-			tool: toolName,
-			message: coerceThrownMessage(err),
-			remediation: {
-				suggestedTool: toolName,
-				suggestedArgs: {},
-				humanHint: `The "${toolName}" tool's handler threw before producing a result (unrelated to your input in most cases). Retry the call; if it persists, check the MCP server's stderr for the logged error.`
-			}
-		}
-	};
-}
-
-//#endregion
-export { buildUnexpectedToolErrorEnvelope };