@effected/mcp 0.2.0 → 0.4.0

package/index.d.ts

@@ -1,5 +1,5 @@
 import { Array, Context, Effect, JsonSchema, Layer, Runtime, Schema, Stdio } from "effect";
-import { McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/unstable/ai";
+import { McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
 import { Remediation } from "@effected/engine";
 //#region src/McpStdio.d.ts
 /**
@@ -74,10 +74,9 @@ export declare class McpStdio {
    * first, then the two newest stateful ones.
    *
    * @remarks
-   * Real clients open with either handshake: Claude Code 2.1.281 was
-   * measured opening a stdio server with the stateless `server/discover`,
-   * while most other shipping clients still send `initialize`. The order
-   * is load-bearing:
+   * Real clients open with either handshake: some (Claude Code, for one)
+   * open a stdio server with the stateless `server/discover`, while others
+   * still send `initialize`. The order is load-bearing:
    *
    * - Stateless first: a request with no session and no `_meta` falls to
    *   `protocols[0]`.
@@ -99,26 +98,35 @@ export declare class McpStdio {
    *
    * The server reads stdin through a guard that frames it exactly as core's
    * decoder does: one streaming UTF-8 decoder, a byte-order mark stripped
-   * only at the start of the stream, lines split on `\n`. A line that is
-   * not JSON is answered on stdout with a JSON-RPC parse error, code
-   * `-32700` and `id: null`, and never reaches core's decoder, which would
-   * otherwise throw on that line again for every later chunk and stop
-   * answering. So is a line longer than core's cap of 16 Mi UTF-16 code
-   * units: it is answered once, as soon as it passes the cap, and the rest
-   * of it is discarded up to its newline. A line of JSON whitespace (space,
-   * tab, carriage return) is ignored.
+   * only at the start of the stream, lines split on `\n`. Core itself skips
+   * a line it cannot use and keeps serving, but sends no reply, where
+   * JSON-RPC 2.0 requires one; the guard supplies it. A line that is not
+   * JSON is answered on stdout with a parse error, code `-32700` and
+   * `id: null`, and never reaches core. So is a line longer than core's cap
+   * of 16 Mi UTF-16 code units: it is answered once, as soon as it passes
+   * the cap, and the rest of it is discarded up to its newline (core would
+   * log it on stderr and drop it). A line of JSON whitespace (space, tab,
+   * carriage return) is ignored.
    *
    * A line that is JSON but no JSON-RPC message core can handle is answered
    * with an Invalid Request, code `-32600` and `id: null`, and never reaches
-   * core: a value that is neither an object nor an array (core throws on
-   * `null`, dropping every other frame in its chunk, and ignores a number,
-   * string or boolean without a reply), an object whose `method` is not a
-   * string and whose `id` is absent or `null` (core throws on it too), and
-   * an object with neither `method` nor `id`, which is neither a request nor
-   * a response. Everything else goes to core: an array, which core answers
-   * `-32600` itself because it serves no batches; an object with an `id`
-   * and no `method`, which is a response and gets no reply; and a request
-   * with an `id`, which core answers even when its `method` is malformed.
+   * core: a value that is neither an object nor an array, an object whose
+   * `method` is not a string and whose `id` is absent or `null`, and an
+   * object with neither `method` nor `id`, which is neither a request nor a
+   * response.
+   *
+   * 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
+   * `id`, which core answers even when its `method` is malformed.
    *
    * Give each server a fresh layer memo map. Core's stdio protocol layer
    * is a shared constant, so a second `McpStdio.layer` server whose build
@@ -184,6 +192,11 @@ interface UnknownKeysLevel {
   readonly unknown: ReadonlyArray<string>;
   /** Keys this level declares, in schema order. */
   readonly accepted: ReadonlyArray<string>;
+  /**
+   * The `patternProperties` patterns this level also accepts keys by, in
+   * schema order. Present only when the level has at least one.
+   */
+  readonly acceptedPatterns?: ReadonlyArray<string>;
 }
 /**
  * Options for {@link ToolInputSchema.formatUnknownKeys}.
@@ -199,10 +212,12 @@ interface FormatUnknownKeysOptions {
  * depth, a message naming them all, and an object-rooted form of a union.
  *
  * @remarks
- * Core's `Tool.Strict` rejects unknown keys but reports only the first
- * (effect `unstable/ai/McpServer.ts` decodes without `errors: "all"`), so an
- * agent fixes one typo per round trip. These walkers run over the schema core
- * actually serves, so what they accept matches what the tool advertises:
+ * 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.
@@ -213,6 +228,9 @@ interface FormatUnknownKeysOptions {
  * - `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
@@ -226,9 +244,12 @@ export declare class ToolInputSchema {
   /** Every level of `payload` that carries a key `schema` does not accept. */
   static readonly unknownKeys: (payload: unknown, schema: JsonSchema.JsonSchema) => ReadonlyArray<UnknownKeysLevel>;
   /**
-   * `Unrecognized parameter(s): a, b.c. Accepted params: x, y.` per level. Each
-   * echoed key is truncated, and at most 20 keys and 20 levels are named; a
-   * trailing `(and N more levels).` counts the levels left out.
+   * `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 readonly formatUnknownKeys: (levels: ReadonlyArray<UnknownKeysLevel>, options?: FormatUnknownKeysOptions) => string;
   /**
@@ -253,16 +274,16 @@ interface McpToolkitOptions {
    * annotation is served and decoded strict. `"annotated"`: only tools
    * annotated `Tool.Strict` true are. In both modes an explicit annotation,
    * true or false, always wins, and a `Tool.dynamic` tool is never
-   * re-annotated (core dies at registration on a strict dynamic tool). Only
-   * a tool that ends up strict gets the unknown-key pre-check; a lenient
-   * one is passed through untouched even if its raw schema is closed.
+   * re-annotated (core dies at registration on a strict dynamic tool).
    */
   readonly strict?: "all" | "annotated" | undefined;
   /**
-   * Replaces the default `ToolInputSchema.formatUnknownKeys` rendering. It
-   * runs per rejected call inside the handler's effect, so a throw becomes
-   * a defect of that call alone — the client receives a JSON-RPC internal
-   * error (-32603) — never a crash of the server.
+   * Ignored. Core's strict decode reports every excess key at every depth,
+   * together with every missing or invalid field, in one `InvalidParams`,
+   * and the layer appends a fixed `Accepted params at <path>: …` line per
+   * level that carries an unknown key; this option changes neither.
+   *
+   * @deprecated A no-op, scheduled for removal in a later minor.
    */
   readonly unknownKeyMessage?: ((levels: ReadonlyArray<UnknownKeysLevel>) => string) | undefined;
 }
