@effected/mcp 0.10.0 → 0.11.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

@@ -94,14 +94,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

package/index.d.ts

@@ -125,14 +125,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

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.11.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,7 +52,7 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/engine": "^0.9.0",
+		"@effected/engine": "^0.10.0",
 		"effect": "^4.0.0"
 	},
 	"engines": {

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: