@effected/mcp 0.12.0 → 0.13.0

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 };

package/StdioCapture.js

@@ -1,146 +0,0 @@
-import { Effect, Fiber } from "effect";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { Writable } from "node:stream";
-
-// src/StdioCapture.ts
-/**
-* One registry per process, shared by every installed copy of this package
-* through a `Symbol.for` key on `globalThis`, so two copies never stack
-* patches or split the context they route on.
-*/
-const registry = (() => {
-	const key = Symbol.for("@effected/mcp/StdioCapture");
-	const global = globalThis;
-	global[key] ??= {
-		storage: new AsyncLocalStorage(),
-		originals: /* @__PURE__ */ new WeakMap()
-	};
-	return global[key];
-})();
-/** Patches `stream` once and returns its original `write`; a stream already patched keeps its first patch. */
-const patch = (stream, pick) => {
-	const known = registry.originals.get(stream);
-	if (known !== void 0) return known;
-	const original = stream.write;
-	registry.originals.set(stream, original);
-	const { storage } = registry;
-	stream.write = function capturedWrite() {
-		const options = storage.getStore();
-		const sink = options === void 0 ? void 0 : pick(options);
-		return sink === void 0 ? original.apply(this, arguments) : sink.write.apply(sink, arguments);
-	};
-	return original;
-};
-const callbackOf = (rest) => {
-	const last = rest.at(-1);
-	return typeof last === "function" ? last : void 0;
-};
-/**
-* Diverts a host's stdout (and optionally stderr) writes to a sink, for code
-* running inside one async context only, while every other context keeps
-* writing to the real streams.
-*
-* @remarks
-* For an MCP server over stdio, stdout is the JSON-RPC wire. A chatty library
-* run in-process (a test runner, a bundler, a linter) must keep its output off
-* it while other handlers, and the transport itself, keep writing normally.
-*
-* `install` patches the host's `write` methods once, keeping the unbound
-* originals, and routes every write through an `AsyncLocalStorage`: inside a
-* {@link StdioCapture.run} or {@link StdioCapture.capture} context a write goes
-* to that context's sink, and outside it to the original stream.
-*
-* An Effect fiber resumes in the async context it suspended in, not the
-* context of whatever woke it, so a server fiber woken by code inside a
-* capture (its response written to a queue, say) keeps writing to the wire.
-*
-* Two kinds of write escape a capture and reach the original stream:
-*
-* - **Writes from a context the capture lost.** Callbacks registered outside the
-*   capture keep the context they were registered in: native addons, worker
-*   thread output relayed by the main thread, listeners on a child process's
-*   pipes attached earlier. On stdout, that is the wire.
-* - **Fibers started inside the capture keep capturing after it ends.** A fiber
-*   forked inside it (`Effect.forkDetach`, a memoized layer first built inside
-*   it, a background fiber a library starts) keeps writing to the sink, even
-*   after the capture's own work is done.
-*
-* @example
-* ```ts
-* import { StdioCapture } from "@effected/mcp/node"
-*
-* const capture = StdioCapture.install(process)
-* // in a tool handler: keep the runner's own console output off the wire
-* const report = yield* runTests(files).pipe(capture.capture({ stdout: capture.toStderr }))
-* ```
-*
-* @public
-*/
-var StdioCapture = class StdioCapture {
-	/** A sink that writes through the host's original, unpatched stderr: captured output stays visible off the wire. */
-	toStderr;
-	constructor(toStderr) {
-		this.toStderr = toStderr;
-	}
-	/**
-	* Patches `host`'s two streams. Idempotent per stream, across every installed
-	* copy of this package: a stream already patched (through another host
-	* object, or another copy) keeps its one patch and its original `write`.
-	*/
-	static install = (host) => {
-		patch(host.stdout, (options) => options.stdout);
-		const stderr = patch(host.stderr, (options) => options.stderr);
-		return new StdioCapture({ write: (...args) => stderr.apply(host.stderr, args) });
-	};
-	/**
-	* A write-only sink that drops every write and calls the write's callback.
-	*
-	* @remarks
-	* It is a {@link StdioSink}, not a stream: it has no `on`, `pipe` target
-	* protocol or `setMaxListeners`, so it cannot stand in where a library
-	* expects a `Writable` (a test runner's logger stream that worker output
-	* is piped into, for one). Use {@link StdioCapture.nullWritable} there; it
-	* serves as a capture sink too.
-	*/
-	static discard = { write: (_chunk, ...rest) => {
-		const callback = callbackOf(rest);
-		if (callback !== void 0) queueMicrotask(callback);
-		return true;
-	} };
-	/**
-	* A new Node `Writable` that drops everything written to it: a real stream,
-	* so it works as a `pipe` target, takes `setMaxListeners`, emits `drain`
-	* and `finish`, and is also a {@link StdioSink} for a capture.
-	*
-	* @remarks
-	* A factory, not a shared value: a stream ends once, and a source piped in
-	* with the default `{ end: true }` ends its destination. Build one per
-	* consumer.
-	*/
-	static nullWritable = () => new Writable({
-		decodeStrings: false,
-		write: (_chunk, _encoding, callback) => callback()
-	});
-	/**
-	* Runs `evaluate` with its writes captured, for code that is not Effect.
-	* A synchronous throw from `evaluate` rejects the returned promise.
-	*/
-	run(options, evaluate) {
-		return registry.storage.run(options, async () => evaluate());
-	}
-	/**
-	* Runs an effect with its writes captured: on its own fiber, started inside
-	* the capture's context, so the context survives every suspension of that
-	* fiber. Interrupting the returned effect interrupts that fiber and waits
-	* for it.
-	*/
-	capture(options) {
-		const { storage } = registry;
-		return (self) => Effect.uninterruptibleMask((restore) => Effect.withFiber((parent) => {
-			const fiber = storage.run(options, () => Effect.runForkWith(parent.context)(self));
-			return Effect.ensuring(restore(Fiber.join(fiber)), Fiber.interrupt(fiber));
-		}));
-	}
-};
-
-export { StdioCapture };

