@effected/mcp 0.12.0 → 0.14.0

package/McpStdio.js

@@ -1,171 +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 a bad `protocols` list
-*   turned into a defect. 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. So does a
-	* registration that fails with `Cause.IllegalArgumentError`, which core
-	* reports for the same class of mistake; any other registration error
-	* stays in the error channel.
-	*
-	* @remarks
-	* Pass the server's registration layers as `options.registrations`: they
-	* are built before the server reads its first request, under
-	* `LogToStderr`. Providing this layer to them, as
-	* `Registrations.pipe(Layer.provideMerge(McpStdio.layer(...)))`, also
-	* serves them, and they inherit `LogToStderr` the same way. A sibling
-	* merged beside it with `Layer.mergeAll` is neither: its build logs still
-	* go through `console.log`, onto the wire.
-	*
-	* The output is `McpServer` and the `McpServer.McpRequest<"Requires", Scope>`
-	* marker the transport discharges. `McpServerClient` is not in it: the
-	* stateless `v2026_07_28` revision has no client session, so a handler
-	* reads the client's details from `McpSchema.McpRequestContext` instead.
-	*
-	* `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 (this layer with its `registrations`, or 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,
-		registrations: options.registrations
-	}).pipe(Layer.provide(makeGuardedStdio()), Layer.provideMerge(Layer.succeed(References.LogToStderr, true)), Layer.catchCause((cause) => Layer.effectContext(Effect.failCause(cause).pipe(Effect.catchIf(Cause.isIllegalArgumentError, (error) => Effect.die(error))))));
-	/**
-	* `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 };

package/McpToolkit.js

