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 NodeServices from "@effect/platform-node/NodeServices";
import { ProviderDriverKind, ThreadId } from "@akeru/contracts";
import { assert, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Logger from "effect/Logger";
import * as Schema from "effect/Schema";
import * as AcpErrors from "effect-acp/errors";
import type { EventNdjsonLogger } from "../Layers/EventNdjsonLogger.ts";
import { makeAcpNativeLoggerFactory } from "./AcpNativeLogging.ts";
const nodeServicesIt = it.layer(NodeServices.layer);
const encodeUnknownJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
nodeServicesIt("ACP native logging", (it) => {
it.effect("records bounded request and protocol diagnostics without raw payloads", () =>
Effect.gen(function* () {
const records: Array<unknown> = [];
const nativeEventLogger: EventNdjsonLogger = {
filePath: "/tmp/provider-native.ndjson",
write: (event) => Effect.sync(() => void records.push(event)),
close: () => Effect.void,
};
const makeLogger = yield* makeAcpNativeLoggerFactory();
const logger = makeLogger({
nativeEventLogger,
provider: ProviderDriverKind.make("cursor"),
threadId: ThreadId.make("thread-1"),
verboseProtocolLogging: true,
});
const secret = "secret-token-value";
const requestLogger = logger.requestLogger;
const protocolLogger = logger.protocolLogging?.logger;
assert.exists(requestLogger);
assert.exists(protocolLogger);
if (!requestLogger || !protocolLogger) return;
yield* requestLogger({
method: "session/prompt",
payload: { prompt: secret, sessionId: secret },
status: "failed",
cause: Cause.fail(AcpErrors.AcpRequestError.internalError(secret, { token: secret })),
});
yield* protocolLogger({
direction: "incoming",
stage: "raw",
payload: `{"token":"${secret}"}`,
});
yield* protocolLogger({
direction: "outgoing",
stage: "decoded",
payload: {
_tag: "Request",
tag: "session/prompt",
payload: { prompt: secret },
},
});
const serialized = encodeUnknownJson(records);
assert.notInclude(serialized, secret);
assert.include(serialized, '"method":"session/prompt"');
assert.include(serialized, '"errorTag":"AcpRequestError"');
assert.include(serialized, '"reasonCount":1');
assert.include(serialized, '"valueType":"string"');
assert.include(serialized, '"messageTag":"Request"');
}),
);
it.effect("keeps request diagnostics without enabling full protocol logging", () =>
Effect.gen(function* () {
const records: Array<unknown> = [];
const makeLogger = yield* makeAcpNativeLoggerFactory();
const logger = makeLogger({
nativeEventLogger: {
filePath: "/tmp/provider-native.ndjson",
write: (event) => Effect.sync(() => void records.push(event)),
close: () => Effect.void,
},
provider: ProviderDriverKind.make("grok"),
threadId: ThreadId.make("thread-1"),
});
assert.isUndefined(logger.protocolLogging);
const requestLogger = logger.requestLogger;
assert.exists(requestLogger);
if (!requestLogger) return;
yield* requestLogger({
method: "session/prompt",
payload: {},
status: "started",
});
assert.lengthOf(records, 1);
}),
);
it.effect("drops transient ACP chunks before formatting verbose protocol logs", () =>
Effect.gen(function* () {
const records: Array<unknown> = [];
const makeLogger = yield* makeAcpNativeLoggerFactory();
const logger = makeLogger({
nativeEventLogger: {
filePath: "/tmp/provider-native.ndjson",
write: (event) => Effect.sync(() => void records.push(event)),
close: () => Effect.void,
},
provider: ProviderDriverKind.make("cursor"),
threadId: ThreadId.make("thread-1"),
verboseProtocolLogging: true,
});
const protocolLogger = logger.protocolLogging?.logger;
assert.exists(protocolLogger);
if (!protocolLogger) return;
for (const updateType of ["agent_message_chunk", "agent_thought_chunk"] as const) {
yield* protocolLogger({
direction: "incoming",
stage: "raw",
payload: `${encodeUnknownJson({
method: "session/update",
params: { update: { sessionUpdate: updateType } },
})}\n`,
});
yield* protocolLogger({
direction: "incoming",
stage: "decoded",
payload: [
{
_tag: "Request",
tag: "session/update",
payload: { update: { sessionUpdate: updateType } },
},
],
});
}
assert.lengthOf(records, 0);
yield* protocolLogger({
direction: "incoming",
stage: "decoded",
payload: [
{
_tag: "Request",
tag: "session/update",
payload: { update: { sessionUpdate: "tool_call" } },
},
],
});
assert.lengthOf(records, 1);
}),
);
it.effect("keeps mixed and incomplete raw diagnostics", () =>
Effect.gen(function* () {
const records: Array<unknown> = [];
const makeLogger = yield* makeAcpNativeLoggerFactory();
const logger = makeLogger({
nativeEventLogger: {
filePath: "/tmp/provider-native.ndjson",
write: (event) => Effect.sync(() => void records.push(event)),
close: () => Effect.void,
},
provider: ProviderDriverKind.make("cursor"),
threadId: ThreadId.make("thread-1"),
verboseProtocolLogging: true,
});
const protocolLogger = logger.protocolLogging?.logger;
assert.exists(protocolLogger);
if (!protocolLogger) return;
const transient = encodeUnknownJson({
method: "session/update",
params: { update: { sessionUpdate: "agent_message_chunk" } },
});
const lifecycle = encodeUnknownJson({ method: "session/new", params: {} });
yield* protocolLogger({
direction: "incoming",
stage: "raw",
payload: `${transient}\n${lifecycle}\n`,
});
yield* protocolLogger({
direction: "incoming",
stage: "raw",
payload: transient,
});
yield* protocolLogger({
direction: "incoming",
stage: "raw",
payload: `${transient}\n{malformed}\n`,
});
assert.lengthOf(records, 3);
}),
);
it.effect("filters transient entries from mixed decoded batches", () =>
Effect.gen(function* () {
const records: Array<unknown> = [];
const makeLogger = yield* makeAcpNativeLoggerFactory();
const logger = makeLogger({
nativeEventLogger: {
filePath: "/tmp/provider-native.ndjson",
write: (event) => Effect.sync(() => void records.push(event)),
close: () => Effect.void,
},
provider: ProviderDriverKind.make("grok"),
threadId: ThreadId.make("thread-1"),
verboseProtocolLogging: true,
});
const protocolLogger = logger.protocolLogging?.logger;
assert.exists(protocolLogger);
if (!protocolLogger) return;
yield* protocolLogger({
direction: "incoming",
stage: "decoded",
payload: [
{
_tag: "Request",
tag: "session/update",
payload: { update: { sessionUpdate: "agent_thought_chunk" } },
},
{
_tag: "Request",
tag: "session/new",
payload: {},
},
],
});
assert.lengthOf(records, 1);
assert.include(encodeUnknownJson(records), '"itemCount":1');
}),
);
it.effect("logs a structural tag when the native writer defects", () => {
const messages: Array<unknown> = [];
const logCapture = Logger.make<unknown, void>(({ message }) => {
if (Array.isArray(message)) {
messages.push(...message);
} else {
messages.push(message);
}
});
const secret = "secret-writer-failure";
return Effect.gen(function* () {
const makeLogger = yield* makeAcpNativeLoggerFactory();
const logger = makeLogger({
nativeEventLogger: {
filePath: "/tmp/provider-native.ndjson",
write: () => Effect.die(new Error(secret)),
close: () => Effect.void,
},
provider: ProviderDriverKind.make("cursor"),
threadId: ThreadId.make("thread-1"),
});
const requestLogger = logger.requestLogger;
assert.exists(requestLogger);
if (!requestLogger) return;
yield* requestLogger({
method: "session/prompt",
payload: {},
status: "started",
});
const serialized = encodeUnknownJson(messages);
assert.notInclude(serialized, secret);
assert.include(serialized, '"errorTag":"Die"');
assert.include(serialized, '"reasonCount":1');
}).pipe(Effect.provide(Logger.layer([logCapture], { mergeWithExisting: false })));
});
it.effect("preserves native writer interruption", () =>
Effect.gen(function* () {
const makeLogger = yield* makeAcpNativeLoggerFactory();
const logger = makeLogger({
nativeEventLogger: {
filePath: "/tmp/provider-native.ndjson",
write: () => Effect.interrupt,
close: () => Effect.void,
},
provider: ProviderDriverKind.make("cursor"),
threadId: ThreadId.make("thread-1"),
});
const requestLogger = logger.requestLogger;
assert.exists(requestLogger);
if (!requestLogger) return;
const exit = yield* requestLogger({
method: "session/prompt",
payload: {},
status: "started",
}).pipe(Effect.exit);
assert.isTrue(Exit.isFailure(exit));
if (Exit.isFailure(exit)) {
assert.isTrue(Cause.hasInterruptsOnly(exit.cause));
}
}),
);
});