@effected/mcp 0.10.0 → 0.12.0

package/McpHarness.js

@@ -3,8 +3,38 @@ import { DEFAULT_CLIENT_INFO, frame, initializeParams, isJsonRpcMessage, isRespo
 import { McpTestFailure } from "./McpTestFailure.js";
 import { Console, Deferred, Effect, Exit, Fiber, Layer, Queue, Sink, Stdio, Stream } from "effect";
 import { McpProtocol } from "effect/ai";
+import { ErrorText } from "@effected/engine";
 
 // src/McpHarness.ts
+/** The generic tag `Object.prototype.toString` answers with: a value with no string form of its own. */
+const GENERIC_STRING = /^\[object [^\]]*\]$/;
+/**
+* One captured console argument as text, as close to what the console would show as a runtime-free rendering gets,
+* and never throwing.
+*
+* @remarks
+* A harness records what the server would have printed, so the record must not lose what the console shows. Hence
+* the order: a value's own string form first (`String(error)` is `Error: boom`, where `ErrorText.describe` would keep
+* only `boom`, and it is the same for any object carrying a `message`), then JSON for an array or a plain object,
+* whose string form is `1,2` or `[object Object]`. `ErrorText.describe` is the last resort for a value whose string
+* form throws and which has no JSON: an object with no prototype has no `toString`, and `String` throws on it inside
+* the server's own console call.
+*/
+const showArg = (arg) => {
+	if (typeof arg === "string") return arg;
+	if (typeof arg !== "object" || arg === null) return ErrorText.describe(arg);
+	try {
+		if (!Array.isArray(arg)) {
+			const text = String(arg);
+			if (!GENERIC_STRING.test(text)) return text;
+		}
+	} catch {}
+	try {
+		const json = JSON.stringify(arg);
+		if (json !== void 0) return json;
+	} catch {}
+	return ErrorText.describe(arg);
+};
 /**
 * An in-process MCP client for a real server layer, over queue-backed stdio.
 *
@@ -109,7 +139,15 @@ var McpHarness = class McpHarness {
 	sentSoFar;
 	/** Everything written to stderr, plus every captured log line. */
 	stderrSoFar;
