Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as AcpError from "./errors.ts";
import * as Effect from "effect/Effect";
import * as Deferred from "effect/Deferred";
import * as Fiber from "effect/Fiber";
import * as Queue from "effect/Queue";
import { it, assert } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as AcpProtocol from "./protocol.ts";
import { encodeJsonl } from "./_internal/shared.ts";
import {
makeInMemoryStdio,
terminationErrorFromHandle,
makeChildStdio,
} from "./_internal/stdio.ts";
import {
RequestPermissionRequest,
ExtRequest,
ExtResponse,
decodeExtRequest,
decodeExtResponse,
decodeRequestPermissionResponse,
makeHandle,
} from "./protocol.test-support.ts";
it.layer(NodeServices.layer)("effect-acp protocol", (it) => {
it.effect("supports generic extension requests over the patched transport", () =>
Effect.gen(function* () {
const { stdio, input, output } = yield* makeInMemoryStdio();
const transport = yield* AcpProtocol.makeAcpPatchedProtocol({
stdio,
serverRequestMethods: new Set(),
});
const response = yield* transport
.request("x/test", { hello: "world" })
.pipe(Effect.forkScoped);
const outbound = yield* Queue.take(output);
assert.deepEqual(yield* decodeExtRequest(outbound), {
jsonrpc: "2.0",
id: 1,
method: "x/test",
params: {
hello: "world",
},
headers: [],
});
yield* Queue.offer(
input,
yield* encodeJsonl(ExtResponse, {
jsonrpc: "2.0",
id: 1,
result: {
ok: true,
},
}),
);
const resolved = yield* Fiber.join(response);
assert.deepEqual(resolved, { ok: true });
}),
);
it.effect("preserves numeric ids for inbound extension requests", () =>
Effect.gen(function* () {
const { stdio, input, output } = yield* makeInMemoryStdio();
yield* AcpProtocol.makeAcpPatchedProtocol({
stdio,
serverRequestMethods: new Set(),
onExtRequest: () => Effect.succeed({ ok: true }),
});
yield* Queue.offer(
input,
yield* encodeJsonl(ExtRequest, {
jsonrpc: "2.0",
id: 7,
method: "x/test",
params: {
hello: "world",
},
headers: [],
}),
);
const outbound = yield* Queue.take(output);
assert.deepEqual(yield* decodeExtResponse(outbound), {
jsonrpc: "2.0",
id: 7,
result: {
ok: true,
},
});
}),
);
it.effect("preserves zero-valued ids for inbound core client requests", () =>
Effect.gen(function* () {
const { stdio, input, output } = yield* makeInMemoryStdio();
const transport = yield* AcpProtocol.makeAcpPatchedProtocol({
stdio,
serverRequestMethods: new Set(["session/request_permission"]),
});
const inboundRequest = yield* Deferred.make<unknown>();
yield* transport.serverProtocol
.run((_clientId, message) => Deferred.succeed(inboundRequest, message).pipe(Effect.asVoid))
.pipe(Effect.forkScoped);
yield* Queue.offer(
input,
yield* encodeJsonl(RequestPermissionRequest, {
jsonrpc: "2.0",
id: 0,
method: "session/request_permission",
params: {
sessionId: "session-1",
toolCall: {
toolCallId: "tool-1",
title: "Allow mock action",
},
options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }],
},
headers: [],
}),
);
const message = yield* Deferred.await(inboundRequest);
assert.deepEqual(message, {
_tag: "Request",
id: 0,
tag: "session/request_permission",
payload: {
sessionId: "session-1",
toolCall: {
toolCallId: "tool-1",
title: "Allow mock action",
},
options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }],
},
headers: [],
});
yield* transport.serverProtocol.send(0, {
_tag: "Exit",
requestId: 0,
exit: {
_tag: "Success",
value: {
outcome: {
outcome: "selected",
optionId: "allow",
},
},
},
});
const outbound = yield* Queue.take(output);
assert.deepEqual(yield* decodeRequestPermissionResponse(outbound), {
jsonrpc: "2.0",
id: 0,
result: {
outcome: {
outcome: "selected",
optionId: "allow",
},
},
});
}),
);
it.effect("cleans up interrupted extension requests before a late response arrives", () =>
Effect.gen(function* () {
const { stdio, input, output } = yield* makeInMemoryStdio();
const transport = yield* AcpProtocol.makeAcpPatchedProtocol({
stdio,
serverRequestMethods: new Set(),
});
const lateResponse = yield* Deferred.make<unknown>();
yield* transport.clientProtocol
.run(0, (message) => Deferred.succeed(lateResponse, message).pipe(Effect.asVoid))
.pipe(Effect.forkScoped);
const response = yield* transport
.request("x/test", { hello: "world" })
.pipe(Effect.forkScoped);
const outbound = yield* Queue.take(output);
assert.deepEqual(yield* decodeExtRequest(outbound), {
jsonrpc: "2.0",
id: 1,
method: "x/test",
params: {
hello: "world",
},
headers: [],
});
yield* Fiber.interrupt(response);
yield* Queue.offer(
input,
yield* encodeJsonl(ExtResponse, {
jsonrpc: "2.0",
id: 1,
result: {
ok: true,
},
}),
);
const message = yield* Deferred.await(lateResponse);
assert.deepEqual(message, {
_tag: "Exit",
requestId: 1,
exit: {
_tag: "Success",
value: {
ok: true,
},
},
});
}),
);
it.effect("propagates the real child exit code when the input stream ends", () =>
Effect.gen(function* () {
const handle = yield* makeHandle({ ACP_MOCK_EXIT_IMMEDIATELY_CODE: "7" });
const firstMessage = yield* Deferred.make<unknown>();
const termination = yield* Deferred.make<AcpError.AcpError>();
const transport = yield* AcpProtocol.makeAcpPatchedProtocol({
stdio: makeChildStdio(handle),
terminationError: terminationErrorFromHandle(handle),
serverRequestMethods: new Set(),
onTermination: (error) => Deferred.succeed(termination, error).pipe(Effect.asVoid),
});
yield* transport.clientProtocol
.run(0, (message) => Deferred.succeed(firstMessage, message).pipe(Effect.asVoid))
.pipe(Effect.forkScoped);
const message = yield* Deferred.await(firstMessage);
const exitError = yield* Deferred.await(termination);
assert.instanceOf(exitError, AcpError.AcpProcessExitedError);
assert.equal((exitError as AcpError.AcpProcessExitedError).code, 7);
assert.equal((message as { readonly _tag?: string })._tag, "ClientProtocolError");
const defect = (message as { readonly error: { readonly reason: unknown } }).error.reason as {
readonly _tag: string;
readonly message: string;
readonly cause: unknown;
};
assert.equal(defect._tag, "RpcClientDefect");
assert.equal(defect.message, "ACP protocol terminated.");
assert.instanceOf(defect.cause, AcpError.AcpProcessExitedError);
assert.equal((defect.cause as AcpError.AcpProcessExitedError).code, 7);
}),
);
it.effect("classifies an input stream ending without inventing a cause", () =>
Effect.gen(function* () {
const { stdio, input } = yield* makeInMemoryStdio();
const termination = yield* Deferred.make<AcpError.AcpError>();
yield* AcpProtocol.makeAcpPatchedProtocol({
stdio,
serverRequestMethods: new Set(),
onTermination: (error) => Deferred.succeed(termination, error).pipe(Effect.asVoid),
});
yield* Queue.end(input);
const error = yield* Deferred.await(termination);
assert.instanceOf(error, AcpError.AcpInputStreamEndedError);
assert.equal(error.message, "ACP input stream ended.");
assert.equal("cause" in error, false);
}),
);
it.effect("keeps client send failure messages independent from the cause", () =>
Effect.gen(function* () {
const { stdio } = yield* makeInMemoryStdio();
const transport = yield* AcpProtocol.makeAcpPatchedProtocol({
stdio,
serverRequestMethods: new Set(),
});
const failure = yield* transport.clientProtocol
.send(0, {
_tag: "Request",
id: "request-1",
tag: "x/test",
payload: 1n,
headers: [],
})
.pipe(Effect.flip);
const defect = failure.reason as {
readonly _tag: string;
readonly message: string;
readonly cause: unknown;
};
assert.equal(defect._tag, "RpcClientDefect");
assert.equal(defect.message, "Failed to send ACP protocol message.");
assert.instanceOf(defect.cause, AcpError.AcpProtocolParseError);
}),
);
it.effect("fails pending extension requests with the propagated exit code", () =>
Effect.gen(function* () {
const { stdio, input, output } = yield* makeInMemoryStdio();
const transport = yield* AcpProtocol.makeAcpPatchedProtocol({
stdio,
terminationError: Effect.succeed(new AcpError.AcpProcessExitedError({ code: 0 })),
serverRequestMethods: new Set(),
});
const response = yield* transport
.request("x/test", { hello: "world" })
.pipe(Effect.forkScoped);
yield* Queue.take(output);
yield* Queue.end(input);
const error = yield* Fiber.join(response).pipe(
Effect.match({
onFailure: (error) => error,
onSuccess: () => assert.fail("Expected request to fail after process exit"),
}),
);
assert.instanceOf(error, AcpError.AcpProcessExitedError);
assert.equal(error.code, 0);
}),
);
});