@effected/mcp 0.8.0 → 0.10.0

package/McpGuard.js

@@ -1,6 +1,6 @@
 import { ProcessGuard } from "@effected/engine/guard";
 
-//#region src/McpGuard.ts
+// src/McpGuard.ts
 /**
 * Crash guards for an MCP server process, installed before the server's
 * module graph is loaded. Imported from `@effected/mcp/guard`.
@@ -78,5 +78,4 @@ var McpGuard = class {
 	});
 };
 
-//#endregion
 export { McpGuard };

package/McpHarness.js

@@ -4,7 +4,7 @@ import { McpTestFailure } from "./McpTestFailure.js";
 import { Console, Deferred, Effect, Exit, Fiber, Layer, Queue, Sink, Stdio, Stream } from "effect";
 import { McpProtocol } from "effect/ai";
 
-//#region src/McpHarness.ts
+// src/McpHarness.ts
 /**
 * An in-process MCP client for a real server layer, over queue-backed stdio.
 *
@@ -297,5 +297,4 @@ var McpHarness = class McpHarness {
 	});
 };
 
-//#endregion
 export { McpHarness };

package/McpProbe.js

@@ -5,7 +5,7 @@ import { McpProcess } from "./McpProcess.js";
 import { Effect } from "effect";
 import { McpProtocol } from "effect/ai";
 
-//#region src/McpProbe.ts
+// src/McpProbe.ts
 /**
 * The smallest proof that an installed MCP bin boots: one initialize, a clean
 * close, and exit 0.
@@ -91,5 +91,4 @@ var McpProbe = class {
 	}));
 };
 
-//#endregion
 export { McpProbe };

package/McpProcess.js

@@ -5,7 +5,7 @@ import { Deferred, Duration, Effect, Option, Queue, Ref, Stream, SubscriptionRef
 import { McpProtocol } from "effect/ai";
 import { ChildProcessSpawner } from "effect/process";
 
-//#region src/McpProcess.ts
+// src/McpProcess.ts
 /**
 * A spawned MCP server bin a test writes to while it runs.
 *
@@ -193,5 +193,4 @@ var McpProcess = class McpProcess {
 	});
 };
 
-//#endregion
 export { McpProcess };

package/McpStdio.js

@@ -3,7 +3,7 @@ import { makeGuardedStdio } from "./internal/StdinFrames.js";
 import { Cause, Effect, Exit, Layer, References, Runtime } from "effect";
 import { McpProtocol, McpServer } from "effect/ai";
 
-//#region src/McpStdio.ts
+// 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.
@@ -164,5 +164,4 @@ var McpStdio = class McpStdio {
 	static teardown = (exit, onExit) => Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) ? onExit(0) : Runtime.defaultTeardown(exit, onExit);
 };
 
-//#endregion
 export { McpStdio };

package/McpTestFailure.js

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 
-//#region src/McpTestFailure.ts
+// src/McpTestFailure.ts
 /**
 * Why an MCP test client could not produce what was asked of it.
 *
@@ -46,5 +46,4 @@ var McpTestFailure = class extends Schema.TaggedError()("McpTestFailure", {
 	message: Schema.String
 }) {};
 
-//#endregion
 export { McpTestFailure };

package/McpToolAudit.js

@@ -1,4 +1,4 @@
-//#region src/McpToolAudit.ts
+// src/McpToolAudit.ts
 const isNode = (u) => typeof u === "object" && u !== null && !Array.isArray(u);
 const HINTS = [
 	"readOnlyHint",
@@ -106,5 +106,4 @@ var McpToolAudit = class {
 	};
 };
 
-//#endregion
 export { McpToolAudit };

package/McpToolkit.js

@@ -3,7 +3,7 @@ import { ToolInputSchema } from "./ToolInputSchema.js";
 import { Context, Effect, Layer, Schema } from "effect";
 import { McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
 
-//#region src/McpToolkit.ts
+// 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 });
 /**
@@ -243,5 +243,4 @@ var McpToolkit = class {
 	})).pipe(Layer.provide(McpServer.McpServer.layer));
 };
 
-//#endregion
 export { McpToolkit, guardRegistration };

package/StdioCapture.js

@@ -0,0 +1,146 @@
+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,7 +1,7 @@
 import { Schema } from "effect";
 import { Remediation } from "@effected/engine";
 
-//#region src/ToolFailure.ts
+// src/ToolFailure.ts
 const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
 /**
 * How a tool's declared failure should read on the wire.
@@ -42,10 +42,14 @@ var ToolFailure = class ToolFailure {
 	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`. */