-	/** Every captured `console.log`, `info` or `debug` call. */
+	/**
+	* Every captured `console.log`, `info` or `debug` call, its arguments joined with a space, each rendered close to
+	* what the console would show: a string as itself, a value with its own string form as that form (an `Error` as
+	* `Error: boom`, a number, a date), an array or a plain object as JSON (`{"message":"x"}`, not just `x`).
+	*
+	* @remarks
+	* Rendering never throws inside the server's own call. A value whose string form throws (an object with no
+	* prototype, a throwing `toString`) and has no JSON falls back to `ErrorText.describe` from `@effected/engine`.
+	*/
 	consoleLogSoFar;
 	/**
 	* End stdin, as a client disconnecting does. The server drains first:
@@ -171,7 +209,7 @@ var McpHarness = class McpHarness {
 			}))
 		});
 		const ambient = yield* Console.Console;
-		const show = (args) => args.map((arg) => typeof arg === "string" ? arg : String(arg)).join(" ");
+		const show = (args) => args.map(showArg).join(" ");
 		const toStdout = (...args) => {
 			consoleLog.push(show(args));
 		};

package/McpStdio.js

@@ -16,7 +16,8 @@ import { McpProtocol, McpServer } from "effect/ai";
 * ```
 *
 * - {@link McpStdio.layer} is `McpServer.layerStdio` with `LogToStderr`
-*   provided and merged into its output, and `Layer.orDie`. It answers a
+*   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
@@ -57,14 +58,24 @@ var McpStdio = class McpStdio {
 	/**
 	* `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.
+	* `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
-	* Only a layer this one provides inherits `LogToStderr`: compose with
-	* `Layer.provideMerge(McpStdio.layer(...))`. A sibling merged beside it
-	* with `Layer.mergeAll` is not provided by it, so its build logs still
+	* 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`,
@@ -94,14 +105,6 @@ var McpStdio = class McpStdio {
 	* object with neither `method` nor `id`, which is neither a request nor a
 	* response.
 	*
-	* A line whose `method` starts with `@effect/rpc/` never reaches core,
-	* whose JSON-RPC decoder would read one without an `id` as its own RPC
-	* control message: `@effect/rpc/Eof` alone silently stops the server
-	* (Effect-TS/effect#8499, open upstream). Such a request is answered
-	* `-32601` Method not found, echoing its `id`; such a notification is
-	* dropped. The guard stops doing this once core no longer treats a
-	* client's `@effect/rpc/` frame as a control message.
-	*
 	* 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
@@ -115,8 +118,8 @@ var McpStdio = class McpStdio {
 	* anywhere under the first one's `Effect.provide`: nested `Layer.build`
 	* and `Effect.provide` fork the ambient memo map rather than starting a
 	* new one. The tool registry is shared the same way. Isolate each server
-	* by wrapping its whole bundle (its toolkit layers together with this
-	* layer) in `Layer.fresh`, or with its own `ManagedRuntime`,
+	* 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.
@@ -134,8 +137,9 @@ var McpStdio = class McpStdio {
 		version: options.version,
 		instructions: options.instructions,
 		description: options.description,
-		protocols: options.protocols ?? McpStdio.protocols
-	}).pipe(Layer.provide(makeGuardedStdio()), Layer.provideMerge(Layer.succeed(References.LogToStderr, true)), Layer.orDie);
+		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

package/McpToolkit.js

@@ -232,6 +232,17 @@ var McpToolkit = class {
 	/**
 	* `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;

package/README.md

@@ -8,10 +8,10 @@ The boundary layer of an `effect/ai` MCP server: stdio wiring that keeps stdout
 [![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
 > **Pre-`1.0.0`.** This package is part of the `@effected/*` kit, built on stable
-> Effect v4 (`effect` `^4.0.0`) and still in `0.x` development. Stable Effect
+> Effect v4 (`effect` `~4.1.0`) and still in `0.x` development. Stable Effect
 > makes a kit `1.0.0` possible, not automatic. To keep your `effect` and
 > `@effect/*` versions on the line the kit is built and tested against, install
-> [`@effected/pnpm-plugin-effect`](https://www.npmjs.com/package/@effected/pnpm-plugin-effect).
+> [`@effected/pnpm-plugin-effected`](https://www.npmjs.com/package/@effected/pnpm-plugin-effected).
 >
 > **Stability: unstable.** This package's API surface is not yet considered
 > complete and may change across `0.x` releases. Pin an exact version — even a
@@ -486,7 +486,7 @@ with no child process and no sockets. Pass `server` **without** a `Stdio`
 of its own — a `Stdio` the server provides internally would talk to the
 real terminal instead of the test's queues, including one that arrives
 bundled: `@effect/platform-node`'s `NodeServices.layer` brings its own
-`Stdio` along with `FileSystem`, `Path`, `ChildProcessSpawner`, `Crypto`
+`Stdio` along with `FileSystem`, `Path`, `ChildProcessSpawner`
 and `Terminal`, so composing the server with that bundle loses the harness's
 `Stdio` the same way. Compose the individual platform layers the server
 needs instead and leave `Stdio` out; the harness supplies it. The harness builds the server

package/ToolReplay.js

@@ -15,6 +15,13 @@ import { KeyValueStore } from "effect/persistence";
 * `get` and `set`, for an application's own table. Then `R` carries no
 * `KeyValueStore`.
 *
+* Inside an MCP server, pass the store. A service left in a handler's `R`
+* has to be declared in the tool's `dependencies`, which makes it a
+* request-level dependency that only MCP middleware can meet. Read
+* `KeyValueStore` once when the handlers are built, with the effect form of
+* `Toolkit.toLayer`, and hand it to `wrap` as `store`: a `KeyValueStore`
+* satisfies {@link ToolReplayStore} as is.
+*
 * Semantics, per call:
 *
 * - A key of `Option.none()` runs the handler; nothing is read or stored.

package/index.d.ts

@@ -1,4 +1,4 @@
-import { Array, Context, Effect, JsonSchema, Layer, Option, Runtime, Schema, Stdio, Struct } from "effect";
+import { Array, Cause, Context, Effect, JsonSchema, Layer, Option, Runtime, Schema, Scope, Stdio, Struct } from "effect";
 import { McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
 import { Remediation } from "@effected/engine";
 import { KeyValueStore } from "effect/persistence";
@@ -7,7 +7,7 @@ import { KeyValueStore } from "effect/persistence";
  *
  * @public
  */
