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 { RuntimeTaskId } from "@akeru/contracts";
import { ProviderDriverKind } from "@akeru/contracts";
import { afterEach, describe, expect, it } from "vite-plus/test";
import {
asEventId,
asThreadId,
asTurnId,
waitForThread,
type ProviderRuntimeTestActivity,
type ProviderRuntimeTestProposedPlan,
createRuntimeIngestionHarness,
} from "./test-support/RuntimeIngestionHarness.ts";
describe("ProviderRuntimeIngestion", () => {
const testScope = createRuntimeIngestionHarness();
const { createHarness } = testScope;
afterEach(testScope.dispose);
it("projects Codex task lifecycle chunks into thread activities", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "task.started",
eventId: asEventId("evt-task-started"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-task-1"),
payload: {
taskId: RuntimeTaskId.make("turn-task-1"),
taskType: "plan",
},
});
harness.emit({
type: "task.progress",
eventId: asEventId("evt-task-progress"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-task-1"),
payload: {
taskId: RuntimeTaskId.make("turn-task-1"),
description: "Comparing the desktop rollout chunks to the app-server stream.",
summary: "Code reviewer is validating the desktop rollout chunks.",
},
});
harness.emit({
type: "task.completed",
eventId: asEventId("evt-task-completed"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-task-1"),
payload: {
taskId: RuntimeTaskId.make("turn-task-1"),
status: "completed",
summary: "<proposed_plan>\n# Plan title\n</proposed_plan>",
},
});
harness.emit({
type: "turn.proposed.completed",
eventId: asEventId("evt-task-proposed-plan-completed"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-task-1"),
payload: {
planMarkdown: "# Plan title",
},
});
const thread = await waitForThread(
harness,
(entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.kind === "task.completed",
) &&
entry.proposedPlans.some(
(proposedPlan: ProviderRuntimeTestProposedPlan) =>
proposedPlan.id === "plan:thread-1:turn:turn-task-1",
),
);
const started = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-task-started",
);
const progress = thread.activities.find(
(activity: ProviderRuntimeTestActivity) =>
activity.id === "task-progress:thread-1:turn-task-1",
);
const completed = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-task-completed",
);
const progressPayload =
progress?.payload &&
(progress.payload === null || Predicate.isObjectOrArray(progress.payload))
? (progress.payload as Record<string, Schema.Json>)
: undefined;
const completedPayload =
completed?.payload &&
(completed.payload === null || Predicate.isObjectOrArray(completed.payload))
? (completed.payload as Record<string, Schema.Json>)
: undefined;
expect(started?.kind).toBe("task.started");
expect(started?.summary).toBe("Plan task started");
expect(progress?.kind).toBe("task.progress");
expect(progressPayload?.detail).toBe("Code reviewer is validating the desktop rollout chunks.");
expect(progressPayload?.summary).toBe(
"Code reviewer is validating the desktop rollout chunks.",
);
expect(completed?.kind).toBe("task.completed");
expect(completedPayload?.detail).toBe("<proposed_plan>\n# Plan title\n</proposed_plan>");
expect(
thread.proposedPlans.find(
(entry: ProviderRuntimeTestProposedPlan) => entry.id === "plan:thread-1:turn:turn-task-1",
)?.planMarkdown,
).toBe("# Plan title");
});
it("titles task activities with the task description, including on completion", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "task.started",
eventId: asEventId("evt-named-task-started"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-named-task"),
payload: {
taskId: RuntimeTaskId.make("named-task-1"),
description: "Typecheck mobile app",
taskType: "local_bash",
},
});
harness.emit({
type: "task.progress",
eventId: asEventId("evt-named-task-progress"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-named-task"),
payload: {
taskId: RuntimeTaskId.make("named-task-1"),
description: "Typecheck mobile app",
summary: "Running tsc across the mobile workspace.",
},
});
harness.emit({
type: "task.completed",
eventId: asEventId("evt-named-task-completed"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-named-task"),
payload: {
taskId: RuntimeTaskId.make("named-task-1"),
status: "completed",
summary: "Typecheck finished without errors.",
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-named-task-completed",
),
);
const progress = thread.activities.find(
(activity: ProviderRuntimeTestActivity) =>
activity.id === "task-progress:thread-1:named-task-1",
);
const completed = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-named-task-completed",
);
const progressPayload =
progress?.payload &&
(progress.payload === null || Predicate.isObjectOrArray(progress.payload))
? (progress.payload as Record<string, Schema.Json>)
: undefined;
const completedPayload =
completed?.payload &&
(completed.payload === null || Predicate.isObjectOrArray(completed.payload))
? (completed.payload as Record<string, Schema.Json>)
: undefined;
expect(progress?.summary).toBe("Typecheck mobile app");
expect(progressPayload?.title).toBe("Typecheck mobile app");
expect(completed?.summary).toBe("Task completed");
expect(completedPayload?.title).toBe("Typecheck mobile app");
expect(completedPayload?.summary).toBe("Typecheck finished without errors.");
expect(completedPayload?.detail).toBe("Typecheck finished without errors.");
});
it("titles task completion from task.started when no progress event carried the name", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "task.started",
eventId: asEventId("evt-fast-task-started"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-fast-task"),
payload: {
taskId: RuntimeTaskId.make("fast-task-1"),
description: "wait for codex review to finish",
taskType: "local_bash",
},
});
harness.emit({
type: "task.completed",
eventId: asEventId("evt-fast-task-completed"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-fast-task"),
payload: {
taskId: RuntimeTaskId.make("fast-task-1"),
status: "completed",
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-fast-task-completed",
),
);
const completed = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-fast-task-completed",
);
const completedPayload =
completed?.payload &&
(completed.payload === null || Predicate.isObjectOrArray(completed.payload))
? (completed.payload as Record<string, Schema.Json>)
: undefined;
expect(completedPayload?.title).toBe("wait for codex review to finish");
});
it("titles task completion from persisted activities after the description cache is swept", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "task.progress",
eventId: asEventId("evt-swept-task-progress"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-swept-task"),
payload: {
taskId: RuntimeTaskId.make("swept-task-1"),
description: "Watch round-3 CI and bots",
summary: "Polling CI checks.",
},
});
await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) =>
activity.id === "task-progress:thread-1:swept-task-1",
),
);
// session.exited sweeps the in-memory description cache; the completion
// that follows must recover the name from persisted activities.
harness.emit({
type: "session.exited",
eventId: asEventId("evt-swept-task-session-exited"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
payload: {},
});
harness.emit({
type: "task.completed",
eventId: asEventId("evt-swept-task-completed"),
provider: ProviderDriverKind.make("claudeAgent"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-swept-task"),
payload: {
taskId: RuntimeTaskId.make("swept-task-1"),
status: "completed",
summary: "CI is green.",
},
});
const thread = await waitForThread(harness, (entry) =>
entry.activities.some(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-swept-task-completed",
),
);
const completed = thread.activities.find(
(activity: ProviderRuntimeTestActivity) => activity.id === "evt-swept-task-completed",
);
const completedPayload =
completed?.payload &&
(completed.payload === null || Predicate.isObjectOrArray(completed.payload))
? (completed.payload as Record<string, Schema.Json>)
: undefined;
expect(completedPayload?.title).toBe("Watch round-3 CI and bots");
});
});