package/ToolFailure.js

@@ -1,75 +0,0 @@
-import { Schema } from "effect";
-import { Remediation } from "@effected/engine";
-
-// src/ToolFailure.ts
-const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
-/**
-* How a tool's declared failure should read on the wire.
-*
-* @remarks
-* Core sends a declared failure that is an `Error` instance — every
-* `Schema.TaggedError` is — as `isError: true` with `error.message` as the only
-* text and no `structuredContent` (effect `ai/McpServer.ts`,
-* `declaredFailureResult`). So the remediation must be folded into `message`
-* when the error is constructed: whatever is not in the message never reaches
-* the agent.
-*
-* Spread {@link ToolFailure.fields} into your tool's `Schema.TaggedError`, build
-* `message` with {@link ToolFailure.message}, and pass every caller-supplied
-* value through {@link ToolFailure.truncate} before echoing it. For a plain
-* refusal with no fields of its own, `ToolRefusal` is this shape ready-made.
-*
-* Only a declared failure keeps its message: core scrubs an undeclared
-* failure or a defect to "Tool execution failed due to an internal server
-* error.", so audit every throw path a tool can take and declare each one the
-* agent should read.
-*
-* @example
-* ```ts
-* import { ToolFailure } from "@effected/mcp";
-* import { Schema } from "effect";
-*
-* class NotFound extends Schema.TaggedError<NotFound>()("NotFound", { ...ToolFailure.fields, id: Schema.String }) {}
-* const remediation = { hint: "List the ids first.", suggestedTool: "list_things" }
-* new NotFound({ id, remediation, message: ToolFailure.message(`No thing "${ToolFailure.truncate(id)}".`, remediation) })
-* ```
-*
-* @public
-*/
-var ToolFailure = class ToolFailure {
-	constructor() {}
-	/** The cap, in UTF-16 code units, on a caller-supplied value echoed into a message. */
-	static ECHO_LIMIT = 200;
-	/** The larger cap for a value the engine produced (a path, a diagnostic), not one a caller typed. */
-	static ENGINE_ECHO_LIMIT = 2e3;
-	/**
-	* The `message` and `remediation` fields to spread into a consumer's
-	* `Schema.TaggedError`, each carrying a default `description` that a served
-	* JSON Schema (a tool's `outputSchema`) shows the agent.
-	*/
-	static fields = {
-		message: Schema.String.annotate({ description: "What went wrong, as one plain sentence." }),
-		remediation: Remediation.annotate({ description: "What to do next: a hint, and optionally the tool to call next and the arguments to call it with." })
-	};
-	/**
-	* `"<raw> <hint> Try <suggestedTool>."`, dropping any empty part, so a
-	* missing tool or an empty hint never leaves a double space.
-	*/
-	static message = (raw, remediation) => [
-		raw,
-		remediation.hint,
-		remediation.suggestedTool === void 0 ? "" : `Try ${remediation.suggestedTool}.`
-	].filter((part) => part !== "").join(" ");
-	/**
-	* `value` cut to `limit` code units with a trailing ellipsis, backing off one
-	* unit rather than splitting a surrogate pair. A hostile multi-megabyte
-	* argument is otherwise echoed into the agent's context whole.
-	*/
-	static truncate = (value, limit = ToolFailure.ECHO_LIMIT) => {
-		if (value.length <= limit) return value;
-		const end = limit > 0 && isHighSurrogate(value.charCodeAt(limit - 1)) ? limit - 1 : limit;
-		return `${value.slice(0, end)}…`;
-	};
-};
-
-export { ToolFailure };