+	/**
+	* 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,
-		remediation: Remediation
+		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
@@ -68,5 +72,4 @@ var ToolFailure = class ToolFailure {
 	};
 };
 
-//#endregion
 export { ToolFailure };

package/ToolInputSchema.js

@@ -1,7 +1,7 @@
 import { ToolFailure } from "./ToolFailure.js";
 import { Result } from "effect";
 
-//#region src/ToolInputSchema.ts
+// src/ToolInputSchema.ts
 const MAX_DEPTH = 256;
 const MAX_ECHOED = 20;
 const DISCRIMINANTS = [
@@ -177,5 +177,4 @@ var ToolInputSchema = class {
 	};
 };
 
-//#endregion
 export { ToolInputSchema };

package/ToolOutcome.js

@@ -0,0 +1,119 @@
+import { ToolFailure } from "./ToolFailure.js";
+import { ToolOutputSchema } from "./ToolOutputSchema.js";
+import { Effect, Schema } from "effect";
+
+// src/ToolOutcome.ts
+/**
+* The `ok: false` structured-outcome envelope: an expected error an agent
+* should branch on, returned on a tool's success channel so it reaches the
+* client as `structuredContent` instead of message text.
+*
+* @remarks
+* Two channels, two jobs, one error shape:
+*
+* - {@link ToolRefusal} is a declared failure: the call itself was wrong, and
+*   the agent reads one sentence (`isError: true`, message text only; core
+*   never sends a failure's `structuredContent`).
+* - `ToolOutcome` is an expected domain outcome: an id that does not exist, a
+*   transition that is not allowed. The agent branches on its `_tag` and
+*   fields (`isError: false`, `structuredContent` carries the envelope).
+*
+* Both carry {@link ToolFailure.fields} (`message`, `remediation`), so an error
+* can move between channels without reshaping.
+*
+* Success members are not reshaped. Spread {@link ToolOutcome.ok} into each
+* success struct so a client can discriminate on `ok`; a member that
+* discriminates another way (`found: true | false`) stays legal.
+*
+* @example
+* ```ts
+* import { ToolOutcome } from "@effected/mcp"
+* import { Effect, Schema } from "effect"
+* import { Tool } from "effect/ai"
+*
+* const NotFound = ToolOutcome.error("GoalNotFound", { id: Schema.Number })
+* const Lookup = Tool.make("goal", {
+* 	parameters: Schema.Struct({ id: Schema.Number }),
+* 	success: ToolOutcome.envelope(Schema.Struct({ ...ToolOutcome.ok, goal: Goal }), [NotFound]),
+* })
+* // in the handler:
+* findGoal(id).pipe(
+* 	Effect.map((goal) => ({ ok: true as const, goal })),
+* 	ToolOutcome.catchAsEnvelope({
+* 		GoalNotFound: (e) => ({ id: e.id, message: `No goal ${e.id}.`, remediation: { hint: "List goals first.", suggestedTool: "goal" } }),
+* 	}),
+* )
+* ```
+*
+* @public
+*/
+var ToolOutcome = class ToolOutcome {
+	constructor() {}
+	/** `{ ok: true }` as schema fields, to spread into each success member. */
+	static ok = { ok: Schema.Literal(true).annotate({ description: "true: the call succeeded." }) };
+	/**
+	* The schema of one envelope error: `_tag`, {@link ToolFailure.fields} and
+	* `fields`. A field named `_tag`, `message` or `remediation` is rejected by
+	* the type, because it would replace the shared one.
+	*/
+	static error = (tag, fields) => Schema.Struct({
+		_tag: Schema.Literal(tag).annotate({ description: "The error's tag: the value to branch on." }),
+		...ToolFailure.fields,
+		...fields
+	});
+	/**
+	* A tool's success schema: `success`, or `{ ok: false, error }` where `error`
+	* is one of `errors`. Object-rooted with {@link ToolOutputSchema.objectRooted},
+	* so core serves its `outputSchema` on every protocol revision.
+	*
+	* @remarks
+	* The failure member, its `ok` and its `error` carry default descriptions.
+	* `options` names the member (`identifier`, served once under `$defs`) or
+	* replaces its description.
+	*/
+	static envelope = (success, errors, options) => ToolOutputSchema.objectRooted(Schema.Union([success, Schema.Struct({
+		ok: Schema.Literal(false).annotate({ description: "false: the call hit an expected error, described in error." }),
+		error: Schema.Union(errors).annotate({ description: "The expected error. Branch on its _tag." })
+	}).annotate({
+		description: options?.description ?? "An expected error the caller should branch on, returned in place of a result.",
+		...options?.identifier === void 0 ? {} : { identifier: options.identifier }
+	})]));
+	/** One `ok: false` value, for a handler that decides on a failure without catching an error. */
+	static failure = (tag, error) => ({
+		ok: false,
+		error: {
+			...error,
+			_tag: tag
+		}
+	});
+	/**
+	* Turns each handled tagged error into its `ok: false` value on the success
+	* channel; every other error stays in the error channel. Typed like core's
+	* `Effect.catchTags`: a case for a tag the effect cannot fail with is a type
+	* error, and the handled tags leave `E`.
+	*
+	* @remarks
+	* Write it inline in the effect's `pipe`. `E` is inferred from the effect
+	* being piped, so `effect.pipe(ToolOutcome.catchAsEnvelope({ … }))` checks
+	* every case name against the effect's real tags. Bound to a `const` first,
+	* the combinator never sees that effect: `E` infers as `unknown`, the
+	* unknown-tag check switches off, and a misspelled tag compiles and never
+	* matches. Core's `catchTags` looks a case up only among `cases`' own keys,
+	* so an error tagged `"toString"` or `"constructor"` never hits an inherited
+	* `Object.prototype` member and stays in the error channel.
+	*/
+	static catchAsEnvelope = (cases) => (self) => {
+		const handlers = {};
+		for (const [tag, handle] of Object.entries(cases)) handlers[tag] = (error) => Effect.succeed(ToolOutcome.failure(tag, handle(error)));
+		return Effect.catchTags(self, handlers);
+	};
+	/**
+	* Whether `value` is an `ok: false` envelope member: an object whose `ok` is
+	* exactly `false`. A success member that discriminates some other way, or a
+	* non-object, is not a failure. Narrows to `{ ok: false }` only: it checks
+	* the discriminant, not the `error` payload.
+	*/
+	static isFailure = (value) => typeof value === "object" && value !== null && value.ok === false;
+};
+
+export { ToolOutcome };

package/ToolOutputSchema.js

@@ -1,6 +1,6 @@
 import { Schema, SchemaAST } from "effect";
 
