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 {
CommandId,
DEFAULT_PROVIDER_INTERACTION_MODE,
MessageId,
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,
waitForThread,
asTurnId,
createRuntimeIngestionHarness,
} from "./test-support/RuntimeIngestionHarness.ts";
describe("ProviderRuntimeIngestion", () => {
const testScope = createRuntimeIngestionHarness();
const { createHarness } = testScope;
afterEach(testScope.dispose);
it("applies provider session.state.changed transitions directly", async () => {
const harness = await createHarness();
const waitingAt = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "session.state.changed",
eventId: asEventId("evt-session-state-waiting"),
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: waitingAt,
payload: {
state: "waiting",
reason: "awaiting approval",
},
});
let thread = await waitForThread(
harness,
(entry) => entry.session?.status === "running" && entry.session?.activeTurnId === null,
);
expect(thread.session?.status).toBe("running");
expect(thread.session?.lastError).toBeNull();
harness.emit({
type: "session.state.changed",
eventId: asEventId("evt-session-state-error"),
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
payload: {
state: "error",
reason: "provider crashed",
},
});
thread = await waitForThread(
harness,
(entry) =>
entry.session?.status === "error" &&
entry.session?.activeTurnId === null &&
entry.session?.lastError === "provider crashed",
);
expect(thread.session?.status).toBe("error");
expect(thread.session?.lastError).toBe("provider crashed");
harness.emit({
type: "session.state.changed",
eventId: asEventId("evt-session-state-stopped"),
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
payload: {
state: "stopped",
},
});
thread = await waitForThread(
harness,
(entry) =>
entry.session?.status === "stopped" &&
entry.session?.activeTurnId === null &&
entry.session?.lastError === "provider crashed",
);
expect(thread.session?.status).toBe("stopped");
expect(thread.session?.lastError).toBe("provider crashed");
harness.emit({
type: "session.state.changed",
eventId: asEventId("evt-session-state-ready"),
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:00.000Z",
payload: {
state: "ready",
},
});
thread = await waitForThread(
harness,
(entry) =>
entry.session?.status === "ready" &&
entry.session?.activeTurnId === null &&
entry.session?.lastError === null,
);
expect(thread.session?.status).toBe("ready");
expect(thread.session?.lastError).toBeNull();
});
it("clears active turn when provider session becomes ready", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "turn.started",
eventId: asEventId("evt-turn-started-session-ready"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-session-ready"),
});
await waitForThread(
harness,
(thread) =>
thread.session?.status === "running" &&
thread.session?.activeTurnId === "turn-session-ready",
10_000,
);
harness.emit({
type: "session.state.changed",
eventId: asEventId("evt-session-state-ready-with-active-turn"),
provider: ProviderDriverKind.make("codex"),
threadId: asThreadId("thread-1"),
createdAt: "2026-01-01T00:00:01.000Z",
payload: {
state: "ready",
},
});
const thread = await waitForThread(
harness,
(entry) =>
entry.session?.status === "ready" &&
entry.session?.activeTurnId === null &&
entry.session?.lastError === null,
10_000,
);
expect(thread.session?.status).toBe("ready");
expect(thread.session?.activeTurnId).toBeNull();
expect(thread.session?.lastError).toBeNull();
});
effectIt.effect(
"keeps a reconnecting pending turn starting while ready clears stale active state",
() =>
Effect.gen(function* () {
const harness = yield* Effect.promise(() => createHarness());
const threadId = asThreadId("thread-1");
const staleTurnId = asTurnId("turn-stale-before-reconnect");
yield* harness.engine.dispatch({
type: "thread.turn.start",
commandId: CommandId.make("cmd-turn-start-pending-reconnect"),
threadId,
message: {
messageId: MessageId.make("message-pending-reconnect"),
role: "user",
text: "resume after reconnect",
attachments: [],
},
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
runtimeMode: "approval-required",
createdAt: "2026-01-01T00:00:01.000Z",
});
yield* harness.engine.dispatch({
type: "thread.session.set",
commandId: CommandId.make("cmd-session-starting-pending-reconnect"),
threadId,
session: {
threadId,
status: "starting",
providerName: "codex",
runtimeMode: "approval-required",
activeTurnId: staleTurnId,
lastError: null,
updatedAt: "2026-01-01T00:00:01.000Z",
},
createdAt: "2026-01-01T00:00:01.000Z",
});
harness.emit({
type: "session.state.changed",
eventId: asEventId("evt-session-ready-pending-reconnect"),
provider: ProviderDriverKind.make("codex"),
threadId,
createdAt: "2026-01-01T00:00:02.000Z",
payload: { state: "ready" },
});
let thread = yield* Effect.promise(() =>
waitForThread(
harness,
(entry) => entry.session?.status === "starting" && entry.session.activeTurnId === null,
),
);
expect(thread.session?.status).toBe("starting");
expect(thread.session?.activeTurnId).toBeNull();
harness.emit({
type: "session.started",
eventId: asEventId("evt-session-started-pending-reconnect"),
provider: ProviderDriverKind.make("codex"),
threadId,
createdAt: "2026-01-01T00:00:03.000Z",
});
yield* Effect.promise(() => harness.drain());
thread = (yield* Effect.promise(() => harness.readModel())).threads.find(
(entry) => entry.id === threadId,
)!;
expect(thread.session?.status).toBe("starting");
expect(thread.session?.activeTurnId).toBeNull();
harness.emit({
type: "turn.started",
eventId: asEventId("evt-turn-started-pending-reconnect"),
provider: ProviderDriverKind.make("codex"),
threadId,
turnId: asTurnId("turn-after-reconnect"),
createdAt: "2026-01-01T00:00:04.000Z",
});
thread = yield* Effect.promise(() =>
waitForThread(
harness,
(entry) =>
entry.session?.status === "running" &&
entry.session.activeTurnId === asTurnId("turn-after-reconnect"),
),
);
expect(thread.session?.status).toBe("running");
harness.emit({
type: "session.started",
eventId: asEventId("evt-session-started-duplicate-midturn"),
provider: ProviderDriverKind.make("codex"),
threadId,
createdAt: "2026-01-01T00:00:05.000Z",
});
yield* Effect.promise(() => harness.drain());
thread = (yield* Effect.promise(() => harness.readModel())).threads.find(
(entry) => entry.id === threadId,
)!;
expect(thread.session?.status).toBe("running");
expect(thread.session?.activeTurnId).toBe(asTurnId("turn-after-reconnect"));
}),
);
effectIt.effect("keeps an aborted pending start stopped across duplicate exit events", () =>
Effect.gen(function* () {
const harness = yield* Effect.promise(() => createHarness());
const threadId = asThreadId("thread-1");
const stoppedAt = "2026-01-01T00:00:02.000Z";
yield* harness.engine.dispatch({
type: "thread.turn.start",
commandId: CommandId.make("cmd-turn-start-before-stop"),
threadId,
message: {
messageId: MessageId.make("message-before-stop"),
role: "user",
text: "stop this startup",
attachments: [],
},
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
runtimeMode: "approval-required",
createdAt: "2026-01-01T00:00:01.000Z",
});
yield* harness.engine.dispatch({
type: "thread.session.set",
commandId: CommandId.make("cmd-session-starting-before-stop"),
threadId,
session: {
threadId,
status: "starting",
providerName: "codex",
runtimeMode: "approval-required",
activeTurnId: null,
lastError: null,
updatedAt: "2026-01-01T00:00:01.000Z",
},
createdAt: "2026-01-01T00:00:01.000Z",
});
yield* harness.engine.dispatch({
type: "thread.session.set",
commandId: CommandId.make("cmd-session-stop-pending-start"),
threadId,
session: {
threadId,
status: "stopped",
providerName: "codex",
runtimeMode: "approval-required",
activeTurnId: null,
lastError: null,
updatedAt: stoppedAt,
},
createdAt: stoppedAt,
});
harness.emit({
type: "session.exited",
eventId: asEventId("evt-session-exited-after-stop"),
provider: ProviderDriverKind.make("codex"),
threadId,
createdAt: "2026-01-01T00:00:03.000Z",
});
harness.emit({
type: "session.exited",
eventId: asEventId("evt-duplicate-session-exited-after-stop"),
provider: ProviderDriverKind.make("codex"),
threadId,
createdAt: "2026-01-01T00:00:04.000Z",
});
yield* Effect.promise(() => harness.drain());
const thread = (yield* Effect.promise(() => harness.readModel())).threads.find(
(entry) => entry.id === threadId,
);
expect(thread?.session?.status).toBe("stopped");
expect(thread?.session?.activeTurnId).toBeNull();
}),
);
it("does not clear active turn when session/thread started arrives mid-turn", async () => {
const harness = await createHarness();
const now = "2026-01-01T00:00:00.000Z";
harness.emit({
type: "turn.started",
eventId: asEventId("evt-turn-started-midturn-lifecycle"),
provider: ProviderDriverKind.make("codex"),
createdAt: now,
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-midturn-lifecycle"),
});
await waitForThread(
harness,
(thread) =>
thread.session?.status === "running" &&
thread.session?.activeTurnId === "turn-midturn-lifecycle",
10_000,
);
harness.emit({
type: "thread.started",
eventId: asEventId("evt-thread-started-midturn-lifecycle"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: asThreadId("thread-1"),
});
harness.emit({
type: "session.started",
eventId: asEventId("evt-session-started-midturn-lifecycle"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: asThreadId("thread-1"),
});
await harness.drain();
const midReadModel = await harness.readModel();
const midThread = midReadModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
expect(midThread?.session?.status).toBe("running");
expect(midThread?.session?.activeTurnId).toBe("turn-midturn-lifecycle");
harness.emit({
type: "turn.completed",
eventId: asEventId("evt-turn-completed-midturn-lifecycle"),
provider: ProviderDriverKind.make("codex"),
createdAt: "2026-01-01T00:00:00.000Z",
threadId: asThreadId("thread-1"),
turnId: asTurnId("turn-midturn-lifecycle"),
status: "completed",
});
await waitForThread(
harness,
(thread) => thread.session?.status === "ready" && thread.session?.activeTurnId === null,
10_000,
);
});
});