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 Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Queue from "effect/Queue";
import * as Stream from "effect/Stream";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import * as CodexError from "./errors.ts";
import * as CodexProtocol from "./protocol.ts";
import * as CodexRpc from "./rpc.ts";
import * as CodexSchema from "./schema.ts";
import { makeInMemoryStdio } from "./_internal/stdio.ts";
import {
encodeJsonl,
decodeJson,
decodeConsumeRateLimitResetCreditParams,
decodeConsumeRateLimitResetCreditResponse,
} from "./protocol.test-support.ts";
it.layer(NodeServices.layer)("effect-codex-app-server protocol", (it) => {
it.effect("maps the earned rate-limit reset consume request and response", () =>
Effect.gen(function* () {
assert.equal(
CodexRpc.CLIENT_REQUEST_METHODS["account/rateLimitResetCredit/consume"],
"account/rateLimitResetCredit/consume",
);
assert.strictEqual(
CodexRpc.CLIENT_REQUEST_PARAMS["account/rateLimitResetCredit/consume"],
CodexSchema.V2ConsumeAccountRateLimitResetCreditParams,
);
assert.strictEqual(
CodexRpc.CLIENT_REQUEST_RESPONSES["account/rateLimitResetCredit/consume"],
CodexSchema.V2ConsumeAccountRateLimitResetCreditResponse,
);
assert.deepEqual(
yield* decodeConsumeRateLimitResetCreditParams({
idempotencyKey: "8ae96ff3-3425-4f4c-8772-b6fd61502868",
creditId: "RateLimitResetCredit_1",
}),
{
idempotencyKey: "8ae96ff3-3425-4f4c-8772-b6fd61502868",
creditId: "RateLimitResetCredit_1",
},
);
assert.deepEqual(yield* decodeConsumeRateLimitResetCreditResponse({ outcome: "reset" }), {
outcome: "reset",
});
}),
);
it.effect(
"encodes requests without a jsonrpc field and routes inbound requests and notifications",
() =>
Effect.gen(function* () {
const { stdio, input, output } = yield* makeInMemoryStdio();
const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({
stdio,
rawNotificationBufferSize: "unbounded",
rawRequestBufferSize: "unbounded",
});
const notificationDeferred =
yield* Deferred.make<ReadonlyArray<CodexProtocol.CodexAppServerIncomingNotification>>();
const requestDeferred =
yield* Deferred.make<ReadonlyArray<CodexProtocol.CodexAppServerIncomingRequest>>();
yield* transport.incomingNotifications.pipe(
Stream.take(1),
Stream.runCollect,
Effect.flatMap((notifications) => Deferred.succeed(notificationDeferred, notifications)),
Effect.forkScoped,
);
yield* transport.incomingRequests.pipe(
Stream.take(1),
Stream.runCollect,
Effect.flatMap((requests) => Deferred.succeed(requestDeferred, requests)),
Effect.forkScoped,
);
yield* transport.notify("initialized");
assert.equal(yield* Queue.take(output), '{"method":"initialized"}\n');
const initializeParams = {
clientInfo: {
name: "effect-codex-app-server-test",
title: "Effect Codex App Server Test",
version: "0.0.0",
},
capabilities: {
experimentalApi: true,
optOutNotificationMethods: null,
},
};
const pendingInitialize = yield* transport
.request("initialize", initializeParams)
.pipe(Effect.forkScoped);
assert.deepEqual(yield* decodeJson(yield* Queue.take(output)), {
id: 1,
method: "initialize",
params: initializeParams,
});
yield* Queue.offer(
input,
encodeJsonl({
method: "item/agentMessage/delta",
params: {
delta: "Hello from the mock peer.",
itemId: "item-1",
threadId: "thread-1",
turnId: "turn-1",
},
}),
);
yield* Queue.offer(
input,
encodeJsonl({
id: 77,
method: "item/tool/requestUserInput",
params: {
itemId: "item-approval-1",
threadId: "thread-1",
turnId: "turn-1",
questions: [
{
id: "approved",
header: "Approve",
question: "Continue?",
},
],
},
}),
);
yield* Queue.offer(
input,
encodeJsonl({
id: 1,
result: {
userAgent: "mock-codex-app-server",
codexHome: "/tmp/codex-home",
platformFamily: "unix",
platformOs: "macos",
},
}),
);
assert.deepEqual(yield* Fiber.join(pendingInitialize), {
userAgent: "mock-codex-app-server",
codexHome: "/tmp/codex-home",
platformFamily: "unix",
platformOs: "macos",
});
assert.deepEqual(yield* Deferred.await(notificationDeferred), [
{
method: "item/agentMessage/delta",
params: {
delta: "Hello from the mock peer.",
itemId: "item-1",
threadId: "thread-1",
turnId: "turn-1",
},
},
]);
assert.deepEqual(yield* Deferred.await(requestDeferred), [
{
id: 77,
method: "item/tool/requestUserInput",
params: {
itemId: "item-approval-1",
threadId: "thread-1",
turnId: "turn-1",
questions: [
{
id: "approved",
header: "Approve",
question: "Continue?",
},
],
},
},
]);
yield* transport.respond(77, {
answers: {
approved: {
answers: ["yes"],
},
},
});
assert.deepEqual(yield* decodeJson(yield* Queue.take(output)), {
id: 77,
result: {
answers: {
approved: {
answers: ["yes"],
},
},
},
});
yield* transport.respondError(
78,
CodexError.CodexAppServerRequestError.methodNotFound("x/test"),
);
assert.deepEqual(yield* decodeJson(yield* Queue.take(output)), {
id: 78,
error: {
code: -32601,
message: "Method not found: x/test",
},
});
}),
);
it.effect("surfaces JSON encoding failures as protocol parse errors", () =>
Effect.gen(function* () {
const { stdio } = yield* makeInMemoryStdio();
const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({ stdio });
const bigintError = yield* transport.notify("x/test", 1n).pipe(Effect.flip);
assert.instanceOf(bigintError, CodexError.CodexAppServerProtocolParseError);
assert.equal(bigintError.operation, "encode-wire-message");
assert.equal(bigintError.method, "x/test");
assert.exists(bigintError.cause);
assert.equal(
bigintError.message,
"Codex App Server protocol operation 'encode-wire-message' failed for method 'x/test'.",
);
interface CircularPayload {
self?: CircularPayload;
}
const circular: CircularPayload = {};
circular.self = circular;
const circularError = yield* transport.notify("x/test", circular).pipe(Effect.flip);
assert.instanceOf(circularError, CodexError.CodexAppServerProtocolParseError);
assert.equal(circularError.operation, "encode-wire-message");
assert.equal(circularError.method, "x/test");
assert.exists(circularError.cause);
const requestError = yield* transport.request("x/request", 1n).pipe(
Effect.match({
onFailure: (error) => error,
onSuccess: () => assert.fail("Expected request encoding to fail"),
}),
);
assert.instanceOf(requestError, CodexError.CodexAppServerProtocolParseError);
assert.deepInclude(requestError, {
operation: "encode-wire-message",
method: "x/request",
requestId: "1",
});
}),
);
it.effect("correlates response errors with the originating request", () =>
Effect.gen(function* () {
const { stdio, input, output } = yield* makeInMemoryStdio();
const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({ stdio });
const response = yield* transport.request("thread/start", {}).pipe(Effect.forkScoped);
yield* Queue.take(output);
yield* Queue.offer(
input,
encodeJsonl({
id: 1,
error: {
code: -32602,
message: "Invalid params",
data: { field: "cwd" },
},
}),
);
const error = yield* Fiber.join(response).pipe(
Effect.match({
onFailure: (error) => error,
onSuccess: () => assert.fail("Expected Codex App Server request to fail"),
}),
);
assert.instanceOf(error, CodexError.CodexAppServerRequestError);
assert.deepInclude(error, {
code: -32602,
errorMessage: "Invalid params",
method: "thread/start",
requestId: "1",
operation: "receive-response",
});
}),
);
});