@effected/mcp 0.11.0 → 0.13.0

package/McpProbe.js

@@ -1,94 +0,0 @@
-import { ToolFailure } from "./ToolFailure.js";
-import { DEFAULT_CLIENT_INFO, STDERR_HINT, frame, initializeParams, isJsonRpcMessage, isResponse, isStateless, parseFrame } from "./internal/wire.js";
-import { McpTestFailure } from "./McpTestFailure.js";
-import { McpProcess } from "./McpProcess.js";
-import { Effect } from "effect";
-import { McpProtocol } from "effect/ai";
-
-// src/McpProbe.ts
-/**
-* The smallest proof that an installed MCP bin boots: one initialize, a clean
-* close, and exit 0.
-*
-* @remarks
-* Stdin stays open until the id-1 response has arrived. Closing it right
-* after writing proves nothing against a server that stops at stdin EOF
-* without answering what is in flight: it replies nothing and exits 0, so a
-* slow boot reads as a pass with no response. The caller asserts `response.error === undefined`, `stderr` is
-* empty and `exitCode` is 0; this is the MCP half of a packed-install proof.
-* Checking stderr and the exit code alone passes a server that answers
-* the handshake with a JSON-RPC error, exits 0 and writes nothing.
-*
-* - Any stdout line that is not JSON-RPC fails with `NotJsonRpc`, naming the
-*   line: a server that logs to stdout corrupts the wire, so the probe fails
-*   rather than skipping the line.
-* - A child that exits before responding fails with `StreamEnded`, and the
-*   message carries its exit code and stderr.
-* - A child that ignores stdin EOF never exits, and the probe waits for it.
-*   Wrap the probe in `Effect.timeout`.
-*
-* @example
-* ```ts
-* import { McpProbe } from "@effected/mcp/testing";
-* import { Effect } from "effect";
-* import { ChildProcess } from "effect/process";
-*
-* const program = Effect.gen(function* () {
-* 	const probe = yield* McpProbe.initialize(ChildProcess.make(process.execPath, ["./bin/server.js"]));
-* 	// A clean boot: no JSON-RPC error, empty stderr, exit code 0.
-* 	return probe.response.error === undefined && probe.stderr === "" && probe.exitCode === 0;
-* });
-* // Requires a `ChildProcessSpawner` from the platform layer.
-* ```
-*
-* @public
-*/
-var McpProbe = class {
-	constructor() {}
-	/**
-	* Spawn `command`, send one `initialize` (or `server/discover` on a
-	* stateless revision) as id 1, wait for its response, close stdin, and
-	* collect stdout, stderr and the exit code.
-	*/
-	static initialize = (command, options = {}) => Effect.scoped(Effect.gen(function* () {
-		const child = yield* McpProcess.spawn(command);
-		const protocol = options.protocol ?? McpProtocol.v2025_11_25;
-		const stateless = isStateless(protocol);
-		yield* child.send(frame(protocol, DEFAULT_CLIENT_INFO, stateless ? "server/discover" : "initialize", stateless ? {} : initializeParams(protocol, DEFAULT_CLIENT_INFO), 1));
-		const stdout = [];
-		const read = Effect.gen(function* () {
-			const line = yield* child.nextLine;
-			stdout.push(line);
-			const message = parseFrame(line);
-			if (!isJsonRpcMessage(message)) return yield* new McpTestFailure({
-				reason: "NotJsonRpc",
-				message: `stdout carried a line that is not JSON-RPC: ${ToolFailure.truncate(line)}`
-			});
-			return message;
-		});
-		const diagnose = (failure) => failure.reason !== "StreamEnded" ? Effect.fail(failure) : Effect.gen(function* () {
-			const code = yield* child.exitCode;
-			const stderr = yield* child.stderrFinal;
-			return yield* new McpTestFailure({
-				reason: "StreamEnded",
-				message: `${failure.message.replace(STDERR_HINT, "")}; the child exited with code ${code}; stderr: ${stderr === "" ? "(empty)" : ToolFailure.truncate(stderr)}`
-			});
-		});
-		let response;
-		while (response === void 0) {
-			const message = yield* Effect.catch(read, diagnose);
-			if (isResponse(message) && message.id === 1) response = message;
-		}
-		yield* child.closeStdin;
-		const exitCode = yield* child.exitCode;
-		while (true) if (!(yield* Effect.catch(Effect.map(read, () => true), (failure) => failure.reason === "StreamEnded" ? Effect.succeed(false) : Effect.fail(failure)))) break;
-		return {
-			response,
-			stdout,
-			stderr: yield* child.stderrFinal,
-			exitCode
-		};
-	}));
-};
-
-export { McpProbe };

