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 Schema from "effect/Schema";
import * as Predicate from "effect/Predicate";
import { ProviderDriverKind } from "@akeru/contracts";
import { ThreadId } from "@akeru/contracts";
import * as Effect from "effect/Effect";
import { it as effectIt } from "@effect/vitest";
import { afterEach, describe, expect, it } from "vite-plus/test";
import {
asEventId,
asThreadId,
asTurnId,
asItemId,
waitForThread,
type ProviderRuntimeTestActivity,
type ProviderRuntimeTestCheckpoint,
createRuntimeIngestionHarness,
} from "./test-support/RuntimeIngestionHarness.ts";
describe("ProviderRuntimeIngestion", () => {
const testScope = createRuntimeIngestionHarness();
const { createHarness } = testScope;
afterEach(testScope.dispose);
it("preserves completed tool metadata on projected tool activities", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "item.completed",
eventId: asEventId("evt-tool-completed-with-data"),
provider: ProviderDriverKind.make("cursor"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-tool-completed"),
itemId: asItemId("item-tool-completed"),
payload: {
itemType: "dynamic_tool_call",
status: "completed",
title: "Read file",
data: {
toolCallId: "tool-read-1",
kind: "read",
rawOutput: {
content: 'import * as Effect from "effect/Effect"\n',
},
},
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-tool-completed-with-data",
),
);
const activity = thread.activities.find(
(entry: ProviderRuntimeTestActivity) => entry.id === "evt-tool-completed-with-data",
);
const payload =
activity?.payload &&
(activity.payload === null || Predicate.isObjectOrArray(activity.payload))
? (activity.payload as Record<string, Schema.Json>)
: undefined;
const data =
payload?.data && (payload.data === null || Predicate.isObjectOrArray(payload.data))
? (payload.data as Record<string, Schema.Json>)
: undefined;
const rawOutput =
data?.rawOutput && (data.rawOutput === null || Predicate.isObjectOrArray(data.rawOutput))
? (data.rawOutput as Record<string, Schema.Json>)
: undefined;
expect(activity?.kind).toBe("tool.completed");
expect(activity?.summary).toBe("Read file");
expect(payload?.itemType).toBe("dynamic_tool_call");
expect(payload?.detail).toBeUndefined();
expect(data?.toolCallId).toBe("tool-read-1");
expect(data?.kind).toBe("read");
expect(rawOutput?.content).toBe('import * as Effect from "effect/Effect"\n');
});
it("normalizes command execution activities to ran-command summaries", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "item.completed",
eventId: asEventId("evt-command-completed"),
provider: ProviderDriverKind.make("cursor"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-command-completed"),
itemId: asItemId("item-command-completed"),
payload: {
itemType: "command_execution",
status: "completed",
title: "Ran command",
detail: "bun run lint",
data: {
toolCallId: "tool-command-1",
kind: "execute",
command: "bun run lint",
},
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-command-completed",
),
);
const activity = thread.activities.find(
(entry: ProviderRuntimeTestActivity) => entry.id === "evt-command-completed",
);
const payload =
activity?.payload &&
(activity.payload === null || Predicate.isObjectOrArray(activity.payload))
? (activity.payload as Record<string, Schema.Json>)
: undefined;
expect(activity?.summary).toBe("Ran command");
expect(payload?.detail).toBe("bun run lint");
});
it("uses structured read-file paths when available", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "item.completed",
eventId: asEventId("evt-read-path-completed"),
provider: ProviderDriverKind.make("cursor"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-read-path"),
itemId: asItemId("item-read-path"),
payload: {
itemType: "dynamic_tool_call",
status: "completed",
title: "Read file",
detail: "/tmp/app.ts",
data: {
toolCallId: "tool-read-path-1",
kind: "read",
locations: [{ path: "/tmp/app.ts" }],
},
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-read-path-completed",
),
);
const activity = thread.activities.find(
(entry: ProviderRuntimeTestActivity) => entry.id === "evt-read-path-completed",
);
const payload =
activity?.payload &&
(activity.payload === null || Predicate.isObjectOrArray(activity.payload))
? (activity.payload as Record<string, Schema.Json>)
: undefined;
expect(activity?.summary).toBe("Read file");
expect(payload?.detail).toBe("/tmp/app.ts");
});
it("consumes P1 runtime events into thread metadata, diff checkpoints, and activities", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "thread.metadata.updated",
eventId: asEventId("evt-thread-metadata-updated"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
payload: {
name: "Renamed by provider",
metadata: { source: "provider" },
},
});
harness.emit({
type: "turn.plan.updated",
eventId: asEventId("evt-turn-plan-updated"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-p1"),
payload: {
explanation: "Working through the plan",
plan: [
{ step: "Inspect files", status: "completed" },
{ step: "Apply patch", status: "inProgress" },
],
},
});
harness.emit({
type: "item.updated",
eventId: asEventId("evt-item-updated"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-p1"),
itemId: asItemId("item-p1-tool"),
payload: {
itemType: "command_execution",
status: "inProgress",
title: "Run tests",
detail: "bun test",
data: { pid: 123 },
},
});
harness.emit({
type: "runtime.warning",
eventId: asEventId("evt-runtime-warning"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-p1"),
payload: {
message: "Provider got slow",
detail: { latencyMs: 1500 },
},
});
harness.emit({
type: "turn.diff.updated",
eventId: asEventId("evt-turn-diff-updated"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-p1"),
itemId: asItemId("item-p1-assistant"),
payload: {
unifiedDiff: "diff --git a/file.txt b/file.txt\n+hello\n",
},
});
const thread = await waitForThread(
harness,
(entry) =>
entry.title === "Thread" &&
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "turn.plan.updated",
) &&
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "tool.updated",
) &&
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "runtime.warning",
) &&
entry.checkpoints.some(
(checkpoint: ProviderRuntimeTestCheckpoint) => checkpoint.turnId === "turn-p1",
),
);
expect(thread.title).toBe("Thread");
const planActivity = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-turn-plan-updated",
);
const planPayload =
planActivity?.payload &&
(planActivity.payload === null || Predicate.isObjectOrArray(planActivity.payload))
? (planActivity.payload as Record<string, Schema.Json>)
: undefined;
expect(planActivity?.kind).toBe("turn.plan.updated");
expect(Array.isArray(planPayload?.plan)).toBe(true);
const toolUpdate = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-item-updated",
);
const toolUpdatePayload =
toolUpdate?.payload &&
(toolUpdate.payload === null || Predicate.isObjectOrArray(toolUpdate.payload))
? (toolUpdate.payload as Record<string, Schema.Json>)
: undefined;
expect(toolUpdate?.kind).toBe("tool.updated");
expect(toolUpdatePayload?.itemType).toBe("command_execution");
expect(toolUpdatePayload?.status).toBe("inProgress");
expect(toolUpdatePayload?.toolCallId).toBe("item-p1-tool");
const warning = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-runtime-warning",
);
const warningPayload =
warning?.payload && (warning.payload === null || Predicate.isObjectOrArray(warning.payload))
? (warning.payload as Record<string, Schema.Json>)
: undefined;
expect(warning?.kind).toBe("runtime.warning");
expect(warningPayload?.message).toBe("Provider got slow");
const checkpoint = thread.checkpoints.find(
(entry: ProviderRuntimeTestCheckpoint) => entry.turnId === "turn-p1",
);
expect(checkpoint?.status).toBe("missing");
expect(checkpoint?.assistantMessageId).toBe("assistant:item-p1-assistant");
expect(checkpoint?.checkpointRef).toBe("provider-diff:evt-turn-diff-updated");
});
effectIt.effect("tracks provider diff updates from a nested Git workspace", () =>
Effect.gen(function* () {
const harness = yield* Effect.promise(() =>
createHarness({ workspaceSubdirectory: "apps/server" }),
);
harness.emit({
type: "turn.diff.updated",
eventId: asEventId("evt-nested-diff"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: asThreadId("thread-1"),
turnId: asTurnId("nested-turn"),
payload: {
unifiedDiff: "diff --git a/apps/server/file.ts b/apps/server/file.ts\n+new\n",
},
});
yield* Effect.promise(harness.drain);
const snapshot = yield* Effect.promise(harness.readModel);
expect(snapshot.threads[0]?.checkpoints).toEqual([
expect.objectContaining({ turnId: "nested-turn", status: "missing" }),
]);
}),
);
it("does not replace the app title with provider metadata", async () => {
const harness = await createHarness({ threadTitle: "Bot conversation" });
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "thread.metadata.updated",
eventId: asEventId("evt-thread-metadata-default"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
payload: {
name: "Renamed by provider",
metadata: { source: "provider" },
},
});
await harness.drain();
const readModel = await harness.readModel();
const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
expect(thread?.title).toBe("Bot conversation");
});
it("projects context window updates into normalized thread activities", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "thread.token-usage.updated",
eventId: asEventId("evt-thread-token-usage-updated"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
payload: {
usage: {
usedTokens: 1075,
totalProcessedTokens: 10_200,
maxTokens: 128_000,
inputTokens: 1000,
cachedInputTokens: 500,
outputTokens: 50,
reasoningOutputTokens: 25,
lastUsedTokens: 1075,
lastInputTokens: 1000,
lastCachedInputTokens: 500,
lastOutputTokens: 50,
lastReasoningOutputTokens: 25,
compactsAutomatically: true,
},
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "context-window.updated",
),
);
const usageActivity = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.kind === "context-window.updated",
);
expect(usageActivity).toBeDefined();
expect(usageActivity?.payload).toMatchObject({
usedTokens: 1075,
totalProcessedTokens: 10_200,
maxTokens: 128_000,
inputTokens: 1000,
cachedInputTokens: 500,
outputTokens: 50,
reasoningOutputTokens: 25,
lastUsedTokens: 1075,
compactsAutomatically: true,
});
});
it("projects Codex camelCase token usage payloads into normalized thread activities", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "thread.token-usage.updated",
eventId: asEventId("evt-thread-token-usage-updated-camel"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
payload: {
usage: {
usedTokens: 126,
totalProcessedTokens: 11_839,
maxTokens: 258_400,
inputTokens: 120,
cachedInputTokens: 0,
outputTokens: 6,
reasoningOutputTokens: 0,
lastUsedTokens: 126,
lastInputTokens: 120,
lastCachedInputTokens: 0,
lastOutputTokens: 6,
lastReasoningOutputTokens: 0,
compactsAutomatically: true,
},
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "context-window.updated",
),
);
const usageActivity = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.kind === "context-window.updated",
);
expect(usageActivity?.payload).toMatchObject({
usedTokens: 126,
totalProcessedTokens: 11_839,
maxTokens: 258_400,
inputTokens: 120,
cachedInputTokens: 0,
outputTokens: 6,
reasoningOutputTokens: 0,
lastUsedTokens: 126,
lastInputTokens: 120,
lastOutputTokens: 6,
compactsAutomatically: true,
});
});
it("projects Claude usage snapshots with context window into normalized thread activities", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "thread.token-usage.updated",
eventId: asEventId("evt-thread-token-usage-updated-claude-window"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
payload: {
usage: {
usedTokens: 31_251,
lastUsedTokens: 31_251,
maxTokens: 200_000,
toolUses: 25,
durationMs: 43_567,
},
},
raw: {
source: "claude.sdk.message",
method: "claude/result/success",
payload: {},
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "context-window.updated",
),
);
const usageActivity = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.kind === "context-window.updated",
);
expect(usageActivity?.payload).toMatchObject({
usedTokens: 31_251,
lastUsedTokens: 31_251,
maxTokens: 200_000,
toolUses: 25,
durationMs: 43_567,
});
});
it("projects compacted thread state into context compaction activities", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "thread.state.changed",
eventId: asEventId("evt-thread-compacted"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-1"),
payload: {
state: "compacted",
detail: { source: "provider" },
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "context-compaction",
),
);
const activity = thread.activities.find(
(candidate: ProviderRuntimeTestActivity) => candidate.kind === "context-compaction",
);
expect(activity?.summary).toBe("Context compacted");
expect(activity?.tone).toBe("info");
});
});