@@ -315,39 +336,45 @@ interface UnionToolOptions<P extends Schema.Decoder<unknown>, S extends Schema.C
  */
 interface UnionHandlerOptions {
   /**
-   * Replaces the default `ToolInputSchema.formatUnknownKeys` rendering, as
-   * {@link McpToolkitOptions.unknownKeyMessage} does for the layer. Pass the
-   * same function to both for one report on every path.
+   * Ignored. The union decode reports every excess, missing and invalid
+   * field in one `InvalidParams`, followed by the same fixed
+   * `Accepted params at <path>: …` lines {@link McpToolkit.layer} appends;
+   * this option changes neither.
+   *
+   * @deprecated A no-op, scheduled for removal in a later minor.
    */
   readonly unknownKeyMessage?: ((levels: ReadonlyArray<UnknownKeysLevel>) => string) | undefined;
 }
 /**
- * Register a toolkit exactly as core's `McpServer.toolkit` does, except that a
- * strict tool's unknown arguments are all named, at every depth, in one
- * response.
+ * 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 itself is core's: a tool annotated `Tool.Strict` is served with
- * `additionalProperties: false` on every object node and decoded with
- * `onExcessProperty: "error"`. But core reports only the FIRST excess key
- * (`Expected no excess property at ["extra"]`), so an agent fixes one typo
- * per round trip and never learns about a nested one until the next call.
- * This layer is the better report, not the rejecter: it runs core's
+ * 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 a `ToolInputSchema.unknownKeys` pre-check in front of each
- * handler. The pre-check walks the input schema the tool actually serves
- * (after core's own top-level `$ref` inlining), follows `$ref`, `allOf` and
- * discriminated `oneOf`/`anyOf` members, and fails with one
- * `McpSchema.InvalidParams` naming every unknown key path plus the accepted
- * params, before core decodes. Core's strict decode stays behind it as the
- * backstop. The pre-check is gated on the same predicate core uses to choose
- * strict decoding — the registered tool's `Tool.Strict` annotation is
- * `true` — so a lenient tool (explicit `Tool.Strict` false, a
- * `Tool.dynamic` tool, or any unannotated tool under `"annotated"`) is
- * never rejected here, even when its raw JSON Schema carries
- * `additionalProperties: false`. The pre-check runs under `Effect.suspend`,
- * so a throwing `unknownKeyMessage` dies inside the call's effect. No core
- * internals are patched, so this survives an rc bump without re-diffing.
+ * `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
@@ -386,9 +413,11 @@ export declare class McpToolkit {
    * {@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: every unknown key named in one
-   * `InvalidParams`, then a strict decode, both before the handler runs, so
-   * bad arguments answer JSON-RPC `-32602` on `2025-06-18` and an `isError`
+   * 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
@@ -399,6 +428,11 @@ export declare class McpToolkit {
    *
    * @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])),
@@ -409,26 +443,27 @@ export declare class McpToolkit {
    */
   static readonly unionTool: <const Name extends string, P extends Schema.Decoder<unknown>, S extends Schema.Constraint = typeof Schema.Void, F extends Schema.Constraint = typeof Schema.Never, const Dependencies extends ReadonlyArray<Context.Key<unknown, unknown>> = []>(name: Name, options: UnionToolOptions<P, S, F, Dependencies>) => UnionTool<Name, P, S, F, Context.Service.Identifier<Dependencies[number]>>;
   /**
-   * The handler for a {@link McpToolkit.unionTool}: checks and decodes the
-   * raw payload exactly as {@link McpToolkit.layer} does, and passes the
-   * decoded member to `handler`.
+   * 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 carrying unknown keys fails with one `McpSchema.InvalidParams`
-   * naming every one of them, at every depth, in the
-   * `ToolInputSchema.formatUnknownKeys` report (or `options.unknownKeyMessage`'s),
-   * walked over the tool's served input schema. A payload that then does
-   * not decode fails `InvalidParams` worded as core words a `Tool.make`
-   * decode failure. 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, and its own `unknownKeyMessage` wins.
+   * 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 readonly unionHandler: <Name extends string, P extends Schema.Decoder<unknown>, S extends Schema.Constraint, F extends Schema.Constraint, R, A, E, RH>(tool: UnionTool<Name, P, S, F, R>, handler: (params: P["Type"]) => Effect.Effect<A, E, RH>, options?: UnionHandlerOptions) => ((payload: unknown) => Effect.Effect<A, E | McpSchema.InvalidParams, RH>);
+  static readonly unionHandler: <Name extends string, P extends Schema.Decoder<unknown>, S extends Schema.Constraint, F extends Schema.Constraint, R, A, E, RH>(tool: UnionTool<Name, P, S, F, R>, handler: (params: P["Type"]) => Effect.Effect<A, E, RH>, _options?: UnionHandlerOptions) => ((payload: unknown) => Effect.Effect<A, E | McpSchema.InvalidParams, RH>);
   /**
-   * `McpServer.toolkit`'s registration layer, strict by default and naming
-   * every unknown argument in one `InvalidParams`.
+   * `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>>;
 }
@@ -440,7 +475,7 @@ export declare class McpToolkit {
  * @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 `unstable/ai/McpServer.ts`,
+ * 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.
@@ -457,6 +492,9 @@ export declare class McpToolkit {
  *
  * @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) })
@@ -563,11 +601,14 @@ declare const ToolRefusal_base: Schema.Class<ToolRefusal, Schema.TaggedStruct<"T
  * {@link ToolRefusal.refuse}; its message already carries the remediation,
  * because a declared `Error` failure sends `message` and nothing else.
  *
- * Audit every throw path when porting a tool: any failure left undeclared
- * loses its message on the wire, however carefully it was worded.
+ * Audit every throw path of a tool: any failure left undeclared loses its
+ * message on the wire, however carefully it was worded.
  *
  * @example
  * ```ts
+ * import { ToolFailure, ToolRefusal } from "@effected/mcp";
+ * import { Tool } from "effect/ai";
+ *
  * const Lookup = Tool.make("lookup", { parameters, success, failure: ToolRefusal })
  * // in the handler:
  * return yield* ToolRefusal.refuse(`No run "${ToolFailure.truncate(id)}".`, { hint: "List runs first.", suggestedTool: "list_runs" })

package/internal/LaunchFailed.js

@@ -7,15 +7,27 @@ import { Runtime } from "effect";
 * second time — through a logger that writes to stdout — and the original exit
 * code rides along for the teardown.
 *
+* @remarks
+* Both runtime markers are prototype getters rather than own fields, so a JSON
+* or logger dump of the error does not carry them; the code lives in a private
+* field.
+*
 * @internal
 */
 var LaunchFailed = class extends Error {
-	[Runtime.errorReported] = false;
-	[Runtime.errorExitCode];
+	#code;
 	constructor(code) {
 		super(`the MCP server failed to launch (exit ${code})`);
 		this.name = "LaunchFailed";
-		this[Runtime.errorExitCode] = code;
+		this.#code = code;
+	}
+	/** Already reported on stderr: `runMain` must not report it again. */
+	get [Runtime.errorReported]() {
+		return false;
+	}
+	/** The exit code the launch failed with. */
+	get [Runtime.errorExitCode]() {
+		return this.#code;
 	}
 };
 