@@ -1,257 +0,0 @@
-import { ToolFailure } from "./ToolFailure.js";
-import { ToolInputSchema } from "./ToolInputSchema.js";
-import { Context, Effect, Layer, Schema } from "effect";
-import { McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
-
-// src/McpToolkit.ts
-/** The union a {@link McpToolkit.unionTool} decodes with; read by the `McpToolkit.layer` decorator. */
-const UnionParameters = Context.Reference("@effected/mcp/UnionParameters", { defaultValue: () => void 0 });
-/**
-* Effect's strict JSON Schema document for `parameters`, definitions attached
-* as `$defs`, then object-rooted: the served input schema of a union tool.
-*/
-const unionInputJsonSchema = (parameters) => {
-	const document = Schema.toJsonSchemaDocument(parameters, { onExcessProperty: "error" });
-	return ToolInputSchema.objectRooted(Object.keys(document.definitions).length === 0 ? document.schema : {
-		...document.schema,
-		$defs: document.definitions
-	});
-};
-const invalidParameters = (name, message) => new McpSchema.InvalidParams({ message: `Invalid parameters for tool '${name}': ${message}` });
-const MAX_ACCEPTED_LINES = 20;
-/**
-* `path` as core renders an issue path, `["a"][0]["b"]`: a segment indexing
-* an array in `payload` is bare, any other is a JSON string. Truncated, since
-* the segments are the caller's keys.
-*/
-const issuePath = (payload, path) => {
-	let node = payload;
-	let out = "";
-	for (const segment of path) {
-		out += Array.isArray(node) ? `[${segment}]` : `[${JSON.stringify(segment)}]`;
-		node = typeof node === "object" && node !== null ? node[segment] : void 0;
-	}
-	return ToolFailure.truncate(out);
-};
-/**
-* One line per level of `payload` that carries a key the served
-* `inputSchema` does not accept: `Accepted params at <path>: a, b.`, with
-* `keys matching <pattern>` for a level that also accepts keys by
-* `patternProperties`, and `This tool accepts no params.` for a
-* zero-parameter root. At most 20 lines; empty when no level has an
-* unknown key.
-*/
-const acceptedParamsLines = (payload, inputSchema) => ToolInputSchema.unknownKeys(payload, inputSchema).slice(0, MAX_ACCEPTED_LINES).map((level) => {
-	const patterns = level.acceptedPatterns ?? [];
-	if (level.path.length === 0 && level.accepted.length === 0 && patterns.length === 0) return "This tool accepts no params.";
-	const parts = [...level.accepted.length > 0 ? [level.accepted.join(", ")] : [], ...patterns.length > 0 ? [`keys matching ${patterns.join(", ")}`] : []];
-	return `Accepted params at ${level.path.length === 0 ? "the root" : issuePath(payload, level.path)}: ${parts.length > 0 ? parts.join("; ") : "(none)"}.`;
-});
-/**
-* `error` with {@link acceptedParamsLines} appended to its message, one per
-* line after core's own report; `error` itself when there is nothing to add.
-* Core stays the decoder: this only annotates the report it produced.
-*/
-const withAcceptedParams = (error, payload, inputSchema) => {
-	const lines = acceptedParamsLines(payload, inputSchema);
-	return lines.length === 0 ? error : new McpSchema.InvalidParams({
-		message: [error.message, ...lines].join("\n"),
-		...error.data !== void 0 ? { data: error.data } : {}
-	});
-};
-/**
-* The one decode a union tool's payload gets, shared by the `McpToolkit.layer`
-* decorator and {@link McpToolkit.unionHandler}: the union's strict decode
-* with the options core decodes a strict `Tool.make` tool with
-* (`onExcessProperty: "error"`, `errors: "all"`), so every excess, missing and
-* invalid field of the matched member is reported together, worded as core
-* words a `Tool.make` failure, with the accepted params appended as the layer
-* appends them to core's own report.
-*/
-const decodeUnionPayload = (name, union, inputSchema) => {
-	const decode = Schema.decodeUnknownEffect(union);
-	return (payload) => {
-		const raw = payload ?? {};
-		return decode(raw, {
-			onExcessProperty: "error",
-			errors: "all"
-		}).pipe(Effect.mapError((error) => withAcceptedParams(invalidParameters(name, error.message), raw, inputSchema)));
-	};
-};
-/**
-* The registration `McpToolkit.layer` hands core in place of `registration`:
-* a union tool gets its payload decoded first, with the wrapped handler built
-* only after the decode passes, so a rejected payload never reaches it.
-* Anything else is decoded by core as before, and core's parameter failure,
-* the only `InvalidParams` its `handle` fails with, gets the accepted params
-* appended.
-*
-* @internal
-*/
-const guardRegistration = (registration) => {
-	const union = Context.get(registration.annotations, UnionParameters);
-	if (union === void 0) return {
-		...registration,
-		handle: (payload) => registration.handle(payload).pipe(Effect.catchTag("InvalidParams", (error) => Effect.fail(withAcceptedParams(error, payload ?? {}, registration.tool.inputSchema))))
-	};
-	const check = decodeUnionPayload(registration.tool.name, union, registration.tool.inputSchema);
-	return {
-		...registration,
-		handle: (payload) => check(payload).pipe(Effect.flatMap(() => registration.handle(payload)))
-	};
-};
-const DEFAULT_STRICT = "all";
-const strictened = (toolkit, mode) => mode === "annotated" ? toolkit : Toolkit.make(...Object.values(toolkit.tools).map((tool) => Tool.isDynamic(tool) || Tool.getStrictMode(tool) !== void 0 ? tool : tool.annotate(Tool.Strict, true)));
-/**
-* Register a toolkit exactly as core's `McpServer.toolkit` does, except that
-* every tool is strict by default and a {@link McpToolkit.unionTool} gets its
-* union decoded.
-*
-* @remarks
-* Rejection and reporting are core's: a tool annotated `Tool.Strict` is
-* served with `additionalProperties: false` on every object node and decoded
-* with `onExcessProperty: "error"` and `errors: "all"`, so one
-* `InvalidParams` names every excess key at every depth together with every
-* missing or invalid field. The layer appends to that report, never in place
-* of it: for every object level of the payload that carries a key the served
-* input schema does not accept, one line naming what that level does accept,
-* `Accepted params at the root: query, filter.` or
-* `Accepted params at ["filter"]: kind, tag.` (the path as core writes it),
-* with `keys matching <pattern>` for keys a `patternProperties` level
-* accepts, and `This tool accepts no params.` for a zero-parameter tool. An
-* agent can fix the call from the reply alone. A failure with no unknown key
-* (a missing or mistyped field only) is core's report unchanged. The lines
-* are appended to core's `InvalidParams` as it leaves the tool's registered
-* handler, the one failure that handler has for bad parameters.
-*
-* On top of that is the policy: under
-* `strict: "all"` (the default) it annotates every tool that carries no
-* `Tool.Strict` annotation of its own as strict, skipping `Tool.dynamic`
-* tools (core dies at registration on a strict dynamic tool). It runs core's
-* `registerToolkit` unchanged under a registration-scoped `McpServer` whose
-* `addTool` puts the union decode in front of a union tool's handler and
-* passes every other registration through untouched. It patches no core
-* internals: it uses only `McpServer.registerToolkit` and `addTool`.
-*
-* Registration goes through core's module-level `McpServer.McpServer.layer`,
-* shared by reference with `McpStdio.layer`'s own copy — provide both into
-* the same graph, as with `McpServer.toolkit`. Never wrap that layer in
-* `Layer.fresh`: tools would register into a second registry nobody serves.
-* To give two servers separate registries, wrap each whole bundle (this
-* layer together with `McpStdio.layer`) in `Layer.fresh` instead.
-*
-* Each call mints a fresh layer; bind the result to a `const` or the
-* registration runs twice.
-*
-* @example
-* ```ts
-* import { Layer } from "effect";
-* import { McpStdio, McpToolkit } from "@effected/mcp";
-*
-* const ToolsLayer = McpToolkit.layer(MyToolkit).pipe(Layer.provide(MyHandlers));
-* const ServerLayer = ToolsLayer.pipe(Layer.provideMerge(McpStdio.layer({ name: "my-server", version: "1.0.0" })));
-* ```
-*
-* @public
-*/
-var McpToolkit = class {
-	constructor() {}
-	/**
-	* A tool whose parameters are a `Schema.Union` of objects, which
-	* `Tool.make` cannot take: core dies at registration on a non-object
-	* `parameters` root.
-	*
-	* @remarks
-	* The tool is a `Tool.dynamic` served with Effect's strict JSON Schema
-	* document for `parameters` (`additionalProperties: false` on every
-	* object node, definitions as `$defs`), rewritten by
-	* `ToolInputSchema.objectRooted` to an object root carrying `type`,
-	* `oneOf` and `x-discriminator`. Write its handler with
-	* {@link McpToolkit.unionHandler}, which receives the decoded member.
-	*
-	* Registered through {@link McpToolkit.layer}, a union tool gets the same
-	* treatment as a strict `Tool.make` tool: a strict decode with
-	* `errors: "all"` before the handler runs, reporting every excess, missing
-	* and invalid field of the matched member in one `InvalidParams`, with the
-	* same `Accepted params at <path>: …` lines appended, so bad
-	* arguments answer JSON-RPC `-32602` on `2025-06-18` and an `isError`
-	* result on the later revisions, exactly as a `Tool.make` decode failure
-	* does. Registered through core's `McpServer.toolkit` it still decodes
-	* strictly, in the handler, but the `InvalidParams` is then a declared
-	* failure: an `isError` result on every revision.
-	*
-	* Never annotate it `Tool.Strict` true: core dies at registration on a
-	* strict tool with a raw JSON Schema.
-	*
-	* @example
-	* ```ts
-	* import { McpToolkit, ToolOutputSchema, ToolRefusal } from "@effected/mcp";
-	* import { Schema } from "effect";
-	* import { Tool } from "effect/ai";
-	*
-	* // `AddNote`, `ListNotes`, `Added`, `Listed` are object schemas; `Kit` is a Toolkit that includes `Note`.
-	* const Note = McpToolkit.unionTool("note", {
-	*   parameters: Schema.Union([AddNote, ListNotes]),
-	*   success: ToolOutputSchema.objectRooted(Schema.Union([Added, Listed])),
-	*   failure: ToolRefusal,
-	* }).annotate(Tool.Title, "Note")
-	* const handlers = Kit.toLayer({ note: McpToolkit.unionHandler(Note, (params) => handleNote(params)) })
-	* ```
-	*/
-	static unionTool = (name, options) => {
-		const tool = Tool.dynamic(name, {
-			description: options.description,
-			parameters: unionInputJsonSchema(options.parameters),
-			success: options.success ?? Schema.Void,
-			failure: Schema.Union([options.failure ?? Schema.Never, McpSchema.InvalidParams])
-		}).annotate(UnionParameters, options.parameters);
-		return Object.assign(tool, { unionParameters: options.parameters });
-	};
-	/**
-	* The handler for a {@link McpToolkit.unionTool}: decodes the raw payload
-	* exactly as {@link McpToolkit.layer} does, and passes the decoded member
-	* to `handler`.
-	*
-	* @remarks
-	* A payload that does not decode strictly fails with one
-	* `McpSchema.InvalidParams`, worded as core words a `Tool.make` decode
-	* failure, naming every excess key at every depth together with every
-	* missing or invalid field of the matched member, then one
-	* `Accepted params at <path>: …` line per level with an unknown key. It
-	* is the same
-	* implementation the layer runs, so a handler called directly (a test
-	* helper, or a toolkit registered through core's `McpServer.toolkit`)
-	* reports what a client of the layer sees. Under {@link McpToolkit.layer}
-	* the layer has already rejected a bad call before the handler runs.
-	* `options.unknownKeyMessage` is deprecated and ignored.
-	*/
-	static unionHandler = (tool, handler, _options = {}) => {
-		const check = decodeUnionPayload(tool.name, tool.unionParameters, tool.jsonSchema);
-		return (payload) => check(payload).pipe(Effect.flatMap(handler));
-	};
-	/**
-	* `McpServer.toolkit`'s registration layer, strict by default.
-	* `options.unknownKeyMessage` is deprecated and ignored.
-	*
-	* @remarks
-	* Its requirements are core's `McpServer.ToolkitRequirements` less
-	* `McpServer`, which the layer provides itself: the handlers, any service
-	* a parameter or success schema needs, and each service a tool declares
-	* with `dependencies` or `addDependency` as an
-	* `McpServer.McpRequest<"Requires", S>` marker. A marker is met per
-	* request by MCP middleware (`McpServer.middleware`, its `layer` provided
-	* to this one), never by providing `S`. A service the handlers only need
-	* when they are built is captured by the effect form of
-	* `Toolkit.toLayer` instead, and declared nowhere.
-	*/
-	static layer = (toolkit, options = {}) => Layer.effectDiscard(Effect.gen(function* () {
-		const registry = yield* McpServer.McpServer;
-		const decorated = McpServer.McpServer.of({
-			...registry,
-			addTool: (registration) => registry.addTool(guardRegistration(registration))
-		});
-		yield* McpServer.registerToolkit(strictened(toolkit, options.strict ?? DEFAULT_STRICT)).pipe(Effect.provideService(McpServer.McpServer, decorated));
-	})).pipe(Layer.provide(McpServer.McpServer.layer));
-};
-
-export { McpToolkit, guardRegistration };