package/McpProcess.js

@@ -1,196 +0,0 @@
-import { ToolFailure } from "./ToolFailure.js";
-import { DEFAULT_CLIENT_INFO, STDERR_HINT, frame, initializeParams, isJsonRpcMessage, isResponse, isStateless, parseFrame } from "./internal/wire.js";
-import { McpTestFailure } from "./McpTestFailure.js";
-import { Deferred, Duration, Effect, Option, Queue, Ref, Stream, SubscriptionRef } from "effect";
-import { McpProtocol } from "effect/ai";
-import { ChildProcessSpawner } from "effect/process";
-
-// src/McpProcess.ts
-/**
-* A spawned MCP server bin a test writes to while it runs.
-*
-* @remarks
-* Build the command in the test file with `execPath` and an explicit `env`:
-* `ChildProcess.make(process.execPath, [bin], { env })`.
-*
-* - `nextLine` fails with `StreamEnded` when stdout ends, so a child that
-*   exits early fails the test instead of hanging it.
-* - `send` writes one JSON-encoded line; `sendRaw` writes a string or bytes
-*   exactly as given, for a malformed frame or one frame split across
-*   writes, even mid-character.
-* - `readUntilResponse` reads past interleaved notifications, such as
-*   `list_changed`, to the matching id and returns what it saw.
-* - `closeStdin` is `Queue.end`, never `Queue.shutdown`, so every frame
-*   already sent is delivered before stdin closes.
-* - A request in flight when stdin closes still answers from an Effect
-*   server, which drains before it exits; a server that does not drain
-*   drops it, so a portable client reads the response first.
-*
-* @example
-* ```ts
-* import { McpProcess } from "@effected/mcp/testing";
-* import { Effect } from "effect";
-* import { ChildProcess } from "effect/process";
-*
-* const program = Effect.gen(function* () {
-* 	const child = yield* McpProcess.spawn(ChildProcess.make(process.execPath, ["./bin/server.js"]));
-* 	yield* child.handshake();
-* 	yield* child.send({ jsonrpc: "2.0", id: 2, method: "tools/list" });
-* 	const { response } = yield* child.readUntilResponse(2);
-* 	yield* child.closeStdin;
-* 	return response;
-* }).pipe(Effect.scoped);
-* // Requires a `ChildProcessSpawner` from the platform layer.
-* ```
-*
-* @public
-*/
-var McpProcess = class McpProcess {
-	/**
-	* Write one JSON-encoded, newline-framed message to the child's stdin.
-	*
-	* @remarks
-	* Never fails. A frame sent after `closeStdin` is dropped, and a write the
-	* child can no longer receive fails the stdin pump instead; the next
-	* `StreamEnded` message names that failure.
-	*/
-	send;
-	/**
-	* Write `text` to the child's stdin exactly as given: a string as UTF-8,
-	* bytes unchanged, with no JSON encoding and no newline added.
-	*
-	* @remarks
-	* For frames `send` cannot produce: a line that is not JSON, a blank line,
-	* or one frame split across several writes, including mid-character by
-	* passing bytes. Include the `\n` yourself.
-	* Never fails, on the same terms as `send`.
-	*/
-	sendRaw;
-	/** The next non-empty stdout line; fails with `StreamEnded` once stdout ends. */
-	nextLine;
-	/** Read JSON-RPC lines up to and including the response with this id. */
-	readUntilResponse;
-	/** `initialize` (id 1) then `notifications/initialized`, or `server/discover` (id 1) on a stateless revision. Use ids of 2 or more for your own requests. */
-	handshake;
-	/** End stdin after every frame already sent. */
-	closeStdin;
-	/** Wait for the child to exit. */
-	exitCode;
-	/** Everything written to stderr so far. */
-	stderrSoFar;
-	/**
-	* Wait until everything written to stderr so far satisfies `predicate`,
-	* and return that text.
-	*
-	* @remarks
-	* Event-driven: the predicate is checked against the current text at once,
-	* then again on every chunk the child writes, never on a polling timer.
-	* Fails with `StreamEnded` when stderr ends (the child exited) without the
-	* predicate holding, and with `TimedOut` once `options.timeout` passes;
-	* both messages carry the stderr seen so far. Reach for it whenever a
-	* report lands on a later tick than the responses a test reads, such as
-	* `McpGuard`'s `injectCrash: { at: "connected" }` report, instead of
-	* reading `stderrSoFar` once. `options.timeout` is real time: run the test
-	* under `it.live`.
-	*/
-	stderrUntil;
-	/** Everything written to stderr, once stderr has ended. Waits for the child to exit. */
-	stderrFinal;
-	constructor(parts) {
-		this.send = parts.send;
-		this.sendRaw = parts.sendRaw;
-		this.nextLine = parts.nextLine;
-		this.readUntilResponse = parts.readUntilResponse;
-		this.handshake = parts.handshake;
-		this.closeStdin = parts.closeStdin;
-		this.exitCode = parts.exitCode;
-		this.stderrSoFar = parts.stderrSoFar;
-		this.stderrUntil = parts.stderrUntil;
-		this.stderrFinal = parts.stderrFinal;
-	}
-	/** Spawn `command` for the life of the current scope. */
-	static spawn = (command) => Effect.gen(function* () {
-		const handle = yield* (yield* ChildProcessSpawner.ChildProcessSpawner).spawn(command);
-		const encoder = new TextEncoder();
-		const stdin = yield* Queue.unbounded();
-		const stdinFailure = yield* Ref.make(void 0);
-		yield* Stream.run(Stream.fromQueue(stdin), handle.stdin).pipe(Effect.catch((error) => Ref.set(stdinFailure, error.message)), Effect.forkScoped);
-		const lines = yield* Queue.unbounded();
-		yield* Stream.splitLines(Stream.decodeText(handle.stdout)).pipe(Stream.runForEach((line) => line.length === 0 ? Effect.void : Effect.asVoid(Queue.offer(lines, line))), Effect.ensuring(Queue.end(lines)), Effect.forkScoped);
-		const stderr = yield* SubscriptionRef.make({
-			text: "",
-			done: false
-		});
-		const stderrDone = yield* Deferred.make();
-		yield* Stream.decodeText(handle.stderr).pipe(Stream.runForEach((text) => SubscriptionRef.update(stderr, (sofar) => ({
-			text: sofar.text + text,
-			done: false
-		}))), Effect.ensuring(Effect.andThen(SubscriptionRef.update(stderr, (sofar) => ({
-			text: sofar.text,
-			done: true
-		})), Deferred.succeed(stderrDone, void 0))), Effect.forkScoped);
-		const stderrText = Effect.map(SubscriptionRef.get(stderr), (state) => state.text);
-		const stderrUntil = (predicate, options) => SubscriptionRef.changes(stderr).pipe(Stream.filter((state) => state.done || predicate(state.text)), Stream.runHead, Effect.flatMap((found) => {
-			const state = Option.getOrElse(found, () => ({
-				text: "",
-				done: true
-			}));
-			return predicate(state.text) ? Effect.succeed(state.text) : Effect.fail(new McpTestFailure({
-				reason: "StreamEnded",
-				message: `the server's stderr ended before it matched; stderr: ${ToolFailure.truncate(state.text, ToolFailure.ENGINE_ECHO_LIMIT)}`
-			}));
-		}), Effect.timeoutOrElse({
-			duration: options.timeout,
-			orElse: () => Effect.flatMap(stderrText, (text) => Effect.fail(new McpTestFailure({
-				reason: "TimedOut",
-				message: `the server's stderr did not match within ${Duration.format(Duration.fromInputUnsafe(options.timeout))}; stderr so far: ${ToolFailure.truncate(text, ToolFailure.ENGINE_ECHO_LIMIT)}`
-			})))
-		}));
-		const nextLine = Queue.take(lines).pipe(Effect.catch(() => Effect.flatMap(Ref.get(stdinFailure), (pump) => Effect.fail(new McpTestFailure({
-			reason: "StreamEnded",
-			message: `the server's stdout ended before the expected line${STDERR_HINT}${pump === void 0 ? "" : `; stdin pump failed: ${ToolFailure.truncate(pump)}`}`
-		})))));
-		const readUntilResponse = (id) => Effect.gen(function* () {
-			const seen = [];
-			while (true) {
-				const line = yield* nextLine;
-				const message = parseFrame(line);
-				if (!isJsonRpcMessage(message)) return yield* new McpTestFailure({
-					reason: "NotJsonRpc",
-					message: `stdout carried a line that is not JSON-RPC: ${ToolFailure.truncate(line)}`
-				});
-				seen.push(message);
-				if (isResponse(message) && message.id === id) return {
-					response: message,
-					seen
-				};
-			}
-		});
-		const sendRaw = (text) => Effect.asVoid(Queue.offer(stdin, typeof text === "string" ? encoder.encode(text) : text));
-		const send = (message) => sendRaw(`${JSON.stringify(message)}\n`);
-		const handshake = (protocol = McpProtocol.v2025_11_25) => Effect.gen(function* () {
-			if (isStateless(protocol)) {
-				yield* send(frame(protocol, DEFAULT_CLIENT_INFO, "server/discover", {}, 1));
-				return (yield* readUntilResponse(1)).response;
-			}
-			yield* send(frame(protocol, DEFAULT_CLIENT_INFO, "initialize", initializeParams(protocol, DEFAULT_CLIENT_INFO), 1));
-			const { response } = yield* readUntilResponse(1);
-			yield* send(frame(protocol, DEFAULT_CLIENT_INFO, "notifications/initialized", void 0));
-			return response;
-		});
-		return new McpProcess({
-			send,
-			sendRaw,
-			nextLine,
-			readUntilResponse,
-			handshake,
-			closeStdin: Effect.asVoid(Queue.end(stdin)),
-			exitCode: Effect.map(handle.exitCode, (code) => Number(code)),
-			stderrSoFar: stderrText,
-			stderrUntil,
-			stderrFinal: Effect.andThen(Deferred.await(stderrDone), stderrText)
-		});
-	});
-};
-
-export { McpProcess };