-interface McpStdioOptions {
+interface McpStdioOptions<RA = never, RE = never, RR = never> {
   /** The server name reported to the client. */
   readonly name: string;
   /** The server version reported to the client. */
@@ -18,7 +18,28 @@ interface McpStdioOptions {
   readonly description?: string | undefined;
   /** Defaults to {@link McpStdio.protocols}. Read its ordering rules before overriding. */
   readonly protocols?: Array.NonEmptyReadonlyArray<McpProtocol.ProtocolAdapter> | undefined;
+  /**
+   * The server's registration layers (toolkits, resources, prompts), built
+   * before the server reads its first request and under `LogToStderr`.
+   *
+   * @remarks
+   * Core's `registrations` option of `McpServer.layerStdio`. The transport
+   * discharges each `McpServer.McpRequest<"Requires", Scope>` marker; any
+   * other request-level marker stays in the layer's requirements, to be met
+   * by MCP middleware. A registration that needs `Stdio` when it is built
+   * gets the guarded one this layer serves over.
+   */
+  readonly registrations?: Layer.Layer<RA, RE, RR> | undefined;
 }
+/**
+ * The services a registration layer needs that {@link McpStdio.layer} does
+ * not supply: everything but `McpServer` and `Stdio` (which the layer
+ * requires itself), with each request-level marker but
+ * `McpServer.McpRequest<"Requires", Scope>`, which the transport discharges.
+ *
+ * @public
+ */
+type McpStdioRegistrationServices<RR> = Exclude<McpServer.McpRequest.Without<RR>, McpServer.McpServer> | McpServer.McpRequest.From<"Requires", Exclude<McpServer.McpRequest.Only<"Requires", RR>, Scope.Scope>>;
 /**
  * Options for {@link McpStdio.launch}.
  *
@@ -51,7 +72,8 @@ interface McpLaunchOptions {
  * ```
  *
  * - {@link McpStdio.layer} is `McpServer.layerStdio` with `LogToStderr`
- *   provided and merged into its output, and `Layer.orDie`. It answers a
+ *   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
@@ -88,14 +110,24 @@ export declare class McpStdio {
   /**
    * `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.
+   * `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
-   * Only a layer this one provides inherits `LogToStderr`: compose with
-   * `Layer.provideMerge(McpStdio.layer(...))`. A sibling merged beside it
-   * with `Layer.mergeAll` is not provided by it, so its build logs still
+   * 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`,
@@ -125,14 +157,6 @@ export declare class McpStdio {
    * object with neither `method` nor `id`, which is neither a request nor a
    * response.
    *
-   * A line whose `method` starts with `@effect/rpc/` never reaches core,
-   * whose JSON-RPC decoder would read one without an `id` as its own RPC
-   * control message: `@effect/rpc/Eof` alone silently stops the server
-   * (Effect-TS/effect#8499, open upstream). Such a request is answered
-   * `-32601` Method not found, echoing its `id`; such a notification is
-   * dropped. The guard stops doing this once core no longer treats a
-   * client's `@effect/rpc/` frame as a control message.
-   *
    * 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
@@ -146,8 +170,8 @@ export declare class McpStdio {
    * anywhere under the first one's `Effect.provide`: nested `Layer.build`
    * and `Effect.provide` fork the ambient memo map rather than starting a
    * new one. The tool registry is shared the same way. Isolate each server
-   * by wrapping its whole bundle (its toolkit layers together with this
-   * layer) in `Layer.fresh`, or with its own `ManagedRuntime`,
+   * 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.
@@ -160,7 +184,7 @@ export declare class McpStdio {
    * Each call mints a fresh layer; bind the result to a `const` or the
    * server builds twice.
    */
-  static readonly layer: (options: McpStdioOptions) => Layer.Layer<McpServer.McpServer | McpSchema.McpServerClient, never, Stdio.Stdio>;
+  static readonly layer: <RA = never, RE = never, RR = never>(options: McpStdioOptions<RA, RE, RR>) => Layer.Layer<McpServer.McpServer | McpServer.McpRequest<"Requires", Scope.Scope>, Exclude<RE, Cause.IllegalArgumentError>, Stdio.Stdio | McpStdioRegistrationServices<RR>>;
   /**
    * `Layer.launch`, with any failure other than an interrupt logged on
    * stderr here and re-raised marked as already reported, keeping its exit
@@ -470,8 +494,19 @@ export declare class McpToolkit {
   /**
    * `McpServer.toolkit`'s registration layer, strict by default.
    * `options.unknownKeyMessage` is deprecated and ignored.
-   */
-  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>>;
+   *
+   * @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 readonly layer: <Tools extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: McpToolkitOptions) => Layer.Layer<never, never, Exclude<McpServer.ToolkitRequirements<Tools>, McpServer.McpServer>>;
 }
 /**
  * How a tool's declared failure should read on the wire.
@@ -810,7 +845,7 @@ export declare class ToolRefusal extends ToolRefusal_base {
  * 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.
+ * `remove`, `clear`, `size` and `keys` 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:
@@ -872,6 +907,13 @@ interface ToolReplayOptions<P, S extends Schema.Top, Store extends ToolReplaySto
  * `get` and `set`, for an application's own table. Then `R` carries no
  * `KeyValueStore`.
  *
+ * Inside an MCP server, pass the store. A service left in a handler's `R`
+ * has to be declared in the tool's `dependencies`, which makes it a
+ * request-level dependency that only MCP middleware can meet. Read
+ * `KeyValueStore` once when the handlers are built, with the effect form of
+ * `Toolkit.toLayer`, and hand it to `wrap` as `store`: a `KeyValueStore`
+ * satisfies {@link ToolReplayStore} as is.
+ *
  * Semantics, per call:
  *
  * - A key of `Option.none()` runs the handler; nothing is read or stored.
@@ -943,5 +985,5 @@ export declare class ToolReplay {
    */
   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 };
