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 { ProviderDriverKind } from "@akeru/contracts";
import { ApprovalRequestId, ThreadId } from "@akeru/contracts";
import { afterEach, describe, expect, it } from "vite-plus/test";
import {
asEventId,
asThreadId,
asTurnId,
waitForThread,
asItemId,
type ProviderRuntimeTestMessage,
type ProviderRuntimeTestActivity,
createRuntimeIngestionHarness,
} from "./test-support/RuntimeIngestionHarness.ts";
describe("ProviderRuntimeIngestion", () => {
const testScope = createRuntimeIngestionHarness();
const { createHarness } = testScope;
afterEach(testScope.dispose);
it("buffers assistant deltas by default until completion", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "turn.started",
eventId: asEventId("evt-turn-started-buffered"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered"),
});
await waitForThread(
harness,
(thread) =>
thread.session?.status === "running" && thread.session?.activeTurnId === "turn-buffered",
);
harness.emit({
type: "content.delta",
eventId: asEventId("evt-message-delta-buffered"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered"),
itemId: asItemId("item-buffered"),
payload: {
streamKind: "assistant_text",
delta: "buffer me",
},
});
await harness.drain();
const midReadModel = await harness.readModel();
const midThread = midReadModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
expect(
midThread?.messages.some(
(message: ProviderRuntimeTestMessage) => message.id === "assistant:item-buffered",
),
).toBe(false);
harness.emit({
type: "item.completed",
eventId: asEventId("evt-message-completed-buffered"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered"),
itemId: asItemId("item-buffered"),
payload: {
itemType: "assistant_message",
status: "completed",
},
});
const thread = await waitForThread(harness, (entry) =>
entry.messages.some(
(message: ProviderRuntimeTestMessage) =>
message.id === "assistant:item-buffered" && !message.streaming,
),
);
const message = thread.messages.find(
(entry: ProviderRuntimeTestMessage) => entry.id === "assistant:item-buffered",
);
expect(message?.text).toBe("buffer me");
expect(message?.streaming).toBe(false);
});
it("flushes and completes buffered assistant text when an approval request opens", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "turn.started",
eventId: asEventId("evt-turn-started-buffered-request-flush"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-request-flush"),
});
await waitForThread(
harness,
(thread) =>
thread.session?.status === "running" &&
thread.session?.activeTurnId === "turn-buffered-request-flush",
);
harness.emit({
type: "content.delta",
eventId: asEventId("evt-message-delta-buffered-request-flush"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-request-flush"),
itemId: asItemId("item-buffered-request-flush"),
payload: {
streamKind: "assistant_text",
delta: "visible before approval",
},
});
harness.emit({
type: "request.opened",
eventId: asEventId("evt-request-opened-buffered-request-flush"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-request-flush"),
requestId: ApprovalRequestId.make("req-buffered-request-flush"),
payload: {
requestType: "command_execution_approval",
detail: "pwd",
},
});
const thread = await waitForThread(harness, (entry) =>
entry.messages.some(
(message: ProviderRuntimeTestMessage) =>
message.id === "assistant:item-buffered-request-flush" &&
!message.streaming &&
message.text === "visible before approval",
),
);
const message = thread.messages.find(
(entry: ProviderRuntimeTestMessage) => entry.id === "assistant:item-buffered-request-flush",
);
expect(message?.streaming).toBe(false);
});
it("flushes and completes buffered assistant text when user input is requested", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "turn.started",
eventId: asEventId("evt-turn-started-buffered-user-input-flush"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-user-input-flush"),
});
await waitForThread(
harness,
(thread) =>
thread.session?.status === "running" &&
thread.session?.activeTurnId === "turn-buffered-user-input-flush",
);
harness.emit({
type: "content.delta",
eventId: asEventId("evt-message-delta-buffered-user-input-flush"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-user-input-flush"),
itemId: asItemId("item-buffered-user-input-flush"),
payload: {
streamKind: "assistant_text",
delta: "visible before user input",
},
});
harness.emit({
type: "user-input.requested",
eventId: asEventId("evt-user-input-requested-buffered-user-input-flush"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-user-input-flush"),
requestId: ApprovalRequestId.make("req-buffered-user-input-flush"),
payload: {
questions: [
{
id: "choice",
header: "Choice",
question: "Pick one",
options: [{ label: "A", description: "Option A" }],
},
],
},
});
const thread = await waitForThread(harness, (entry) =>
entry.messages.some(
(message: ProviderRuntimeTestMessage) =>
message.id === "assistant:item-buffered-user-input-flush" &&
!message.streaming &&
message.text === "visible before user input",
),
);
const message = thread.messages.find(
(entry: ProviderRuntimeTestMessage) =>
entry.id === "assistant:item-buffered-user-input-flush",
);
expect(message?.streaming).toBe(false);
});
it("does not create assistant segments for whitespace-only buffered text at approval boundaries", async () => {
const harness = await createHarness();
const startedAt = "2026-03-28T06:28:00.000Z";
const pausedAt = "2026-03-28T06:28:01.000Z";
harness.emit({
type: "turn.started",
eventId: asEventId("evt-turn-started-buffered-whitespace-request"),
provider: ProviderDriverKind.make("codex"),
createdAt: startedAt,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-whitespace-request"),
});
await waitForThread(
harness,
(thread) =>
thread.session?.status === "running" &&
thread.session?.activeTurnId === "turn-buffered-whitespace-request",
);
harness.emit({
type: "content.delta",
eventId: asEventId("evt-message-delta-buffered-whitespace-request"),
provider: ProviderDriverKind.make("codex"),
createdAt: startedAt,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-whitespace-request"),
itemId: asItemId("item-buffered-whitespace-request"),
payload: {
streamKind: "assistant_text",
delta: "\n\n\n",
},
});
harness.emit({
type: "request.opened",
eventId: asEventId("evt-request-opened-buffered-whitespace-request"),
provider: ProviderDriverKind.make("codex"),
createdAt: pausedAt,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-buffered-whitespace-request"),
requestId: ApprovalRequestId.make("req-buffered-whitespace-request"),
payload: {
requestType: "command_execution_approval",
detail: "pwd",
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "approval.requested",
),
);
expect(
thread.messages.some(
(message: ProviderRuntimeTestMessage) =>
message.id === "assistant:item-buffered-whitespace-request",
),
).toBe(false);
});
});