package/McpStdio.js

@@ -1,159 +0,0 @@
-import { LaunchFailed } from "./internal/LaunchFailed.js";
-import { makeGuardedStdio } from "./internal/StdinFrames.js";
-import { Cause, Effect, Exit, Layer, References, Runtime } from "effect";
-import { McpProtocol, McpServer } from "effect/ai";
-
-// src/McpStdio.ts
-/**
-* Serve an MCP server over stdio without ever writing a log line or a failure
-* report onto stdout, which is the JSON-RPC wire.
-*
-* @remarks
-* The one-line `main.ts`:
-*
-* ```ts
-* NodeRuntime.runMain(McpStdio.launch(Main), { teardown: McpStdio.teardown })
-* ```
-*
-* - {@link McpStdio.layer} is `McpServer.layerStdio` with `LogToStderr`
-*   provided and merged into its output, and `Layer.orDie`. It answers a
-*   stdin line that is not JSON with a JSON-RPC `-32700` parse error, and
-*   JSON that is not a JSON-RPC message with `-32600`, and keeps serving.
-* - {@link McpStdio.launch} reports a launch failure itself, on stderr, and
-*   hides it from `runMain`, whose own report is written outside anything
-*   the program can provide.
-* - {@link McpStdio.teardown} maps stdin EOF, the normal end of every
-*   session, to exit 0 instead of 130.
-*
-* Never `NodeRuntime.runMain(Layer.launch(Main).pipe(Effect.provideService(References.LogToStderr, true)))`:
-* it typechecks and serves, but a launch failure is still reported by
-* `runMain` through `console.log`, straight onto the wire, where the client
-* reads it as a malformed frame instead of an error.
-*
-* @public
-*/
-var McpStdio = class McpStdio {
-	constructor() {}
-	/**
-	* `[v2026_07_28, v2025_11_25, v2025_06_18]` — the stateless revision
-	* first, then the two newest stateful ones.
-	*
-	* @remarks
-	* Real clients open with either handshake: some (Claude Code, for one)
-	* open a stdio server with the stateless `server/discover`, while others
-	* still send `initialize`. The order is load-bearing:
-	*
-	* - Stateless first: a request with no session and no `_meta` falls to
-	*   `protocols[0]`.
-	* - Never a single entry: `initialize` only matches stateful adapters, so
-	*   a stateless-only list refuses every client that opens with it.
-	* - At most one stateless adapter; a second fails the layer.
-	*/
-	static protocols = [
-		McpProtocol.v2026_07_28,
-		McpProtocol.v2025_11_25,
-		McpProtocol.v2025_06_18
-	];
-	/**
-	* `McpServer.layerStdio` with `LogToStderr` provided and merged into the
-	* output, so every layer it provides logs to stderr too. A bad
-	* `protocols` list dies: it is the implementer's defect.
-	*
-	* @remarks
-	* Only a layer this one provides inherits `LogToStderr`: compose with
-	* `Layer.provideMerge(McpStdio.layer(...))`. A sibling merged beside it
-	* with `Layer.mergeAll` is not provided by it, so its build logs still
-	* go through `console.log`, onto the wire.
-	
-	*
-	* `LogToStderr` only reaches a logger that reads it: Effect's default
-	* logger and `Logger.consolePretty`. `Logger.consoleJson`,
-	* `Logger.consoleLogFmt` and `Logger.consoleStructured` are built with
-	* `Logger.withConsoleLog`, which writes through `console.log` whatever
-	* `LogToStderr` says, so a server that installs one puts every log line on
-	* the wire. Never install them under this layer; wrap the formatter in
-	* `Logger.withConsoleError` instead, as in
-	* `Logger.layer([Logger.withConsoleError(Logger.formatJson)])`.
-	*
-	* The server reads stdin through a guard that frames it exactly as core's
-	* decoder does: one streaming UTF-8 decoder, a byte-order mark stripped
-	* only at the start of the stream, lines split on `\n`. Core itself skips
-	* a line it cannot use and keeps serving, but sends no reply, where
-	* JSON-RPC 2.0 requires one; the guard supplies it. A line that is not
-	* JSON is answered on stdout with a parse error, code `-32700` and
-	* `id: null`, and never reaches core. So is a line longer than core's cap
-	* of 16 Mi UTF-16 code units: it is answered once, as soon as it passes
-	* the cap, and the rest of it is discarded up to its newline (core would
-	* log it on stderr and drop it). A line of JSON whitespace (space, tab,
-	* carriage return) is ignored.
-	*
-	* A line that is JSON but no JSON-RPC message core can handle is answered
-	* with an Invalid Request, code `-32600` and `id: null`, and never reaches
-	* core: a value that is neither an object nor an array, an object whose
-	* `method` is not a string and whose `id` is absent or `null`, and an
-	* object with neither `method` nor `id`, which is neither a request nor a
-	* response.
-	*
-	* Everything else goes to core: an array, which core answers `-32600`
-	* itself because it serves no batches; an object with an `id` and no
-	* `method`, which is a response and gets no reply; and a request with an
-	* `id`, which core answers even when its `method` is malformed.
-	*
-	* Give each server a fresh layer memo map. Core's stdio protocol layer
-	* is a shared constant, so a second `McpStdio.layer` server whose build
-	* sees the first one's memo map shares its protocol: only the first
-	* server reads stdin, and the second never answers. Merging both into
-	* one graph does that, and so does building or providing the second
-	* anywhere under the first one's `Effect.provide`: nested `Layer.build`
-	* and `Effect.provide` fork the ambient memo map rather than starting a
-	* new one. The tool registry is shared the same way. Isolate each server
-	* by wrapping its whole bundle (its toolkit layers together with this
-	* layer) in `Layer.fresh`, or with its own `ManagedRuntime`,
-	* `Effect.provide(layer, { local: true })` or its own process. Never put
-	* the `Layer.fresh` boundary between a toolkit and this layer: the server
-	* would serve an empty registry.
-	*
-	* Code after a completed `Effect.provide` of a stdio server never runs:
-	* core's stdio protocol interrupts the fiber that built it when its stdin
-	* loop ends, which closing the provide's scope does. In a test, serve the
-	* layer through `McpHarness` from `@effected/mcp/testing` instead.
-	*
-	* Each call mints a fresh layer; bind the result to a `const` or the
-	* server builds twice.
-	*/
-	static layer = (options) => McpServer.layerStdio({
-		name: options.name,
-		version: options.version,
-		instructions: options.instructions,
-		description: options.description,
-		protocols: options.protocols ?? McpStdio.protocols
-	}).pipe(Layer.provide(makeGuardedStdio()), Layer.provideMerge(Layer.succeed(References.LogToStderr, true)), Layer.orDie);
-	/**
-	* `Layer.launch`, with any failure other than an interrupt logged on
-	* stderr here and re-raised marked as already reported, keeping its exit
-	* code.
-	*
-	* @remarks
-	* `runMain` logs an unhandled failure from outside the program, where no
-	* `Effect.provideService` reaches, and Effect's default logger writes
-	* through `console.log` unless `LogToStderr` is set. For an MCP server
-	* that is stdout, which is the wire.
-	*
-	* `options.onReady` runs after the layer has built and before the launch
-	* waits forever, as {@link McpLaunchOptions.onReady} describes.
-	*/
-	static launch = (layer, options = {}) => (options.onReady === void 0 ? Layer.launch(layer) : Effect.scoped(Layer.build(layer).pipe(Effect.andThen(options.onReady), Effect.andThen(Effect.never)))).pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : Effect.logError(cause).pipe(Effect.andThen(Effect.fail(new LaunchFailed(Runtime.getErrorExitCode(Cause.squash(cause))))))), Effect.provideService(References.LogToStderr, true));
-	/**
-	* Success or an interrupt-only exit maps to 0. Anything else goes to
-	* `Runtime.defaultTeardown`.
-	*
-	* @remarks
-	* Stdin EOF, the normal end of every session, ends in an interrupt-only
-	* exit, and so do SIGINT and SIGTERM: `runMain` interrupts the program on
-	* either signal. All three exit 0 here, not the 130 a default teardown
-	* reports for an interrupt.
-	*/
-	static teardown = (exit, onExit) => Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) ? onExit(0) : Runtime.defaultTeardown(exit, onExit);
-};
-
-export { McpStdio };