-//#region src/ToolOutputSchema.ts
+// src/ToolOutputSchema.ts
 const MARK = "~effected/mcp/objectRooted";
 /** Always passes; contributes `type: "object"` beside whatever the node already emits. */
 const objectRoot = Schema.makeFilter(() => true, {
@@ -62,5 +62,4 @@ var ToolOutputSchema = class {
 	};
 };
 
-//#endregion
 export { ToolOutputSchema };

package/ToolRefusal.js

@@ -1,7 +1,7 @@
 import { ToolFailure } from "./ToolFailure.js";
 import { Schema } from "effect";
 
-//#region src/ToolRefusal.ts
+// src/ToolRefusal.ts
 /**
 * A tool call refused for a reason the caller can fix: the kit's ready-made
 * declared failure, built on {@link ToolFailure.fields}.
@@ -54,5 +54,4 @@ var ToolRefusal = class ToolRefusal extends Schema.TaggedError()("ToolRefusal",
 	});
 };
 
-//#endregion
 export { ToolRefusal };

package/ToolReplay.js

@@ -0,0 +1,122 @@
+import { ToolOutcome } from "./ToolOutcome.js";
+import { Effect, Option, Schema } from "effect";
+import { KeyValueStore } from "effect/persistence";
+
+// src/ToolReplay.ts
+/**
+* Idempotent replay for a write tool: a repeated call with the same key returns
+* the first call's stored result, marked `_idempotentReplay: true`, instead of
+* running the mutation again.
+*
+* @remarks
+* The store is core's `KeyValueStore` (`effect/persistence`), required in `R`
+* (`KeyValueStore.layerMemory`, `layerFileSystem` or `layerSql`), unless
+* {@link ToolReplayOptions.store} supplies a {@link ToolReplayStore}: just
+* `get` and `set`, for an application's own table. Then `R` carries no
+* `KeyValueStore`.
+*
+* Semantics, per call:
+*
+* - A key of `Option.none()` runs the handler; nothing is read or stored.
+* - A stored value that decodes through `success` is returned with the marker,
+*   and the handler does not run.
+* - A miss runs the handler and stores its result, best-effort. A store that
+*   fails, a row that no longer decodes (written under an older schema, or
+*   corrupt), and a failed write are each a miss or a skipped write, never a
+*   tool error. Each is logged at debug level with the tool name.
+* - A handler failure stores nothing, so a retry runs it again.
+* - An `ok: false` result (a {@link ToolOutcome} envelope failure) is never
+*   stored: a "not found" must not replay after the thing exists.
+*
+* This is replay, not exactly-once: two concurrent calls with one key both
+* miss and both run.
+*
+* The key is the whole identity of a request. A hit compares neither the
+* params nor the schema version (a row written under an older schema replays
+* whenever it still decodes), and rows never expire: the store keeps a result
+* until something removes it. A key reused with different params therefore
+* replays the first result, so {@link ToolReplayOptions.key} must fold in a
+* digest of any params that can vary under one id.
+*
+* Wrap it inside {@link ToolOutcome.catchAsEnvelope}, so the envelope sees the
+* handler's real errors and replay sees only real successes.
+*
+* @example
+* ```ts
+* import { ToolReplay } from "@effected/mcp"
+* import { Option, Schema } from "effect"
+*
+* const Created = ToolReplay.success(Schema.Struct({ ok: Schema.Literal(true), id: Schema.Number }))
+* const create = ToolReplay.wrap({
+* 	tool: "goal_create",
+* 	success: Created,
+* 	key: (params: { readonly requestId?: string }) => Option.fromUndefinedOr(params.requestId),
+* })(createGoal)
+* ```
+*
+* @public
+*/
+var ToolReplay = class ToolReplay {
+	constructor() {}
+	/**
+	* The marker field, to spread into each object member of a replayable
+	* success schema. {@link ToolReplay.success} adds it for you.
+	*/
+	static marker = { _idempotentReplay: Schema.optionalKey(Schema.Literal(true).annotate({ description: "Present and true when this result replays an earlier call with the same idempotency key: the stored result is returned and the mutation did not run again." })) };
+	/**
+	* A struct with {@link ToolReplay.marker} added. Use it for each object
+	* success member, so core's encoder keeps the marker on a replayed reply.
+	*
+	* @remarks
+	* Built with core's `fieldsAssign`, which, like `mapFields`, does not carry
+	* the struct's own `.check(...)` refinements over: apply checks to the
+	* result, not to the struct passed in.
+	*/
+	static success = (schema) => schema.pipe(Schema.fieldsAssign(ToolReplay.marker));
+	/**
+	* The `KeyValueStore` key one call is stored under: `<tool>:<key>`. Split on
+	* the first `:` to recover both parts; MCP tool names are `[A-Za-z0-9_.-]`.
+	*/
+	static storeKey = (tool, key) => `${tool}:${key}`;
+	/**
+	* Wraps a handler with replay. Throws at wrap time when `tool` contains
+	* `:`, a wiring mistake, so it surfaces when the server is built.
+	*/
+	static wrap = (options) => {
+		if (options.tool.includes(":")) throw new Error(`ToolReplay.wrap: tool name "${options.tool}" contains ":", the stored-key separator.`);
+		const { tool, success } = options;
+		const given = options.store;
+		const json = Schema.fromJsonString(Schema.toCodecJson(success));
+		const decode = Schema.decodeEffect(json);
+		const encode = Schema.encodeEffect(json);
+		return (handler) => (params) => {
+			const found = options.key(params);
+			if (Option.isNone(found)) return handler(params);
+			const storeKey = ToolReplay.storeKey(tool, found.value);
+			return Effect.gen(function* () {
+				const store = given ?? (yield* KeyValueStore.KeyValueStore);
+				const cached = yield* store.get(storeKey).pipe(Effect.flatMap((raw) => raw === void 0 ? Effect.succeedNone : Effect.asSome(decode(raw))), Effect.tapCause((cause) => Effect.logDebug("ToolReplay lookup failed; treating as a miss", {
+					tool,
+					cause
+				})), Effect.orElseSucceed(() => Option.none()));
+				if (Option.isSome(cached)) {
+					yield* Effect.annotateCurrentSpan("mcp.tool.replayed", true);
+					return withMarker(cached.value);
+				}
+				yield* Effect.annotateCurrentSpan("mcp.tool.replayed", false);
+				const result = yield* handler(params);
+				if (!ToolOutcome.isFailure(result)) yield* encode(result).pipe(Effect.flatMap((encoded) => store.set(storeKey, encoded)), Effect.tapCause((cause) => Effect.logDebug("ToolReplay store failed; result not stored", {
+					tool,
+					cause
+				})), Effect.ignore);
+				return result;
+			}).pipe(Effect.withSpan("ToolReplay.wrap", { attributes: { "mcp.tool.name": tool } }));
+		};
+	};
+};
+const withMarker = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? {
+	...value,
+	_idempotentReplay: true
+} : value;
+
+export { ToolReplay };

package/guard.d.ts

@@ -1,5 +1,4 @@
 import { Effect, Layer, Runtime } from "effect";
-//#region src/McpGuard.d.ts
 /**
  * The slice of the host process the guard uses. Node's `process` satisfies it.
  *
@@ -105,10 +104,21 @@ interface McpGuardRunOptions<ROut, E> {
    * an `at` or `kind` outside these values, does nothing at all. Wire it to
    * an environment variable only a test sets.
    */
-  readonly injectCrash?: {
-    readonly at: "load" | "connected";
-    readonly kind: "uncaughtException" | "unhandledRejection";
-  } | undefined;
+  readonly injectCrash?: InjectCrash | undefined;
+}
+/**
+ * One test-only injected crash, as {@link McpGuard.parseInjectCrash} returns
+ * it and {@link McpGuardRunOptions.injectCrash} takes it: which point of the
+ * launch to raise it at, and which process event to raise. The same shape as
+ * `ProcessGuardInjection` from `@effected/engine/guard`.
+ *
+ * @public
+ */
+interface InjectCrash {
+  /** `"load"`: before the server module loads. `"connected"`: once the server is serving. */
+  readonly at: "load" | "connected";
+  /** The process event raised to the guard's listeners. */
+  readonly kind: "uncaughtException" | "unhandledRejection";
 }
 /**
  * Crash guards for an MCP server process, installed before the server's
@@ -171,10 +181,9 @@ export declare class McpGuard {
    * McpGuard.parseInjectCrash("load:uncaughtException"); // => { at: "load", kind: "uncaughtException" }
    * ```
    */