+export type { FormatUnknownKeysOptions, McpLaunchOptions, McpStdioOptions, McpStdioRegistrationServices, McpToolkitOptions, ToolOutcomeEnvelopeOptions, ToolOutcomeErrorInput, ToolOutcomeFailure, ToolOutcomeFailures, ToolReplayOptions, ToolReplayStore, UnionHandlerOptions, UnionTool, UnionToolOptions, UnknownKeysLevel };
 //# sourceMappingURL=index.d.ts.map

package/internal/StdinFrames.js

@@ -40,36 +40,12 @@ const INVALID_REQUEST_FRAME = `${JSON.stringify({
 		message: "Invalid Request"
 	}
 })}\n`;
-/**
-* The JSON-RPC 2.0 answer to a request whose method is one of Effect's
-* internal `@effect/rpc/` control messages, newline-framed, echoing the
-* request's `id`.
-*
-* @internal
-*/
-const methodNotFoundFrame = (id) => `${JSON.stringify({
-	jsonrpc: "2.0",
-	id,
-	error: {
-		code: McpSchema.METHOD_NOT_FOUND_ERROR_CODE,
-		message: "Method not found"
-	}
-})}\n`;
-/**
-* The method prefix core's JSON-RPC decoder reserves for its own RPC control
-* messages (`Eof`, `Interrupt`, `Ack`, …).
-*
-* @internal
-*/
-const RPC_CONTROL_PREFIX = "@effect/rpc/";
 /** JSON's insignificant whitespace, minus the newline that ends the line. */
 const BLANK = /^[ \t\r]*$/;
 const isNullish = (value) => value === null || value === void 0;