package/internal/StdinFrames.js

@@ -1,5 +1,5 @@
 import { Effect, Layer, Stdio, Stream } from "effect";
-import { McpSchema } from "effect/unstable/ai";
+import { McpSchema } from "effect/ai";
 
 //#region src/internal/StdinFrames.ts
 /**
@@ -40,27 +40,59 @@ 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, or `undefined` to
-* forward it to core.
+* The guard's answer to one non-blank line within the cap, `DROP` to swallow
+* it silently, or `undefined` to forward it to core.
 *
 * @remarks
-* A frame that parses is forwarded unless core would throw on it or ignore
-* it without a reply, which JSON-RPC 2.0 calls an Invalid Request:
-*
-* - a value that is neither an object nor an array: core throws on `null`,
-*   dropping every other frame in its chunk, and ignores a number, string or
-*   boolean without a reply;
-* - an object with a `method` that is not a string and no usable `id`: core
-*   throws on it, dropping the rest of its chunk (with an `id`, core answers
-*   `-32601` itself);
+* A frame that parses is forwarded unless core would skip it without a
+* reply, where JSON-RPC 2.0 requires an Invalid Request:
+*
+* - a value that is neither an object nor an array;
+* - an object with a `method` that is not a string and no usable `id` (with
+*   an `id`, core answers `-32601` itself);
 * - an object with neither `method` nor `id`: every JSON-RPC request carries a
 *   `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.
+*
 * 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
 * response.
@@ -75,7 +107,10 @@ 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")) return typeof message.method !== "string" && isNullish(message.id) ? INVALID_REQUEST_FRAME : void 0;
+	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;
+	}
 	return Object.hasOwn(message, "id") ? void 0 : INVALID_REQUEST_FRAME;
 };
 /**
@@ -83,15 +118,15 @@ const answerFor = (line) => {
 * decoder will parse and answer, each with its newline.
 *
 * @remarks
-* Core's stdio decoder parses each line inside its read loop. A line that is
-* not JSON throws before the decoder advances past it, so the line stays at
-* the head of its buffer and every later chunk throws on it again: the server
-* never reads another frame. A line that is JSON but no JSON-RPC message core
-* can handle either throws inside the decoder, dropping the frames after it in
-* the same chunk, or is ignored without a reply. The guard frames stdin
+* Core's stdio decoder skips a line it cannot use and keeps serving
+* (Effect-TS/effect PR #8541): a line that is not JSON, a JSON value that is
+* not an object, or an object that is no JSON-RPC message is dropped without
+* a reply, and a line past its buffer cap is logged on stderr and dropped.
+* 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.
+* to write. It also keeps `@effect/rpc/` control methods away from core (see
+* `answerFor`), which would otherwise let one client line stop the server.
 *
 * - 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
@@ -101,7 +136,10 @@ const answerFor = (line) => {
 * - A line of JSON whitespace only is not a frame: dropped, not answered.
 * - 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`; everything else goes to core.
+*   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
 *   its newline. Nothing is held beyond the cap.
@@ -143,7 +181,7 @@ const makeFrameGuard = (maxFrameLength = MAX_FRAME_LENGTH) => {
 			if (BLANK.test(line)) continue;
 			const answer = answerFor(line);
 			if (answer === void 0) forward += `${line}\n`;
-			else replies.push(answer);
+			else if (answer !== DROP) replies.push(answer);
 		}
 		pending += text.slice(start);
 		if (pending.length > maxFrameLength) {
@@ -198,4 +236,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, guardStdin, makeFrameGuard, makeGuardedStdio };
+export { INVALID_REQUEST_FRAME, MAX_FRAME_LENGTH, PARSE_ERROR_FRAME, RPC_CONTROL_PREFIX, guardStdin, makeFrameGuard, makeGuardedStdio, methodNotFoundFrame };

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@effected/mcp",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"private": false,
-	"description": "The boundary layer of an effect/unstable/ai MCP server: stdio wiring that keeps stdout the wire, tool-failure shaping, strict-input walkers, and test clients",
+	"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": [
 		"effect",
 		"mcp",
@@ -47,8 +47,8 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/engine": "^0.1.0",
-		"effect": "4.0.0-rc.117"
+		"@effected/engine": "^0.3.0",
+		"effect": "^4.0.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"