package/McpTestFailure.js

@@ -1,49 +0,0 @@
-import { Schema } from "effect";
-
-// src/McpTestFailure.ts
-/**
-* Why an MCP test client could not produce what was asked of it.
-*
-* @remarks
-* Each reason is raised by a specific client, and not every client raises
-* every reason:
-*
-* - `StreamEnded` (`McpProcess`, `McpProbe`): the spawned child's stdout
-*   ended first, because the child exited. `McpProbe` folds the exit code
-*   and stderr into the message. `McpProcess.stderrUntil` raises it when
-*   stderr ends before its predicate holds.
-* - `TimedOut` (`McpProcess.stderrUntil`): the predicate did not hold
-*   within the given timeout. The message carries the stderr seen so far.
-* - `NotJsonRpc` (`McpProcess.readUntilResponse`, `McpProbe`): a spawned
-*   child's stdout line was not a JSON-RPC frame. `McpHarness` never raises
-*   it: under `strictStdout` a non-JSON-RPC line DIES the pending wait as a
-*   defect instead, so assert it with `Effect.exit` and `Cause.hasDies`,
-*   not `catchTag`.
-* - `ServerStopped` (`McpHarness`): the in-process server stopped, usually
-*   because stdin closed while the request was in flight.
-* - `NotInitialized` (`McpHarness`): a request other than `initialize` or
-*   `ping` was made on a stateful revision before `initialize` was sent. The request
-*   is never written; the server would only have refused it opaquely:
-*   `-32602 Invalid request metadata` when a stateless adapter is listed
-*   first, `-32603 Internal error` when only stateful revisions are served.
-* - `ErrorResponse` (`McpHarness.listTools`): the server answered with a
-*   JSON-RPC error where a result was required. Every other request method
-*   returns the whole response, error included, as data.
-*
-* @public
-*/
-var McpTestFailure = class extends Schema.TaggedError()("McpTestFailure", {
-	/** Which failure occurred; see the list above for which client raises which. */
-	reason: Schema.Literals([
-		"StreamEnded",
-		"ServerStopped",
-		"NotJsonRpc",
-		"NotInitialized",
-		"ErrorResponse",
-		"TimedOut"
-	]),
-	/** A human-readable description of what went wrong. */
-	message: Schema.String
-}) {};
-
-export { McpTestFailure };