-  static readonly parseInjectCrash: (value: string | undefined) => McpGuardRunOptions<unknown, unknown>["injectCrash"];
+  static readonly parseInjectCrash: (value: string | undefined) => InjectCrash | undefined;
   /** Install the guards, load the server, and launch it. Resolves once the server is launched. */
   static readonly run: <ROut, E>(options: McpGuardRunOptions<ROut, E>) => Promise<void>;
 }
-//#endregion
-export type { McpGuardHost, McpGuardPolicy, McpGuardRunOptions, McpGuardedServer };
+export type { InjectCrash, McpGuardHost, McpGuardPolicy, McpGuardRunOptions, McpGuardedServer };
 //# sourceMappingURL=guard.d.ts.map

package/index.d.ts

@@ -1,7 +1,7 @@
-import { Array, Context, Effect, JsonSchema, Layer, Runtime, Schema, Stdio } from "effect";
+import { Array, Context, Effect, JsonSchema, Layer, Option, Runtime, Schema, Stdio, Struct } from "effect";
 import { McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
 import { Remediation } from "@effected/engine";
-//#region src/McpStdio.d.ts
+import { KeyValueStore } from "effect/persistence";
 /**
  * Options for {@link McpStdio.layer}.
  *
@@ -188,8 +188,6 @@ export declare class McpStdio {
    */
   static readonly teardown: Runtime.Teardown;
 }
-//#endregion
-//#region src/ToolInputSchema.d.ts
 /**
  * The unknown keys found at one object level of a tool-call payload.
  *
@@ -271,8 +269,6 @@ export declare class ToolInputSchema {
    */
   static readonly objectRooted: (schema: JsonSchema.JsonSchema) => JsonSchema.JsonSchema;
 }
-//#endregion
-//#region src/McpToolkit.d.ts
 /**
  * Options for {@link McpToolkit.layer}.
  *
@@ -477,8 +473,6 @@ export declare class McpToolkit {
    */
   static readonly layer: <Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: McpToolkitOptions) => Layer.Layer<never, never, Tool.HandlersFor<Tools> | Exclude<Tool.HandlerServices<Tools>, McpSchema.McpRequestContext>>;
 }
-//#endregion
-//#region src/ToolFailure.d.ts
 /**
  * How a tool's declared failure should read on the wire.
  *
@@ -518,7 +512,11 @@ export declare class ToolFailure {
   static readonly ECHO_LIMIT: number;
   /** The larger cap for a value the engine produced (a path, a diagnostic), not one a caller typed. */
   static readonly ENGINE_ECHO_LIMIT: number;
-  /** The `message` and `remediation` fields to spread into a consumer's `Schema.TaggedError`. */
+  /**
+   * 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 readonly fields: {
     readonly message: Schema.String;
     readonly remediation: Schema.Struct<{
@@ -539,8 +537,167 @@ export declare class ToolFailure {
    */
   static readonly truncate: (value: string, limit?: number) => string;
 }
