Skip to content

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.

15.0 KB
Raw Blame
import * as Predicate from "effect/Predicate";
import { ProviderDriverKind, ProviderInstanceId } from "@akeru/contracts";
import { CommandId, DEFAULT_PROVIDER_INTERACTION_MODE, ThreadId } from "@akeru/contracts";
import * as Effect from "effect/Effect";
import * as Deferred from "effect/Deferred";
import { it as effectIt } from "@effect/vitest";
import { afterEach, describe, expect, it } from "vite-plus/test";
import { ProviderAdapterRequestError } from "../../provider/Errors.ts";
import {
  asMessageId,
  asProjectId,
  asTurnId,
  asApprovalRequestId,
  createProviderCommandHarness,
} from "./test-support/ProviderCommandHarness.ts";

describe("ProviderCommandReactor", () => {
  const testScope = createProviderCommandHarness();
  const { createHarness } = testScope;
  afterEach(testScope.dispose);
  it("routes thread.turn.start through AgentController before sending the provider turn", async () => {
    const harness = await createHarness();
    const now = "2026-01-01T00:00:00.000Z";

    await harness.run(
      harness.engine.dispatch({
        type: "thread.turn.start",
        commandId: CommandId.make("cmd-turn-start-1"),
        threadId: ThreadId.make("thread-1"),
        message: {
          messageId: asMessageId("user-message-1"),
          role: "user",
          text: "hello reactor",
          attachments: [],
        },
        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
        runtimeMode: "approval-required",
        createdAt: now,
      }),
    );

    await harness.waitFor(() => harness.startSession.mock.calls.length === 1);
    await harness.waitFor(() => harness.sendTurn.mock.calls.length === 1);
    expect(harness.resolveEngine).toHaveBeenCalledWith({
      threadId: ThreadId.make("thread-1"),
      engine: null,
      fallback: {
        instanceId: ProviderInstanceId.make("codex"),
        model: "gpt-5-codex",
      },
      mode: "default",
      botConversation: false,
    });
    expect(harness.startSession.mock.calls[0]?.[0]).toEqual(ThreadId.make("thread-1"));
    expect(harness.startSession.mock.calls[0]?.[1]).toMatchObject({
      cwd: "/tmp/provider-project",
      modelSelection: {
        instanceId: ProviderInstanceId.make("codex"),
        model: "gpt-5-codex",
      },
      mcpServers: [],
      memoryAccess: {
        tenantId: "local",
        userId: "owner",
        threadId: "thread-1",
        projectId: "project-1",
        workspaceRoot: "/tmp/provider-project",
        botId: null,
        groupId: null,
        respondingBotId: null,
        groupMemberBotIds: [],
      },
      botSandbox: "local",
      runtimeMode: "approval-required",
    });

    const readModel = await harness.readModel();
    const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
    expect(thread?.session?.threadId).toBe("thread-1");
    expect(thread?.session?.status).toBe("starting");
    expect(thread?.session?.runtimeMode).toBe("approval-required");
  });

  it.each([
    [1, "before"],
    [2, "after"],
  ] as const)(
    "handles an intent committed on startup sequence read %i, %s subscribing",
    async (commitDuringSequenceRead, _position) => {
      const harness = await createHarness({ commitDuringSequenceRead });

      await harness.drain();

      const readModel = await harness.readModel();
      const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
      expect(thread?.titleRegeneration).toBeNull();
    },
  );

  it("replays a startup gap longer than one event store page", async () => {
    const harness = await createHarness({
      commitDuringSequenceRead: 1,
      titleUpdatesBeforeStartupCommit: 1_000,
    });

    await harness.drain();

    const readModel = await harness.readModel();
    const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
    expect(thread?.titleRegeneration).toBeNull();
  });

  it("fails startup instead of dropping a gap it cannot replay", async () => {
    await expect(
      createHarness({ commitDuringSequenceRead: 1, failStartupReplay: true }),
    ).rejects.toThrow("Injected startup replay failure");
  });

  effectIt.effect("lets another thread approve and interrupt while session setup is blocked", () =>
    Effect.gen(function* () {
      const sessionSetupStarted = yield* Deferred.make<void>();
      const releaseSessionSetup = yield* Deferred.make<void>();
      const approvalReachedAdapter = yield* Deferred.make<void>();
      const interruptReachedAdapter = yield* Deferred.make<void>();
      const threadB = ThreadId.make("thread-2");

      const harness = yield* Effect.promise(() =>
        createHarness({
          startSessionEffect: (session) =>
            session.threadId === ThreadId.make("thread-1")
              ? Deferred.succeed(sessionSetupStarted, undefined).pipe(
                  Effect.andThen(Deferred.await(releaseSessionSetup)),
                  Effect.as(session),
                )
              : Effect.succeed(session),
          respondToRequestEffect: (request) =>
            request.threadId === threadB
              ? Deferred.succeed(approvalReachedAdapter, undefined).pipe(Effect.asVoid)
              : Effect.void,
          interruptTurnEffect: (request) =>
            (request === null || Predicate.isObjectOrArray(request)) &&
            request !== null &&
            "threadId" in request &&
            request.threadId === threadB
              ? Deferred.succeed(interruptReachedAdapter, undefined).pipe(Effect.asVoid)
              : Effect.void,
        }),
      );

      const now = "2026-01-01T00:00:00.000Z";

      yield* harness.engine.dispatch({
        type: "thread.create",
        commandId: CommandId.make("cmd-thread-create-2-concurrency"),
        threadId: threadB,
        projectId: asProjectId("project-1"),
        title: "Thread B",
        modelSelection: {
          instanceId: ProviderInstanceId.make("codex"),
          model: "gpt-5-codex",
        },
        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
        runtimeMode: "approval-required",
        branch: null,
        worktreePath: null,
        createdAt: now,
      });
      yield* harness.engine.dispatch({
        type: "thread.session.set",
        commandId: CommandId.make("cmd-thread-session-2-concurrency"),
        threadId: threadB,
        session: {
          threadId: threadB,
          status: "running",
          providerName: "codex",
          runtimeMode: "approval-required",
          activeTurnId: asTurnId("turn-2"),
          lastError: null,
          updatedAt: now,
        },
        createdAt: now,
      });
      yield* harness.engine.dispatch({
        type: "thread.turn.start",
        commandId: CommandId.make("cmd-turn-start-blocked-thread-1"),
        threadId: ThreadId.make("thread-1"),
        message: {
          messageId: asMessageId("user-message-blocked-thread-1"),
          role: "user",
          text: "block this setup",
          attachments: [],
        },
        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
        runtimeMode: "approval-required",
        createdAt: now,
      });
      yield* Deferred.await(sessionSetupStarted);

      yield* harness.engine.dispatch({
        type: "thread.approval.respond",
        commandId: CommandId.make("cmd-approval-thread-2-concurrency"),
        threadId: threadB,
        requestId: asApprovalRequestId("approval-thread-2-concurrency"),
        decision: "accept",
        createdAt: now,
      });
      yield* harness.engine.dispatch({
        type: "thread.turn.interrupt",
        commandId: CommandId.make("cmd-interrupt-thread-2-concurrency"),
        threadId: threadB,
        turnId: asTurnId("turn-2"),
        createdAt: now,
      });

      yield* Deferred.await(approvalReachedAdapter);
      yield* Deferred.await(interruptReachedAdapter);
      expect(yield* Deferred.isDone(releaseSessionSetup)).toBe(false);
      yield* Deferred.succeed(releaseSessionSetup, undefined);
      yield* Effect.promise(() => harness.drain());
    }),
  );

  it("replays a persisted turn start that predates reactor startup exactly once", async () => {
    const harness = await createHarness({ turnStartBeforeReactor: true });

    await harness.drain();

    expect(harness.startSession).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
      threadId: ThreadId.make("thread-1"),
      input: "recover this persisted request",
    });
  });

  it("replays a persisted resume that predates reactor startup exactly once", async () => {
    const harness = await createHarness({ resumeBeforeReactor: true });

    await harness.drain();

    expect(harness.startSession).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
      threadId: ThreadId.make("thread-1"),
      input: expect.stringContaining("Resume the interrupted request"),
    });
  });

  it("deduplicates a persisted resume delivered by both startup recovery and the live stream", async () => {
    const harness = await createHarness({
      resumeBeforeReactor: true,
      replayPersistedResumeOnSubscribe: true,
    });

    await harness.drain();

    expect(harness.startSession).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn).toHaveBeenCalledTimes(1);
  });

  it("continues a running turn after reactor startup without replaying the user prompt", async () => {
    const harness = await createHarness({ runningTurnBeforeReactor: true });

    await harness.drain();

    expect(harness.startSession).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
      threadId: ThreadId.make("thread-1"),
      input: expect.stringContaining("server restarted"),
    });
    expect(harness.sendTurn.mock.calls[0]?.[0]).not.toMatchObject({
      input: "recover this persisted request",
    });
  });

  it.each([
    ["pending turn start", { turnStartBeforeReactor: true }],
    ["pending resume", { resumeBeforeReactor: true }],
    ["running turn", { runningTurnBeforeReactor: true }],
  ] as const)(
    "does not restart a delegated child's %s after reactor startup",
    async (_name, recovery) => {
      const harness = await createHarness({ ...recovery, delegatedChild: true });

      await harness.drain();

      expect(harness.startSession).not.toHaveBeenCalled();
      expect(harness.sendTurn).not.toHaveBeenCalled();
    },
  );

  it("marks an interrupted turn resumable when automatic recovery fails", async () => {
    const harness = await createHarness({
      runningTurnBeforeReactor: true,
      sendTurnEffect: () =>
        Effect.fail(
          new ProviderAdapterRequestError({
            provider: ProviderDriverKind.make("codex"),
            method: "thread.turn.start",
            detail: "Provider was temporarily unavailable.",
          }),
        ),
    });

    await harness.drain();

    const readModel = await harness.readModel();
    const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
    expect(thread?.session).toMatchObject({
      status: "error",
      lastError: expect.stringContaining("Use Resume to continue"),
    });
    expect(thread?.latestTurn?.state).toBe("error");
  });

  it.each(["approval", "user-input"] as const)(
    "expires a stale pending %s before automatic restart recovery",
    async (requestKind) => {
      const harness = await createHarness({
        runningTurnBeforeReactor: true,
        pendingRequestBeforeReactor: requestKind,
      });

      await harness.drain();

      const readModel = await harness.readModel();
      const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
      expect(thread?.activities).toContainEqual(
        expect.objectContaining({
          kind: requestKind === "approval" ? "approval.resolved" : "user-input.resolved",
          payload: expect.objectContaining({
            requestId: `${requestKind}-before-restart`,
            outcome: "interrupted",
          }),
        }),
      );
      expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
        input: expect.stringContaining("server restarted"),
      });
    },
  );

  it("resumes an errored turn without adding or replaying a user message", async () => {
    const harness = await createHarness();
    const now = "2026-01-01T00:00:00.000Z";
    await harness.runEffect(
      harness.engine.dispatch({
        type: "thread.turn.start",
        commandId: CommandId.make("cmd-turn-before-manual-resume"),
        threadId: ThreadId.make("thread-1"),
        message: {
          messageId: asMessageId("user-message-before-manual-resume"),
          role: "user",
          text: "finish the migration",
          attachments: [],
        },
        interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
        runtimeMode: "approval-required",
        createdAt: now,
      }),
    );
    await harness.drain();
    await harness.runEffect(
      harness.engine.dispatch({
        type: "thread.session.set",
        commandId: CommandId.make("cmd-running-before-manual-resume"),
        threadId: ThreadId.make("thread-1"),
        session: {
          threadId: ThreadId.make("thread-1"),
          status: "running",
          providerName: "codex",
          providerInstanceId: ProviderInstanceId.make("codex"),
          runtimeMode: "approval-required",
          mcpServerIds: [],
          activeTurnId: asTurnId("turn-before-manual-resume"),
          lastError: null,
          updatedAt: now,
        },
        createdAt: now,
      }),
    );
    await harness.runEffect(
      harness.engine.dispatch({
        type: "thread.session.set",
        commandId: CommandId.make("cmd-error-before-manual-resume"),
        threadId: ThreadId.make("thread-1"),
        session: {
          threadId: ThreadId.make("thread-1"),
          status: "error",
          providerName: "codex",
          providerInstanceId: ProviderInstanceId.make("codex"),
          runtimeMode: "approval-required",
          mcpServerIds: [],
          activeTurnId: null,
          lastError: "Automatic recovery failed.",
          updatedAt: now,
        },
        createdAt: now,
      }),
    );
    harness.sendTurn.mockClear();

    await harness.runEffect(
      harness.engine.dispatch({
        type: "thread.turn.resume",
        commandId: CommandId.make("cmd-manual-resume"),
        threadId: ThreadId.make("thread-1"),
        createdAt: now,
      }),
    );
    await harness.drain();

    expect(harness.sendTurn).toHaveBeenCalledTimes(1);
    expect(harness.sendTurn.mock.calls[0]?.[0]).toMatchObject({
      threadId: ThreadId.make("thread-1"),
      input: expect.stringContaining("Resume the interrupted request"),
    });
    expect(harness.sendTurn.mock.calls[0]?.[0]).not.toMatchObject({
      input: "finish the migration",
    });
    const readModel = await harness.readModel();
    const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
    expect(thread?.messages.filter((message) => message.role === "user")).toHaveLength(1);
  });
});