package/McpToolAudit.js

@@ -1,109 +0,0 @@
-// src/McpToolAudit.ts
-const isNode = (u) => typeof u === "object" && u !== null && !Array.isArray(u);
-const HINTS = [
-	"readOnlyHint",
-	"destructiveHint",
-	"idempotentHint",
-	"openWorldHint"
-];
-/** Real branches whose members are separate object shapes, each worth its own report. `allOf` is not one of these: core emits it to merge keywords (declared `properties` plus a Record's `additionalProperties`) onto the SAME node, never to introduce a sibling shape. */
-const BRANCHES = [
-	"prefixItems",
-	"anyOf",
-	"oneOf"
-];
-const objectNodes = (schema) => {
-	const out = [];
-	const join = (path, key) => path === "" ? key : `${path}.${key}`;
-	const visit = (node, path) => {
-		if (!isNode(node)) return;
-		const merged = Array.isArray(node.allOf) ? [node, ...node.allOf.filter(isNode)] : [node];
-		const declaredParts = merged.filter((part) => isNode(part.properties));
-		const properties = declaredParts.length === 0 ? void 0 : declaredParts.reduce((acc, part) => {
-			for (const [key, child] of Object.entries(part.properties)) acc[key] = child;
-			return acc;
-		}, Object.create(null));
-		const closed = merged.some((part) => part.additionalProperties === false);
-		const droppedKeyCheck = merged.some((part) => isNode(part.additionalProperties) && isNode(part.propertyNames));
-		if (isNode(properties) || merged.some((part) => part.type === "object")) out.push({
-			path,
-			properties,
-			closed,
-			droppedKeyCheck
-		});
-		if (isNode(properties)) for (const [key, child] of Object.entries(properties)) visit(child, join(path, key));
-		visit(node.items, join(path, "items"));
-		visit(node.additionalProperties, join(path, "additionalProperties"));
-		for (const keyword of BRANCHES) {
-			const list = node[keyword];
-			if (Array.isArray(list)) for (const [index, child] of list.entries()) visit(child, join(path, `${keyword}[${index}]`));
-		}
-		if (isNode(node.$defs)) for (const [key, child] of Object.entries(node.$defs)) visit(child, `$defs.${key}`);
-	};
-	visit(schema, "");
-	return out;
-};
-/**
-* A pure sweep over a served `tools/list` that returns every policy
-* violation, as `"<tool>: <what>"` strings.
-*
-* @remarks
-* Run it against what a real server serves (`McpHarness.listTools`), not
-* against your own schemas: the served document is what a client sees, and
-* it differs by protocol revision. The stateless `2026-07-28` adapter passes a
-* non-object output through, while the stateful adapters drop it — which is
-* why `objectRootedOutput` defaults to `true`.
-*
-* `"closed"` is only as sound as the walk. It follows `properties`,
-* `items`, a schema-valued `additionalProperties`, `prefixItems`, `anyOf`,
-* `oneOf` and `$defs`, and merges an `allOf` member's `properties` and
-* `additionalProperties: false` onto its node. It does not visit
-* `patternProperties` values, an `allOf` member's `items` or
-* `additionalProperties` schema, or an `allOf` nested inside another; and
-* a key declared in two `allOf` members is last-write-wins. A hand-authored
-* or `Tool.dynamic` schema can therefore pass `"closed"` with an open node
-* the walk never reached. Core-emitted strict schemas close every node, so
-* a strict `Tool.make` tool is reported faithfully.
-*
-* @public
-*/
-var McpToolAudit = class {
-	constructor() {}
-	/**
-	* Every violation of `policy` across `tools`, as `"<tool>: <what>"`, in
-	* tool order. Empty means the sweep passed. A duplicate tool name is
-	* reported under every policy, `input: "any"` included.
-	*/
-	static check = (tools, policy) => {
-		const violations = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (const tool of tools) {
-			const report = (what) => {
-				violations.push(`${tool.name}: ${what}`);
-			};
-			if (seen.has(tool.name)) report("duplicate tool name");
-			seen.add(tool.name);
-			if (policy.input !== "any") for (const { path, properties, closed, droppedKeyCheck } of objectNodes(tool.inputSchema)) {
-				const where = path === "" ? "the root" : path;
-				if (policy.input === "closed" && !closed) report(`input schema is open at ${where}${droppedKeyCheck ? " (a Record whose key check was not served; a key pattern is served closed, as patternProperties, only when its RegExp has the u flag, e.g. Schema.isPattern(/^x-/u))" : ""}`);
-				if (policy.input === "open" && isNode(properties) && closed) report(`input schema is closed at ${where}`);
-			}
-			const title = tool.title ?? tool.annotations?.title;
-			if (policy.requireTitle === true && (typeof title !== "string" || title === "")) report("no title");
-			if (policy.requireOutputSchema === true && tool.outputSchema === void 0) report("no outputSchema (a union success schema is dropped on stateful revisions; see ToolOutputSchema.objectRooted)");
-			if ((policy.objectRootedOutput ?? true) && tool.outputSchema !== void 0 && tool.outputSchema.type !== "object") {
-				const union = Array.isArray(tool.outputSchema.anyOf) || Array.isArray(tool.outputSchema.oneOf);
-				report(`outputSchema is not object-rooted (root type: ${String(tool.outputSchema.type ?? "none")})${union ? "; if every union member is an object, wrap the union success schema in ToolOutputSchema.objectRooted" : ""}`);
-			}
-			const length = (tool.description ?? "").length;
-			if (policy.maxDescription !== void 0 && length > policy.maxDescription) report(`description is ${length} characters, over the ${policy.maxDescription} limit`);
-			if (policy.requireHints === true) {
-				const missing = HINTS.filter((hint) => typeof tool.annotations?.[hint] !== "boolean");
-				if (missing.length > 0) report(`missing annotation hints: ${missing.join(", ")}`);
-			}
-		}
-		return violations;
-	};
-};
-
-export { McpToolAudit };