-//#endregion
-//#region src/ToolOutputSchema.d.ts
+/**
+ * What a {@link ToolOutcome.catchAsEnvelope} case returns for one caught error:
+ * the same `message` and `remediation` a {@link ToolRefusal} carries, plus any
+ * structured fields the agent branches on.
+ *
+ * @remarks
+ * `message` is the plain sentence. The hint stays in `remediation`, where it
+ * reaches the agent as data; unlike a refusal's message, nothing is folded in.
+ *
+ * @public
+ */
+interface ToolOutcomeErrorInput {
+  readonly message: string;
+  readonly remediation: Remediation;
+  readonly [field: string]: unknown;
+}
+/**
+ * The `ok: false` member of an envelope: `{ ok: false, error: { _tag, message, remediation, ...fields } }`.
+ *
+ * @public
+ */
+interface ToolOutcomeFailure<Tag extends string, I extends ToolOutcomeErrorInput> {
+  readonly ok: false;
+  readonly error: {
+    readonly _tag: Tag;
+  } & I;
+}
+/**
+ * The failure values {@link ToolOutcome.catchAsEnvelope} produces for a set of
+ * cases: one {@link ToolOutcomeFailure} per handled tag.
+ *
+ * @public
+ */
+type ToolOutcomeFailures<Cases> = { [K in keyof Cases]: Cases[K] extends ((...args: ReadonlyArray<never>) => infer I) ? I extends ToolOutcomeErrorInput ? ToolOutcomeFailure<K & string, I> : never : never; }[keyof Cases];
+/**
+ * {@link ToolOutcome.envelope}'s options: annotations for the `ok: false`
+ * member, so a served `outputSchema` can name and describe it.
+ *
+ * @public
+ */
+interface ToolOutcomeEnvelopeOptions {
+  /**
+   * The failure member's schema identifier. Core's JSON Schema output then
+   * emits it once under `$defs` by this name and refers to it with `$ref`.
+   */
+  readonly identifier?: string;
+  /**
+   * The failure member's description, replacing the default one (which says
+   * that `ok: false` carries an expected error to branch on).
+   */
+  readonly description?: string;
+}
+/**
+ * The `ok: false` structured-outcome envelope: an expected error an agent
+ * should branch on, returned on a tool's success channel so it reaches the
+ * client as `structuredContent` instead of message text.
+ *
+ * @remarks
+ * Two channels, two jobs, one error shape:
+ *
+ * - {@link ToolRefusal} is a declared failure: the call itself was wrong, and
+ *   the agent reads one sentence (`isError: true`, message text only; core
+ *   never sends a failure's `structuredContent`).
+ * - `ToolOutcome` is an expected domain outcome: an id that does not exist, a
+ *   transition that is not allowed. The agent branches on its `_tag` and
+ *   fields (`isError: false`, `structuredContent` carries the envelope).
+ *
+ * Both carry {@link ToolFailure.fields} (`message`, `remediation`), so an error
+ * can move between channels without reshaping.
+ *
+ * Success members are not reshaped. Spread {@link ToolOutcome.ok} into each
+ * success struct so a client can discriminate on `ok`; a member that
+ * discriminates another way (`found: true | false`) stays legal.
+ *
+ * @example
+ * ```ts
+ * import { ToolOutcome } from "@effected/mcp"
+ * import { Effect, Schema } from "effect"
+ * import { Tool } from "effect/ai"
+ *
+ * const NotFound = ToolOutcome.error("GoalNotFound", { id: Schema.Number })
+ * const Lookup = Tool.make("goal", {
+ * 	parameters: Schema.Struct({ id: Schema.Number }),
+ * 	success: ToolOutcome.envelope(Schema.Struct({ ...ToolOutcome.ok, goal: Goal }), [NotFound]),
+ * })
+ * // in the handler:
+ * findGoal(id).pipe(
+ * 	Effect.map((goal) => ({ ok: true as const, goal })),
+ * 	ToolOutcome.catchAsEnvelope({
+ * 		GoalNotFound: (e) => ({ id: e.id, message: `No goal ${e.id}.`, remediation: { hint: "List goals first.", suggestedTool: "goal" } }),
+ * 	}),
+ * )
+ * ```
+ *
+ * @public
+ */
+export declare class ToolOutcome {
+  private constructor();
+  /** `{ ok: true }` as schema fields, to spread into each success member. */
+  static readonly ok: {
+    readonly ok: Schema.Literal<true>;
+  };
+  /**
+   * The schema of one envelope error: `_tag`, {@link ToolFailure.fields} and
+   * `fields`. A field named `_tag`, `message` or `remediation` is rejected by
+   * the type, because it would replace the shared one.
+   */
+  static readonly error: <const Tag extends string, const Fields extends Schema.Struct.Fields = Record<never, never>>(tag: Tag, fields?: Fields & { readonly [K in "_tag" | "message" | "remediation"]?: never; }) => Schema.Struct<{
+    readonly _tag: Schema.Literal<Tag>;
+  } & typeof ToolFailure.fields & Fields>;
+  /**
+   * A tool's success schema: `success`, or `{ ok: false, error }` where `error`
+   * is one of `errors`. Object-rooted with {@link ToolOutputSchema.objectRooted},
+   * so core serves its `outputSchema` on every protocol revision.
+   *
+   * @remarks
+   * The failure member, its `ok` and its `error` carry default descriptions.
+   * `options` names the member (`identifier`, served once under `$defs`) or
+   * replaces its description.
+   */
+  static readonly envelope: <S extends Schema.Top, const Errors extends ReadonlyArray<Schema.Top>>(success: S, errors: Errors, options?: ToolOutcomeEnvelopeOptions) => Schema.Union<readonly [S, Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: Schema.Union<Errors>;
+  }>]>;
+  /** One `ok: false` value, for a handler that decides on a failure without catching an error. */
+  static readonly failure: <const Tag extends string, const I extends ToolOutcomeErrorInput>(tag: Tag, error: I) => ToolOutcomeFailure<Tag, I>;
+  /**
+   * Turns each handled tagged error into its `ok: false` value on the success
+   * channel; every other error stays in the error channel. Typed like core's
+   * `Effect.catchTags`: a case for a tag the effect cannot fail with is a type
+   * error, and the handled tags leave `E`.
+   *
+   * @remarks
+   * Write it inline in the effect's `pipe`. `E` is inferred from the effect
+   * being piped, so `effect.pipe(ToolOutcome.catchAsEnvelope({ … }))` checks
+   * every case name against the effect's real tags. Bound to a `const` first,
+   * the combinator never sees that effect: `E` infers as `unknown`, the
+   * unknown-tag check switches off, and a misspelled tag compiles and never
+   * matches. Core's `catchTags` looks a case up only among `cases`' own keys,
+   * so an error tagged `"toString"` or `"constructor"` never hits an inherited
+   * `Object.prototype` member and stays in the error channel.
+   */
+  static readonly catchAsEnvelope: <E, Cases extends { [K in Extract<E, {
+    readonly _tag: string;
+  }>["_tag"]]+?: (error: Extract<E, {
+    readonly _tag: K;
+  }>) => ToolOutcomeErrorInput; } & (unknown extends E ? Record<never, never> : { [K in Exclude<keyof Cases, Extract<E, {
+    readonly _tag: string;
+  }>["_tag"]>]: never; })>(cases: Cases) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | ToolOutcomeFailures<Cases>, Exclude<E, {
+    readonly _tag: keyof Cases;
+  }>, R>;
+  /**
+   * Whether `value` is an `ok: false` envelope member: an object whose `ok` is
+   * exactly `false`. A success member that discriminates some other way, or a
+   * non-object, is not a failure. Narrows to `{ ok: false }` only: it checks
+   * the discriminant, not the `error` payload.
+   */
+  static readonly isFailure: (value: unknown) => value is {
+    readonly ok: false;
+  };
+}
 /**
  * Shaping for a tool's `success` schema, so the `outputSchema` core serves
  * is one every client accepts.
@@ -589,8 +746,6 @@ export declare class ToolOutputSchema {
    */
   static readonly objectRooted: <S extends Schema.Top>(schema: S) => S;
 }