package/ToolInputSchema.js

@@ -1,180 +0,0 @@
-import { ToolFailure } from "./ToolFailure.js";
-import { Result } from "effect";
-
-// src/ToolInputSchema.ts
-const MAX_DEPTH = 256;
-const MAX_ECHOED = 20;
-const DISCRIMINANTS = [
-	"action",
-	"kind",
-	"_tag",
-	"type"
-];
-const REF_PREFIX = "#/$defs/";
-const isNode = (u) => typeof u === "object" && u !== null && !Array.isArray(u);
-const resolveRef = (node, root, seen = /* @__PURE__ */ new Set()) => {
-	const ref = node.$ref;
-	if (typeof ref !== "string" || !ref.startsWith(REF_PREFIX) || seen.has(ref)) return node;
-	const defs = root.$defs;
-	const name = ref.slice(8).replaceAll("~1", "/").replaceAll("~0", "~");
-	const target = isNode(defs) && Object.hasOwn(defs, name) ? defs[name] : void 0;
-	if (!isNode(target)) return node;
-	const { $ref: _ref, ...siblings } = node;
-	return resolveRef({
-		...target,
-		...siblings
-	}, root, /* @__PURE__ */ new Set([...seen, ref]));
-};
-const literalValues = (node) => {
-	if (!isNode(node)) return void 0;
-	if (Array.isArray(node.enum)) return node.enum;
-	return "const" in node ? [node.const] : void 0;
-};
-const discriminantOf = (members) => members.length === 0 ? void 0 : DISCRIMINANTS.find((key) => members.every((member) => isNode(member.properties) && literalValues(member.properties[key]) !== void 0));
-const selectMember = (members, value, root) => {
-	const resolved = members.filter(isNode).map((member) => resolveRef(member, root));
-	const key = discriminantOf(resolved);
-	if (key !== void 0) return resolved.find((member) => literalValues(member.properties[key])?.includes(value[key]) === true);
-	const objects = resolved.filter((member) => isNode(member.properties) || member.type === "object");
-	return objects.length === 1 ? objects[0] : void 0;
-};
-const matchesPattern = (pattern, key) => Result.getOrUndefined(Result.try(() => new RegExp(pattern, "u").test(key))) === true;
-const collect = (payload, root) => {
-	const out = [];
-	const walk = (value, raw, path, depth) => {
-		if (depth > MAX_DEPTH || !isNode(raw)) return;
-		const node = resolveRef(raw, root);
-		const parts = [node, ...Array.isArray(node.allOf) ? node.allOf.filter(isNode).map((m) => resolveRef(m, root)) : []];
-		const members = Array.isArray(node.oneOf) ? node.oneOf : Array.isArray(node.anyOf) ? node.anyOf : void 0;
-		const additional = parts.map((part) => part.additionalProperties).find(isNode);
-		const isClosed = parts.some((part) => part.additionalProperties === false);
-		if (Array.isArray(value)) {
-			const prefix = Array.isArray(node.prefixItems) ? node.prefixItems : [];
-			if (prefix.length === 0 && !isNode(node.items) && members !== void 0) {
-				const arrays = members.filter(isNode).map((member) => resolveRef(member, root)).filter((member) => member.type === "array");
-				if (arrays.length === 1) walk(value, arrays[0], path, depth + 1);
-				return;
-			}
-			for (const [index, item] of value.entries()) walk(item, index < prefix.length ? prefix[index] : node.items, [...path, String(index)], depth + 1);
-			return;
-		}
-		if (!isNode(value)) return;
-		const declared = parts.filter((part) => isNode(part.properties));
-		if (declared.length === 0 && members !== void 0) {
-			const member = selectMember(members, value, root);
-			if (member !== void 0) walk(value, member, path, depth + 1);
-			return;
-		}
-		const properties = Object.create(null);
-		for (const part of declared) for (const [key, schema] of Object.entries(part.properties)) properties[key] = schema;
-		const patterns = parts.flatMap((part) => isNode(part.patternProperties) ? Object.entries(part.patternProperties) : []);
-		const accepted = Object.keys(properties);
-		const extra = [];
-		const patterned = [];
-		for (const key of Object.keys(value)) {
-			if (Object.hasOwn(properties, key)) continue;
-			const match = patterns.find(([pattern]) => matchesPattern(pattern, key));
-			if (match === void 0) extra.push(key);
-			else patterned.push([key, match[1]]);
-		}
-		if (extra.length > 0 && isClosed) {
-			const acceptedPatterns = patterns.map(([pattern]) => pattern);
-			out.push({
-				path,
-				unknown: extra,
-				accepted,
-				...acceptedPatterns.length > 0 ? { acceptedPatterns } : {}
-			});
-		}
-		for (const key of accepted) if (Object.hasOwn(value, key)) walk(value[key], properties[key], [...path, key], depth + 1);
-		for (const [key, schema] of patterned) walk(value[key], schema, [...path, key], depth + 1);
-		if (additional !== void 0) for (const key of extra) walk(value[key], additional, [...path, key], depth + 1);
-	};
-	walk(payload, root, [], 0);
-	return out;
-};
-/**
-* Pure walkers over a tool's served JSON Schema: every unknown key at every
-* depth, a message naming them all, and an object-rooted form of a union.
-*
-* @remarks
-* For a `Tool.make` tool, core's strict decode already names every unknown
-* key, with every missing or invalid field, in one response. Core never
-* validates a `Tool.dynamic` tool's raw JSON Schema, so these walkers are
-* for that case: a handler runs them against the schema it registered.
-* They run over the schema as served, so what they accept matches what the
-* tool advertises:
-*
-* - Only `additionalProperties: false` closes a node, as in JSON Schema; core
-*   emits it on every object node of a strict tool and `true` otherwise.
-* - `allOf` members' properties merge; `oneOf`/`anyOf` members are chosen by an
-*   `action`, `kind`, `_tag` or `type` literal (tried in that order), or by
-*   being the only object member. A payload whose discriminant matches no
-*   member, or is missing, is skipped and left for decoding.
-* - `items`, `prefixItems`, `$ref` into `$defs` (JSON Pointer escapes
-*   honoured), and `patternProperties` are followed; a key matched by a
-*   pattern is accepted and walked with the first matching pattern's schema.
-*   Effect serves a pattern-keyed `Schema.Record` with `patternProperties`
-*   only when the key pattern's RegExp has the `u` flag; without it the
-*   record is served open, and every key is accepted.
-* - The payload is untrusted: the walk stops descending at depth 256 rather
-*   than overflowing the stack, so a deeper unknown key goes unreported and
-*   is left for decoding. Every hop counts toward that cap: each property or
-*   array position, and also each union member selection, which adds a hop
-*   without adding a path segment.
-*
-* @public
-*/
-var ToolInputSchema = class {
-	constructor() {}
-	/** Every level of `payload` that carries a key `schema` does not accept. */
-	static unknownKeys = (payload, schema) => collect(payload, schema);
-	/**
-	* `Unrecognized parameter(s): a, b.c. Accepted params: x, y.` per level,
-	* followed by `Accepted keys matching: ^x-.` when the level also accepts
-	* keys by pattern. A level that accepts keys only by pattern names its
-	* patterns alone, never `Accepted params: (none).` Each echoed key and
-	* pattern is truncated, and at most 20 keys, 20 patterns and 20 levels are
-	* named; a trailing `(and N more levels).` counts the levels left out.
-	*/
-	static formatUnknownKeys = (levels, options = {}) => {
-		const limit = options.echoLimit ?? ToolFailure.ECHO_LIMIT;
-		const sentences = levels.slice(0, MAX_ECHOED).map((level) => {
-			const shown = level.unknown.slice(0, MAX_ECHOED).map((key) => ToolFailure.truncate([...level.path, key].join("."), limit));
-			const more = level.unknown.length > MAX_ECHOED ? ` (and ${level.unknown.length - MAX_ECHOED} more)` : "";
-			const patterns = (level.acceptedPatterns ?? []).slice(0, MAX_ECHOED).map((pattern) => ToolFailure.truncate(pattern, limit));
-			const params = level.accepted.length > 0 ? ` Accepted params: ${level.accepted.join(", ")}.` : patterns.length === 0 ? " Accepted params: (none)." : "";
-			const matching = patterns.length > 0 ? ` Accepted keys matching: ${patterns.join(", ")}.` : "";
-			return `Unrecognized parameter(s): ${shown.join(", ")}${more}.${params}${matching}`;
-		});
-		const hidden = levels.length > MAX_ECHOED ? ` (and ${levels.length - MAX_ECHOED} more levels).` : "";
-		return `${sentences.join(" ")}${hidden}`;
-	};
-	/**
-	* `schema` with a root `$ref` inlined and a top-level union of objects
-	* sharing an `action`, `kind`, `_tag` or `type` literal rewritten to an
-	* object root carrying `type: "object"`, `oneOf` and `"x-discriminator"` —
-	* MCP requires an object root, and core dies at boot on a union root.
-	* Returned as the same value when nothing changes.
-	*/
-	static objectRooted = (schema) => {
-		const root = resolveRef(schema, schema);
-		const members = Array.isArray(root.anyOf) ? root.anyOf : Array.isArray(root.oneOf) ? root.oneOf : void 0;
-		if (root.type === void 0 && members !== void 0) {
-			const resolved = members.filter(isNode).map((member) => resolveRef(member, schema));
-			const key = resolved.length === members.length ? discriminantOf(resolved) : void 0;
-			if (key !== void 0) {
-				const { anyOf: _anyOf, oneOf: _oneOf, ...rest } = root;
-				return {
-					type: "object",
-					...rest,
-					oneOf: resolved,
-					"x-discriminator": key
-				};
-			}
-		}
-		return root;
-	};
-};
-
-export { ToolInputSchema };