-/** {@link answerFor}'s verdict for a line that is neither forwarded nor answered. */
-const DROP = "";
 /**
-* The guard's answer to one non-blank line within the cap, `DROP` to swallow
-* it silently, or `undefined` to forward it to core.
+* The guard's answer to one non-blank line within the cap, or `undefined` to
+* forward it to core.
 *
 * @remarks
 * A frame that parses is forwarded unless core would skip it without a
@@ -82,16 +58,9 @@ const DROP = "";
 *   `method` and every response an `id`, so it is neither, and core ignores it
 *   as a response to nothing.
 *
-* A frame whose `method` starts with `@effect/rpc/` never reaches core. Core's
-* JSON-RPC decoder reads such a frame with no `id` as one of its own RPC
-* control messages, so `{"jsonrpc":"2.0","method":"@effect/rpc/Eof"}` from
-* any client silently stops the server (Effect-TS/effect#8499). A
-* notification of that shape is dropped; a request, which carries an `id`,
-* is answered `-32601` Method not found, as no MCP method has that prefix.
-* Remove this branch once Effect-TS/effect#8499 is fixed in the installed
-* `effect` (the open PR #8509 proposes the fix) and a probe shows an
-* unguarded server still answering a ping sent after an `@effect/rpc/Eof`
-* notification.
+* A frame whose `method` starts with `@effect/rpc/` is an ordinary request or
+* notification to core, which serves MCP with Effect's RPC control messages
+* turned off: a notification is ignored and a request answered `-32601`.
 *
 * Arrays are forwarded: core answers a batch `-32600` itself. So is any object
 * with an `id` and no `method`, which is a response; JSON-RPC never answers a
@@ -107,10 +76,7 @@ const answerFor = (line) => {
 	if (typeof value !== "object" || value === null) return INVALID_REQUEST_FRAME;
 	if (Array.isArray(value)) return void 0;
 	const message = value;
-	if (Object.hasOwn(message, "method")) {
-		if (typeof message.method === "string" && message.method.startsWith("@effect/rpc/")) return isNullish(message.id) ? DROP : methodNotFoundFrame(message.id);
-		return typeof message.method !== "string" && isNullish(message.id) ? INVALID_REQUEST_FRAME : void 0;
-	}
+	if (Object.hasOwn(message, "method")) return typeof message.method !== "string" && isNullish(message.id) ? INVALID_REQUEST_FRAME : void 0;
 	return Object.hasOwn(message, "id") ? void 0 : INVALID_REQUEST_FRAME;
 };
 /**
@@ -125,8 +91,7 @@ const answerFor = (line) => {
 * JSON-RPC 2.0 requires a reply to each of them, so the guard frames stdin
 * exactly as core does and answers such a line itself, returning
 * {@link PARSE_ERROR_FRAME} or {@link INVALID_REQUEST_FRAME} for the caller
-* to write. It also keeps `@effect/rpc/` control methods away from core (see
-* `answerFor`), which would otherwise let one client line stop the server.
+* to write.
 *
 * - Decoding mirrors core: one streaming UTF-8 decoder, so a character split
 *   across chunks decodes whole, a byte-order mark is stripped only at the
@@ -137,8 +102,6 @@ const answerFor = (line) => {
 * - A line that is JSON is answered `-32600` when it is not an object or an
 *   array, when its `method` is not a string and it has no usable `id`, or
 *   when it has neither `method` nor `id`.
-* - A line whose `method` starts with `@effect/rpc/` is answered `-32601`
-*   when it carries an `id` and dropped when it does not.
 * - Everything else goes to core.
 * - A line longer than `maxFrameLength` code units is answered once, as soon
 *   as the held part exceeds the cap, and the rest of it is discarded up to
@@ -181,7 +144,7 @@ const makeFrameGuard = (maxFrameLength = MAX_FRAME_LENGTH) => {
 			if (BLANK.test(line)) continue;
 			const answer = answerFor(line);
 			if (answer === void 0) forward += `${line}\n`;
-			else if (answer !== DROP) replies.push(answer);
+			else replies.push(answer);
 		}
 		pending += text.slice(start);
 		if (pending.length > maxFrameLength) {
@@ -235,4 +198,4 @@ const guardStdin = (stdio) => {
 */
 const makeGuardedStdio = () => Layer.effect(Stdio.Stdio, Effect.map(Stdio.Stdio, guardStdin));
 
-export { INVALID_REQUEST_FRAME, MAX_FRAME_LENGTH, PARSE_ERROR_FRAME, RPC_CONTROL_PREFIX, guardStdin, makeFrameGuard, makeGuardedStdio, methodNotFoundFrame };
+export { INVALID_REQUEST_FRAME, MAX_FRAME_LENGTH, PARSE_ERROR_FRAME, guardStdin, makeFrameGuard, makeGuardedStdio };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/mcp",
-	"version": "0.10.0",
+	"version": "0.12.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": [
@@ -52,8 +52,8 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/engine": "^0.9.0",
-		"effect": "^4.0.0"
+		"@effected/engine": "^0.11.0",
+		"effect": "~4.1.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/testing.d.ts

@@ -214,7 +214,15 @@ export declare class McpHarness {
   readonly sentSoFar: Effect.Effect<ReadonlyArray<unknown>>;
   /** Everything written to stderr, plus every captured log line. */
   readonly stderrSoFar: Effect.Effect<string>;
-  /** Every captured `console.log`, `info` or `debug` call. */
+  /**
+   * Every captured `console.log`, `info` or `debug` call, its arguments joined with a space, each rendered close to
+   * what the console would show: a string as itself, a value with its own string form as that form (an `Error` as
+   * `Error: boom`, a number, a date), an array or a plain object as JSON (`{"message":"x"}`, not just `x`).
+   *
+   * @remarks
+   * Rendering never throws inside the server's own call. A value whose string form throws (an object with no
+   * prototype, a throwing `toString`) and has no JSON falls back to `ErrorText.describe` from `@effected/engine`.
+   */
   readonly consoleLogSoFar: Effect.Effect<ReadonlyArray<string>>;
   /**
    * End stdin, as a client disconnecting does. The server drains first:

package/tsdoc-metadata.json

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