-//#endregion
-//#region src/ToolRefusal.d.ts
 declare const ToolRefusal_base: Schema.Class<ToolRefusal, Schema.TaggedStruct<"ToolRefusal", {
   readonly message: Schema.String;
   readonly remediation: Schema.Struct<{
@@ -647,6 +802,146 @@ export declare class ToolRefusal extends ToolRefusal_base {
    */
   static readonly refuse: (reason: string, remediation: Remediation) => ToolRefusal;
 }
-//#endregion
-export type { FormatUnknownKeysOptions, McpLaunchOptions, McpStdioOptions, McpToolkitOptions, UnionHandlerOptions, UnionTool, UnionToolOptions, UnknownKeysLevel };
+/**
+ * The narrow store {@link ToolReplay.wrap} reads and writes: `get` and `set`
+ * on string values, nothing else.
+ *
+ * @remarks
+ * Core's `KeyValueStore` already satisfies it structurally, so a
+ * `KeyValueStore` value can be passed as is. An application backed by its
+ * own table implements just these two methods, instead of stubbing the
+ * `remove`, `clear` and `size` that `KeyValueStore.makeStringOnly` demands.
+ *
+ * `get` answers `undefined` for a missing key, the same contract as
+ * `KeyValueStore.get`. A failure from either method is never a tool error:
+ * a failed `get` is a miss and a failed `set` is a skipped write, both
+ * logged at debug level, so the error channel is `unknown`.
+ *
+ * @public
+ */
+interface ToolReplayStore {
+  /** The stored value for `key`, or `undefined` when nothing is stored under it. */
+  readonly get: (key: string) => Effect.Effect<string | undefined, unknown>;
+  /** Stores `value` under `key`, replacing any earlier value. */
+  readonly set: (key: string, value: string) => Effect.Effect<void, unknown>;
+}
+/**
+ * What {@link ToolReplay.wrap} needs to know about one tool.
+ *
+ * @typeParam Store - The type of {@link ToolReplayOptions.store}; when it is
+ * omitted, `wrap` requires `KeyValueStore` in `R` instead.
+ *
+ * @public
+ */
+interface ToolReplayOptions<P, S extends Schema.Top, Store extends ToolReplayStore | undefined = undefined> {
+  /** The served tool name. It must not contain `:`, the separator of the stored key ({@link ToolReplay.storeKey}). */
+  readonly tool: string;
+  /**
+   * The tool's success schema. Results are stored encoded through it and
+   * decoded through it on replay. It must declare {@link ToolReplay.marker} on
+   * each object member, or core's encoder drops the marker from the reply:
+   * build each member with {@link ToolReplay.success} so it cannot be left out.
+   */
+  readonly success: S;
+  /**
+   * The idempotency key for one call; `Option.none()` runs the handler with
+   * nothing stored or replayed.
+   *
+   * @remarks
+   * The key must identify the request completely. A replay compares nothing
+   * else: not the params, not the schema version. So a reused key with
+   * different params returns the FIRST call's result. When the params under
+   * one caller-supplied id can vary, fold a digest of them into the key.
+   */
+  readonly key: (params: P) => Option.Option<string>;
+  /**
+   * Where results are stored. Omitted, `wrap` reads core's `KeyValueStore`
+   * from `R`; given, it uses this store and `KeyValueStore` leaves `R`.
+   */
+  readonly store?: Store;
+}
+/**
+ * Idempotent replay for a write tool: a repeated call with the same key returns
+ * the first call's stored result, marked `_idempotentReplay: true`, instead of
+ * running the mutation again.
+ *
+ * @remarks
+ * The store is core's `KeyValueStore` (`effect/persistence`), required in `R`
+ * (`KeyValueStore.layerMemory`, `layerFileSystem` or `layerSql`), unless
+ * {@link ToolReplayOptions.store} supplies a {@link ToolReplayStore}: just
+ * `get` and `set`, for an application's own table. Then `R` carries no
+ * `KeyValueStore`.
+ *
+ * Semantics, per call:
+ *
+ * - A key of `Option.none()` runs the handler; nothing is read or stored.
+ * - A stored value that decodes through `success` is returned with the marker,
+ *   and the handler does not run.
+ * - A miss runs the handler and stores its result, best-effort. A store that
+ *   fails, a row that no longer decodes (written under an older schema, or
+ *   corrupt), and a failed write are each a miss or a skipped write, never a
+ *   tool error. Each is logged at debug level with the tool name.
+ * - A handler failure stores nothing, so a retry runs it again.
+ * - An `ok: false` result (a {@link ToolOutcome} envelope failure) is never
+ *   stored: a "not found" must not replay after the thing exists.
+ *
+ * This is replay, not exactly-once: two concurrent calls with one key both
+ * miss and both run.
+ *
+ * The key is the whole identity of a request. A hit compares neither the
+ * params nor the schema version (a row written under an older schema replays
+ * whenever it still decodes), and rows never expire: the store keeps a result
+ * until something removes it. A key reused with different params therefore
+ * replays the first result, so {@link ToolReplayOptions.key} must fold in a
+ * digest of any params that can vary under one id.
+ *
+ * Wrap it inside {@link ToolOutcome.catchAsEnvelope}, so the envelope sees the
+ * handler's real errors and replay sees only real successes.
+ *
+ * @example
+ * ```ts
+ * import { ToolReplay } from "@effected/mcp"
+ * import { Option, Schema } from "effect"
+ *
+ * const Created = ToolReplay.success(Schema.Struct({ ok: Schema.Literal(true), id: Schema.Number }))
+ * const create = ToolReplay.wrap({
+ * 	tool: "goal_create",
+ * 	success: Created,
+ * 	key: (params: { readonly requestId?: string }) => Option.fromUndefinedOr(params.requestId),
+ * })(createGoal)
+ * ```
+ *
+ * @public
+ */
+export declare class ToolReplay {
+  private constructor();
+  /**
+   * The marker field, to spread into each object member of a replayable
+   * success schema. {@link ToolReplay.success} adds it for you.
+   */
+  static readonly marker: {
+    readonly _idempotentReplay: Schema.optionalKey<Schema.Literal<true>>;
+  };
+  /**
+   * A struct with {@link ToolReplay.marker} added. Use it for each object
+   * success member, so core's encoder keeps the marker on a replayed reply.
+   *
+   * @remarks
+   * Built with core's `fieldsAssign`, which, like `mapFields`, does not carry
+   * the struct's own `.check(...)` refinements over: apply checks to the
+   * result, not to the struct passed in.
+   */
+  static readonly success: <const Fields extends Schema.Struct.Fields>(schema: Schema.Struct<Fields>) => Schema.Struct<Struct.Simplify<Struct.Assign<Fields, typeof ToolReplay.marker>>>;
+  /**
+   * The `KeyValueStore` key one call is stored under: `<tool>:<key>`. Split on
+   * the first `:` to recover both parts; MCP tool names are `[A-Za-z0-9_.-]`.
+   */
+  static readonly storeKey: (tool: string, key: string) => string;
+  /**
+   * Wraps a handler with replay. Throws at wrap time when `tool` contains
+   * `:`, a wiring mistake, so it surfaces when the server is built.
+   */
+  static readonly wrap: <P, S extends Schema.Top, Store extends ToolReplayStore | undefined = undefined>(options: ToolReplayOptions<P, S, Store>) => (<E, R>(handler: (params: P) => Effect.Effect<S["Type"], E, R>) => (params: P) => Effect.Effect<S["Type"], E, R | ([Store] extends [ToolReplayStore] ? never : KeyValueStore.KeyValueStore) | S["DecodingServices"] | S["EncodingServices"]>);
+}
+export type { FormatUnknownKeysOptions, McpLaunchOptions, McpStdioOptions, McpToolkitOptions, ToolOutcomeEnvelopeOptions, ToolOutcomeErrorInput, ToolOutcomeFailure, ToolOutcomeFailures, ToolReplayOptions, ToolReplayStore, UnionHandlerOptions, UnionTool, UnionToolOptions, UnknownKeysLevel };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -3,6 +3,8 @@ import { ToolFailure } from "./ToolFailure.js";
 import { ToolInputSchema } from "./ToolInputSchema.js";
 import { McpToolkit } from "./McpToolkit.js";
 import { ToolOutputSchema } from "./ToolOutputSchema.js";
+import { ToolOutcome } from "./ToolOutcome.js";
 import { ToolRefusal } from "./ToolRefusal.js";
+import { ToolReplay } from "./ToolReplay.js";
 
-export { McpStdio, McpToolkit, ToolFailure, ToolInputSchema, ToolOutputSchema, ToolRefusal };
+export { McpStdio, McpToolkit, ToolFailure, ToolInputSchema, ToolOutcome, ToolOutputSchema, ToolRefusal, ToolReplay };

package/internal/LaunchFailed.js

@@ -1,6 +1,6 @@
 import { Runtime } from "effect";
 
-//#region src/internal/LaunchFailed.ts
+// src/internal/LaunchFailed.ts
 /**
 * The failure `McpStdio.launch` re-raises after reporting a launch failure on
 * stderr itself. `errorReported: false` keeps `runMain` from reporting it a
@@ -31,5 +31,4 @@ var LaunchFailed = class extends Error {
 	}
 };
 
-//#endregion
 export { LaunchFailed };

package/internal/StdinFrames.js

@@ -1,7 +1,7 @@
 import { Effect, Layer, Stdio, Stream } from "effect";
 import { McpSchema } from "effect/ai";
 
-//#region src/internal/StdinFrames.ts
+// src/internal/StdinFrames.ts
 /**
 * The line-length cap core's stdio NDJSON decoder applies, in the same unit
 * (UTF-16 code units of the decoded text) and with the same predicate
@@ -235,5 +235,4 @@ const guardStdin = (stdio) => {
 */
 const makeGuardedStdio = () => Layer.effect(Stdio.Stdio, Effect.map(Stdio.Stdio, guardStdin));
 
-//#endregion
 export { INVALID_REQUEST_FRAME, MAX_FRAME_LENGTH, PARSE_ERROR_FRAME, RPC_CONTROL_PREFIX, guardStdin, makeFrameGuard, makeGuardedStdio, methodNotFoundFrame };

package/internal/guardLaunch.js

@@ -1,7 +1,7 @@
 import { McpStdio } from "../McpStdio.js";
 import { Effect } from "effect";
 
-//#region src/internal/guardLaunch.ts
+// src/internal/guardLaunch.ts
 /**
 * The server half of `McpGuard.run`, reached only through a dynamic import so
 * the guard module itself evaluates nothing but its own code.
@@ -10,5 +10,4 @@ import { Effect } from "effect";
 */
 const launchGuarded = (server, onReady) => server.runMain(McpStdio.launch(server.layer, { onReady: Effect.sync(onReady) }), { teardown: McpStdio.teardown });
 
-//#endregion
 export { launchGuarded };

package/internal/wire.js

@@ -1,6 +1,6 @@
 import { Result } from "effect";
 
-//#region src/internal/wire.ts
+// src/internal/wire.ts
 /** @internal */
 const DEFAULT_CLIENT_INFO = {
 	name: "effected-mcp-testing",
@@ -62,5 +62,4 @@ const initializeParams = (protocol, clientInfo) => ({
 	clientInfo
 });
 
-//#endregion
 export { DEFAULT_CLIENT_INFO, STDERR_HINT, frame, initializeParams, isJsonRpcMessage, isResponse, isStateless, parseFrame, requestKey };

package/node.d.ts

@@ -0,0 +1,126 @@
+import { Writable } from "node:stream";
+import { Effect } from "effect";
+/**
+ * Anything with a replaceable `write`: a patched stream (Node's
+ * `process.stdout` and `process.stderr`) and a sink captured writes go to (a
+ * Node `Writable`, {@link StdioCapture.nullWritable}, {@link StdioCapture.discard},
+ * {@link StdioCapture.toStderr}).
+ *
+ * @remarks
+ * A sink's `write` receives exactly the arguments the patched stream's
+ * `write` was called with, including any trailing callback, so a sink must
+ * call that callback itself, as a `Writable` does.
+ *
+ * @public
+ */
+interface StdioSink {
+  write(chunk: any, ...rest: Array<any>): boolean;
+}
+/**
+ * The two streams {@link StdioCapture.install} patches. Node's `process`
+ * satisfies it; pass it in from `main.ts`.
+ *
+ * @public
+ */
+interface StdioCaptureHost {
+  readonly stdout: StdioSink;
+  readonly stderr: StdioSink;
+}
+/**
+ * The sinks for one capture. `stderr` passes through to the real stream when
+ * omitted.
+ *
+ * @public
+ */
+interface StdioCaptureOptions {
+  readonly stdout: StdioSink;
+  readonly stderr?: StdioSink | undefined;
+}
+/**
+ * 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
+ */
+export declare class StdioCapture {
+  /** A sink that writes through the host's original, unpatched stderr: captured output stays visible off the wire. */
+  readonly toStderr: StdioSink;
+  private constructor();
+  /**
+   * 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 readonly install: (host: StdioCaptureHost) => StdioCapture;
+  /**
+   * 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 readonly discard: StdioSink;
+  /**
+   * 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 readonly nullWritable: () => Writable;
+  /**
+   * Runs `evaluate` with its writes captured, for code that is not Effect.
+   * A synchronous throw from `evaluate` rejects the returned promise.
+   */
+  run<A>(options: StdioCaptureOptions, evaluate: () => PromiseLike<A>): Promise<A>;
+  /**
+   * 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: StdioCaptureOptions): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+export type { StdioCaptureHost, StdioCaptureOptions, StdioSink };
+//# sourceMappingURL=node.d.ts.map

package/node.js

@@ -0,0 +1,3 @@
+import { StdioCapture } from "./StdioCapture.js";
+
+export { StdioCapture };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/mcp",
-	"version": "0.8.0",
+	"version": "0.10.0",
 	"private": false,
 	"description": "The boundary layer of an effect/ai MCP server: stdio wiring that keeps stdout the wire, tool-failure shaping, strict-input walkers, and test clients",
 	"keywords": [
@@ -39,6 +39,11 @@
 			"import": "./guard.js",
 			"default": "./guard.js"
 		},
+		"./node": {
+			"types": "./node.d.ts",
+			"import": "./node.js",
+			"default": "./node.js"
+		},
 		"./testing": {
 			"types": "./testing.d.ts",
 			"import": "./testing.js",
@@ -47,7 +52,7 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/engine": "^0.7.0",
+		"@effected/engine": "^0.9.0",
 		"effect": "^4.0.0"
 	},
 	"engines": {

package/testing.d.ts

@@ -1,7 +1,6 @@
 import { Duration, Effect, JsonSchema, Layer, PlatformError, Schema, Scope, Stdio } from "effect";
 import { McpProtocol } from "effect/ai";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
-//#region src/McpTestFailure.d.ts
 declare const McpTestFailure_base: Schema.Class<McpTestFailure, Schema.TaggedStruct<"McpTestFailure", {
   /** Which failure occurred; see the list above for which client raises which. */
   readonly reason: Schema.Literals<readonly ["StreamEnded", "ServerStopped", "NotJsonRpc", "NotInitialized", "ErrorResponse", "TimedOut"]>;
@@ -40,8 +39,6 @@ declare const McpTestFailure_base: Schema.Class<McpTestFailure, Schema.TaggedStr
  * @public
  */
 export declare class McpTestFailure extends McpTestFailure_base {}
-//#endregion
-//#region src/McpWire.d.ts
 /**
  * One JSON-RPC 2.0 frame as an MCP test client sees it.
  *
@@ -92,8 +89,6 @@ interface ServedResource {
     readonly [key: string]: unknown;
   } | undefined;
 }
-//#endregion
-//#region src/McpHarness.d.ts
 /**
  * Options for {@link McpHarness.make}.
  *
@@ -238,8 +233,6 @@ export declare class McpHarness {
   /** Build `server` over queue-backed stdio and return a client for it; fails with the layer's own error if it cannot build. */
   static readonly make: <ROut, E, R>(server: Layer.Layer<ROut, E, R>, options?: McpHarnessOptions) => Effect.Effect<McpHarness, E, Scope.Scope | Exclude<R, Stdio.Stdio>>;
 }
-//#endregion
-//#region src/McpProbe.d.ts
 /**
  * Options for {@link McpProbe.initialize}.
  *
@@ -310,8 +303,6 @@ export declare class McpProbe {
    */
   static readonly initialize: (command: ChildProcess.Command, options?: McpProbeOptions) => Effect.Effect<McpProbeResult, McpTestFailure | PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner>;
 }
-//#endregion
-//#region src/McpProcess.d.ts
 /**
  * Options for {@link McpProcess.stderrUntil}.
  *
@@ -423,8 +414,6 @@ export declare class McpProcess {
   /** Spawn `command` for the life of the current scope. */
   static readonly spawn: (command: ChildProcess.Command) => Effect.Effect<McpProcess, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner | Scope.Scope>;
 }
-//#endregion
-//#region src/McpToolAudit.d.ts
 /**
  * The policy {@link McpToolAudit.check} enforces.
  *
@@ -489,6 +478,5 @@ export declare class McpToolAudit {
    */
   static readonly check: (tools: ReadonlyArray<ServedTool>, policy: McpToolAuditPolicy) => ReadonlyArray<string>;
 }
-//#endregion
 export type { JsonRpcMessage, McpHarnessOptions, McpProbeOptions, McpProbeResult, McpProcessStderrUntilOptions, McpToolAuditPolicy, ServedResource, ServedTool };
 //# sourceMappingURL=testing.d.ts.map

package/tsdoc-metadata.json

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