// @effect-diagnostics nodeBuiltinImport:off globalTimers:off
import * as NodeStream from "node:stream";
import { describe, expect, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import { vi } from "vite-plus/test";
import { mcpToolSession, runAcpMcpCliFastPath, runAcpMcpStdioBridge } from "./AcpMcpStdioBridge.ts";
function makeHarness(
responder: (request: Request) => Promise<Response> | Response,
input = new NodeStream.PassThrough(),
) {
const written: Array<string> = [];
const requests: Array<{ readonly headers: Headers; readonly body: string }> = [];
const bridge = runAcpMcpStdioBridge({
endpoint: "http://127.0.0.1:1/mcp",
authorization: "Bearer bridge-test",
input,
output: {
write: (chunk: string) => {
written.push(chunk);
},
},
fetchImplementation: async (_url, init) => {
const request = new Request("http://127.0.0.1:1/mcp", init);
requests.push({ headers: request.headers, body: String(init?.body ?? "") });
return responder(request);
},
});
return { input, written, requests, bridge };
}
function pendingFetch(started: Deferred.Deferred<AbortSignal | undefined>) {
return (_url: string, init?: RequestInit): Promise<Response> => {
Deferred.doneUnsafe(started, Effect.succeed(init?.signal ?? undefined));
return new Promise(() => {});
};
}
describe("AcpMcpStdioBridge", () => {
it("prints structured results once in the terminal while retaining other content and errors", async () => {
const originalEnvironment = process.env;
using _environment = {
[Symbol.dispose]: () => {
process.env = originalEnvironment;
},
};
process.env = {
...originalEnvironment,
T3_ACP_MCP_ENDPOINT: "http://127.0.0.1:1/mcp",
T3_ACP_MCP_AUTHORIZATION: "Bearer bridge-test",
};
const structuredContent = { taskId: "task-1", status: "failed" };
const explanation = { type: "text", text: "The command failed." };
const image = { type: "image", data: "image-data", mimeType: "image/png" };
const result = {
structuredContent,
content: [{ type: "text", text: JSON.stringify(structuredContent) }, explanation, image],
isError: true,
};
using fetch = vi.spyOn(globalThis, "fetch").mockImplementation(async (_url, init) => {
if (init?.method === "DELETE") return new Response(null, { status: 204 });
const message = JSON.parse(String(init?.body)) as { id?: string; method: string };
if (message.method === "notifications/initialized") {
return new Response(null, { status: 202 });
}
return Response.json(
{
jsonrpc: "2.0",
id: message.id,
result: message.method === "initialize" ? { protocolVersion: "2025-06-18" } : result,
},
{ headers: { "mcp-session-id": "session-42" } },
);
});
using output = vi.spyOn(process.stdout, "write").mockReturnValue(true);
await runAcpMcpCliFastPath("acp-mcp-call", ["task_status", '{"taskId":"task-1"}']);
expect(output).toHaveBeenCalledExactlyOnceWith(
`${JSON.stringify({ ...result, content: [explanation, image] })}\n`,
);
expect(fetch).toHaveBeenLastCalledWith(
"http://127.0.0.1:1/mcp",
expect.objectContaining({ method: "DELETE" }),
);
});
it.effect("forwards requests and replays the session id and protocol version", () =>
Effect.gen(function* () {
const { input, written, requests, bridge } = makeHarness((request) => {
const body = JSON.parse(String(requests.at(-1)?.body ?? "{}")) as { id?: number };
void request;
return new Response(
JSON.stringify({
jsonrpc: "2.0",
id: body.id ?? null,
result: body.id === 1 ? { protocolVersion: "2025-06-18" } : { ok: true },
}),
{
status: 200,
headers: { "content-type": "application/json", "mcp-session-id": "session-42" },
},
);
});
const fiber = yield* Effect.forkChild(bridge);
input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize" })}\n`);
input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list" })}\n`);
input.end();
yield* Fiber.join(fiber);
expect(written).toHaveLength(2);
expect(JSON.parse(written[0]!)).toMatchObject({ id: 1 });
expect(JSON.parse(written[1]!)).toMatchObject({ id: 2, result: { ok: true } });
expect(requests[0]?.headers.get("authorization")).toBe("Bearer bridge-test");
expect(requests[1]?.headers.get("mcp-session-id")).toBe("session-42");
expect(requests[1]?.headers.get("mcp-protocol-version")).toBe("2025-06-18");
}),
);
it.effect("acknowledges notifications silently and synthesizes errors for failed requests", () =>
Effect.gen(function* () {
let call = 0;
const { input, written, bridge } = makeHarness(() => {
call += 1;
return call === 1
? new Response(null, { status: 202 })
: new Response("upstream broke", { status: 500 });
});
const fiber = yield* Effect.forkChild(bridge);
input.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}\n`);
input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 3, method: "tools/list" })}\n`);
input.end();
yield* Fiber.join(fiber);
expect(written).toHaveLength(1);
expect(JSON.parse(written[0]!)).toMatchObject({
id: 3,
error: { code: -32603 },
});
}),
);
it.effect("emits parse errors for malformed JSON-RPC input", () =>
Effect.gen(function* () {
const { input, written, requests, bridge } = makeHarness(
() => new Response(null, { status: 202 }),
);
const fiber = yield* Effect.forkChild(bridge);
input.end("{not-json}\n");
yield* Fiber.join(fiber);
expect(requests).toHaveLength(0);
expect(JSON.parse(written[0]!)).toEqual({
jsonrpc: "2.0",
id: null,
error: { code: -32700, message: "Parse error" },
});
}),
);
it.effect("keeps U+2028 and U+2029 inside a message instead of splitting it", () =>
Effect.gen(function* () {
const { input, written, requests, bridge } = makeHarness(
() => Response.json({ jsonrpc: "2.0", id: 4, result: { ok: true } }),
// Object mode keeps the two writes as separate chunks instead of one buffered read.
new NodeStream.PassThrough({ objectMode: true }),
);
const fiber = yield* Effect.forkChild(bridge);
// JSON.stringify leaves both separators unescaped, as MCP stdio clients send them.
const message = JSON.stringify({
jsonrpc: "2.0",
id: 4,
method: "tools/call",
params: { name: "echo", arguments: { text: "a\u2028b\u2029c\u{1f30d}" } },
});
// Split inside the emoji's UTF-8 bytes and leave the last line unterminated, as stdin may.
const bytes = Buffer.from(message);
const split = bytes.indexOf(Buffer.from("\u{1f30d}")) + 2;
input.write(bytes.subarray(0, split));
input.end(bytes.subarray(split));
yield* Fiber.join(fiber);
expect(requests.map((request) => request.body)).toEqual([message]);
expect(written.map((chunk) => JSON.parse(chunk))).toEqual([
{ jsonrpc: "2.0", id: 4, result: { ok: true } },
]);
}),
);
it.effect("forwards SSE messages before the HTTP response closes", () =>
Effect.gen(function* () {
let resolveResponseController!: (
controller: ReadableStreamDefaultController<Uint8Array>,
) => void;
const responseControllerReady = new Promise<ReadableStreamDefaultController<Uint8Array>>(
(resolve) => {
resolveResponseController = resolve;
},
);
let firstWrite: (() => void) | undefined;
const firstWritten = new Promise<void>((resolve) => {
firstWrite = resolve;
});
const input = new NodeStream.PassThrough();
const written: Array<string> = [];
const fiber = yield* Effect.forkChild(
runAcpMcpStdioBridge({
endpoint: "http://127.0.0.1:1/mcp",
authorization: "Bearer bridge-test",
input,
output: {
write: (chunk) => {
written.push(chunk);
firstWrite?.();
},
},
fetchImplementation: async () =>
new Response(
new ReadableStream<Uint8Array>({
start: (controller) => {
resolveResponseController(controller);
},
}),
{ headers: { "content-type": "text/event-stream" } },
),
}),
);
input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 7, method: "tools/call" })}\n`);
const responseController = yield* Effect.promise(() => responseControllerReady);
responseController.enqueue(
new TextEncoder().encode(
'data: {"jsonrpc":"2.0","method":"notifications/progress","params":{}}\n\n',
),
);
yield* Effect.promise(() => firstWritten);
expect(JSON.parse(written[0]!)).toMatchObject({ method: "notifications/progress" });
responseController.enqueue(
new TextEncoder().encode('data: {"jsonrpc":"2.0","id":7,"result":{}}\n\n'),
);
responseController.close();
input.end();
yield* Fiber.join(fiber);
expect(written).toHaveLength(2);
}),
);
it.effect("forwards client responses while an SSE request is still open", () =>
Effect.gen(function* () {
let responseController: ReadableStreamDefaultController<Uint8Array> | undefined;
let serverRequestWritten: (() => void) | undefined;
const serverRequestReachedClient = new Promise<void>((resolve) => {
serverRequestWritten = resolve;
});
const input = new NodeStream.PassThrough();
const written: Array<string> = [];
const fiber = yield* Effect.forkChild(
runAcpMcpStdioBridge({
endpoint: "http://127.0.0.1:1/mcp",
authorization: "Bearer bridge-test",
input,
output: {
write: (chunk) => {
written.push(chunk);
if (JSON.parse(chunk).id === "server-request-1") serverRequestWritten?.();
},
},
fetchImplementation: async (_url, init) => {
const body = JSON.parse(String(init?.body ?? "{}")) as {
readonly id?: unknown;
readonly method?: unknown;
readonly result?: unknown;
};
if (body.method === "tools/call") {
return new Response(
new ReadableStream<Uint8Array>({
start: (controller) => {
responseController = controller;
controller.enqueue(
new TextEncoder().encode(
'data: {"jsonrpc":"2.0","id":"server-request-1","method":"elicitation/create","params":{}}\n\n',
),
);
},
}),
{ headers: { "content-type": "text/event-stream" } },
);
}
expect(body).toMatchObject({ id: "server-request-1", result: { action: "accept" } });
responseController?.enqueue(
new TextEncoder().encode('data: {"jsonrpc":"2.0","id":7,"result":{}}\n\n'),
);
responseController?.close();
return new Response(null, { status: 202 });
},
}),
);
input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 7, method: "tools/call" })}\n`);
yield* Effect.promise(() => serverRequestReachedClient);
input.write(
`${JSON.stringify({ jsonrpc: "2.0", id: "server-request-1", result: { action: "accept" } })}\n`,
);
input.end();
yield* Fiber.join(fiber);
expect(written.map((line) => JSON.parse(line).id)).toEqual(["server-request-1", 7]);
}),
);
it.effect("forwards cancellation while a tool SSE response is still open", () =>
Effect.gen(function* () {
let resolveResponseController!: (
controller: ReadableStreamDefaultController<Uint8Array>,
) => void;
const responseControllerReady = new Promise<ReadableStreamDefaultController<Uint8Array>>(
(resolve) => {
resolveResponseController = resolve;
},
);
const methods: Array<string> = [];
const input = new NodeStream.PassThrough();
const written: Array<string> = [];
const fiber = yield* Effect.forkChild(
runAcpMcpStdioBridge({
endpoint: "http://127.0.0.1:1/mcp",
authorization: "Bearer bridge-test",
input,
output: { write: (chunk) => written.push(chunk) },
fetchImplementation: async (_url, init) => {
const body = JSON.parse(String(init?.body ?? "{}")) as {
readonly method?: string;
};
methods.push(body.method ?? "");
if (body.method === "tools/call") {
return new Response(
new ReadableStream<Uint8Array>({
start: resolveResponseController,
}),
{ headers: { "content-type": "text/event-stream" } },
);
}
const controller = await responseControllerReady;
controller.enqueue(
new TextEncoder().encode('data: {"jsonrpc":"2.0","id":7,"result":{}}\n\n'),
);
controller.close();
return new Response(null, { status: 202 });
},
}),
);
input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 7, method: "tools/call" })}\n`);
yield* Effect.promise(() => responseControllerReady);
input.write(
`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/cancelled", params: { requestId: 7 } })}\n`,
);
input.end();
yield* Fiber.join(fiber);
expect(methods).toEqual(["tools/call", "notifications/cancelled"]);
expect(JSON.parse(written[0]!)).toMatchObject({ id: 7, result: {} });
}),
);
it.effect("aborts the pending fetch when a tool call is interrupted", () =>
Effect.gen(function* () {
const started = yield* Deferred.make<AbortSignal | undefined>();
const fiber = yield* mcpToolSession({
endpoint: "http://127.0.0.1:1/mcp",
authorization: "Bearer bridge-test",
clientName: "t3-code-acp-cli",
fetchImplementation: pendingFetch(started),
}).pipe(
Effect.flatMap((session) => session.call("orchestrator_capabilities", {})),
Effect.scoped,
Effect.forkChild,
);
const signal = yield* Deferred.await(started);
yield* Fiber.interrupt(fiber);
expect(signal?.aborted).toBe(true);
}),
);
it.effect("aborts the pending fetch when the stdio bridge is interrupted", () =>
Effect.gen(function* () {
const started = yield* Deferred.make<AbortSignal | undefined>();
const input = new NodeStream.PassThrough();
const fiber = yield* runAcpMcpStdioBridge({
endpoint: "http://127.0.0.1:1/mcp",
authorization: "Bearer bridge-test",
input,
output: { write: () => undefined },
fetchImplementation: pendingFetch(started),
}).pipe(Effect.forkChild);
input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" })}\n`);
const signal = yield* Deferred.await(started);
yield* Fiber.interrupt(fiber);
expect(signal?.aborted).toBe(true);
}),
);
});