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.4 KB
Raw Blame
import { DelegationId, type AkeruDelegationRecord } from "@akeru/contracts";
import {
  projectionQueryFixture,
  providerRuntimeContext,
} from "./test-support/projectionFixtures.ts";
import type { AkeruMastraState } from "../AkeruMastraHarness.ts";

import * as NodeFS from "node:fs";
import * as NodePath from "node:path";
import type { MastraDBMessage, Session } from "@mastra/core/agent-controller";
import { MessageId, ProviderDriverKind, ThreadId, TurnId } from "@akeru/contracts";
import { it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import { assert, describe, expect, vi } from "vite-plus/test";
import { ServerConfig } from "../../config.ts";
import { AgentController } from "../Services/AgentController.ts";
import { makeAkeruMastraHarness, type AkeruMastraHarness } from "../AkeruMastraHarness.ts";
import { type AgentControllerLiveOptions } from "./AgentController.ts";
import * as ProjectionSnapshotQuery from "../../orchestration/Services/ProjectionSnapshotQuery.ts";
import {
  ProjectionThreadMessageRepository,
  type ProjectionThreadMessage,
} from "../../persistence/Services/ProjectionThreadMessages.ts";
import {
  ProjectionTurnRepository,
  type ProjectionTurn,
} from "../../persistence/Services/ProjectionTurns.ts";
import {
  codexThreadId,
  kimiThreadId,
  codexInstanceId,
  kimiInstanceId,
  codexSelection,
} from "./test-support/agentControllerFixtures.ts";
import {
  makeBridge,
  makeLayer,
  provideController,
  bossBotId,
  linearServer,
  groupParentSnapshot,
} from "./test-support/agentControllerLayers.ts";
import { mastraHarnessFixture } from "./test-support/agentControllerHarness.ts";

describe("AgentControllerLive", () => {
  it.effect.each(["codex", "kimi"] as const)(
    "restarts %s with only retained turns in the next turn's Mastra context",
    (provider) => {
      const bridge = makeBridge();
      const threadId = provider === "codex" ? codexThreadId : kimiThreadId;

      const selection =
        provider === "codex" ? codexSelection : { instanceId: kimiInstanceId, model: "k3-256k" };

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

      const attachment = {
        type: "image" as const,
        id: `${threadId}-12345678-1234-1234-1234-123456789abc`,
        name: "retained.png",
        mimeType: "image/png",
        sizeBytes: 1,
      };

      const messages: ProjectionThreadMessage[] = [1, 2].flatMap((count) =>
        (["user", "assistant"] as const).map((role) => ({
          messageId: MessageId.make(`${role}-${count}`),
          threadId,
          turnId: role === "user" ? null : TurnId.make(`turn-${count}`),
          role,
          text: `${role} turn ${count}`,
          isStreaming: false,
          createdAt,
          updatedAt: createdAt,
          attachments: count === 1 && role === "user" ? [attachment] : [],
        })),
      );

      const turns: ProjectionTurn[] = [1, 2].map((count) => ({
        threadId,
        turnId: TurnId.make(`turn-${count}`),
        pendingMessageId: MessageId.make(`user-${count}`),
        assistantMessageId: MessageId.make(`assistant-${count}`),
        sourceProposedPlanThreadId: null,
        sourceProposedPlanId: null,
        respondingBotId: null,
        state: "completed",
        requestedAt: createdAt,
        startedAt: createdAt,
        completedAt: createdAt,
        checkpointTurnCount: count,
        checkpointRef: null,
        checkpointStatus: null,
        checkpointFiles: [],
      }));

      const nextContext = Promise.withResolvers<MastraDBMessage[]>();
      const dispatchStarted = Promise.withResolvers<void>();
      const finishDispatch = Promise.withResolvers<void>();
      const dispatchAborted = Promise.withResolvers<void>();
      const sessions: Session<AkeruMastraState>[] = [];
      let harness: AkeruMastraHarness | undefined;
      let failRestart = false;

      const factory: NonNullable<AgentControllerLiveOptions["makeMastraHarness"]> = (options) =>
        Effect.gen(function* () {
          const real = yield* makeAkeruMastraHarness(options);
          harness = real;
          yield* Effect.promise(() =>
            real.rebuildConversation!(
              String(threadId),
              messages.map((message) => ({
                id: String(message.messageId),
                role: message.role,
                content: { format: 2, parts: [{ type: "text", text: message.text }] },
                createdAt: new Date(message.createdAt),
                threadId: String(threadId),
                resourceId: String(threadId),
              })),
            ),
          );

          return {
            ...real,
            observeAfterTurn: async () => undefined,
            controller: {
              ...real.controller,
              init: () => real.controller.init(),
              deleteSession: (input) => real.controller.deleteSession(input),
              createSession: async (input) => {
                if (failRestart) {
                  failRestart = false;
                  throw new Error("Restart failed");
                }

                const session = await real.controller.createSession(input);
                sessions.push(session);

                if (sessions.length === 1) {
                  const abort = session.abort.bind(session);
                  vi.spyOn(session, "abort").mockImplementation(() => {
                    abort();
                    dispatchAborted.resolve();
                  });
                }

                vi.spyOn(session, "sendMessage").mockImplementation(async () => {
                  if (sessions.length === 1) {
                    dispatchStarted.resolve();
                    await finishDispatch.promise;

                    return;
                  }

                  nextContext.resolve(await session.thread.listActiveMessages());
                });

                return session;
              },
            },
          };
        });

      return Effect.gen(function* () {
        const controller = yield* AgentController;
        const config = yield* ServerConfig;
        NodeFS.mkdirSync(config.attachmentsDir, { recursive: true });
        NodeFS.writeFileSync(NodePath.join(config.attachmentsDir, `${attachment.id}.png`), "x");
        yield* controller.resolveEngine({
          threadId,
          engine: null,
          fallback: selection,
          mode: "default",
          botConversation: true,
        });
        yield* controller.startSession(threadId, {
          threadId,
          provider: ProviderDriverKind.make(provider),
          providerInstanceId: selection.instanceId,
          modelSelection: selection,
          runtimeMode: "approval-required",
          cwd: process.cwd(),
        });
        const before = yield* Effect.promise(() => sessions[0]!.thread.listActiveMessages());
        expect(before.map((message) => message.id)).toEqual([
          "user-1",
          "assistant-1",
          "user-2",
          "assistant-2",
        ]);
        yield* Effect.promise(() =>
          harness!.restoreObservationalMemory!(String(threadId), {
            current: {
              id: "discarded-observation",
              generationCount: 1,
              activeObservations: "Facts from discarded turn 2",
              bufferedObservations: "",
              bufferedReflection: null,
              totalTokensObserved: 10,
              observationTokenCount: 2,
              createdAt,
              updatedAt: createdAt,
              originType: "initial",
            },
            history: [],
          }),
        );
        yield* controller.sendTurn({ threadId, input: "Discarded in-flight turn" });
        yield* Effect.promise(() => dispatchStarted.promise);

        const rollback = yield* controller
          .rollbackConversation({ threadId, numTurns: 1 })
          .pipe(Effect.forkChild({ startImmediately: true }));

        yield* Effect.promise(() => dispatchAborted.promise);
        expect(sessions).toHaveLength(1);
        finishDispatch.resolve();
        yield* Fiber.join(rollback);
        expect(
          yield* Effect.promise(() => harness!.readObservationalMemory!(String(threadId))),
        ).toEqual({ current: null, history: [] });
        expect(sessions).toHaveLength(2);
        expect(sessions[1]).not.toBe(sessions[0]);
        yield* controller.sendTurn({ threadId, input: "Next turn" });
        const context = yield* Effect.promise(() => nextContext.promise);
        expect(context.map((message) => message.id)).toEqual(["user-1", "assistant-1"]);
        expect(context[0]?.content.parts).toEqual([
          {
            type: "text",
            text: `user turn 1\n\n[Attached image "retained.png" is saved at: ${NodePath.join(config.attachmentsDir, `${attachment.id}.png`)}]`,
          },
        ]);
        expect(context[0]?.content.experimental_attachments).toEqual([
          {
            name: "retained.png",
            contentType: "image/png",
            url: "data:image/png;base64,eA==",
          },
        ]);
        expect(context[1]?.content.parts).toEqual([{ type: "text", text: "assistant turn 1" }]);
        yield* controller.interruptTurn({ threadId });
        turns.splice(1);
        messages.splice(2);
        failRestart = true;

        const failedRestart = yield* controller
          .rollbackConversation({ threadId, numTurns: 1 })
          .pipe(Effect.exit);

        expect(Exit.isFailure(failedRestart)).toBe(true);
        // The original session reopens without another start request.
        expect(sessions).toHaveLength(3);
        expect(
          (yield* Effect.promise(() => sessions[2]!.thread.listActiveMessages())).map(
            (message) => message.id,
          ),
        ).toEqual(["user-1", "assistant-1"]);
        yield* controller.rollbackConversation({ threadId, numTurns: 1 });
        expect(sessions).toHaveLength(4);
        expect(yield* Effect.promise(() => sessions[3]!.thread.listActiveMessages())).toEqual([]);
        yield* controller.stopSession({ threadId });
        yield* controller.startSession(threadId, {
          threadId,
          modelSelection: selection,
          runtimeMode: "approval-required",
        });
        expect(yield* Effect.promise(() => sessions[4]!.thread.listActiveMessages())).toEqual([]);
        expect(bridge.rollbackConversation).not.toHaveBeenCalled();
      }).pipe(
        Effect.provide(
          makeLayer(bridge.service, factory).pipe(
            Layer.provide(
              Layer.mock(ProjectionThreadMessageRepository)({
                listByThreadId: () => Effect.succeed(messages),
              }),
            ),
            Layer.provide(
              Layer.mock(ProjectionTurnRepository)({
                listByThreadId: () => Effect.succeed(turns),
              }),
            ),
          ),
        ),
      );
    },
  );
});

describe("AgentControllerLive", () => {
  describe("temporary workers", () => {
    it.effect("rebuilds an orphaned worker grant from its delegated parent after a restart", () => {
      const bridge = makeBridge();
      const mastra = mastraHarnessFixture();

      const mcpManager = {
        init: vi.fn(async () => undefined),
        disconnect: vi.fn(async () => undefined),
        getTools: vi.fn(() => ({ linear_update: { mcp: { annotations: {} } } })),
        getServerStatuses: vi.fn(() => []),
      };

      // The worker's parent is a delegated chat limited to Task and WebSearch.
      const delegatedParentThreadId = ThreadId.make("thread-delegated-parent");
      const orphanThreadId = ThreadId.make("worker-thread-restricted");

      const parentDelegation: AkeruDelegationRecord = {
        delegationId: DelegationId.make("delegation-restricted"),
        parentDelegationId: null,
        parentBotId: bossBotId,
        childBotId: bossBotId,
        parentTurnId: TurnId.make("parent-turn"),
        ancestorBotIds: [],
        depth: 1,
        task: "Restricted delegation",
        expectedResult: "Summary",
        deadline: null,
        billedBotId: bossBotId,
        keep: false,
        anchorMessageId: null,
        retryOfDelegationId: null,
        trigger: "bot",
        createdAt: "2026-09-01T00:00:00.000Z",
        updatedAt: "2026-09-01T00:01:00.000Z",
        parentThreadId: codexThreadId,
        phase: {
          _tag: "Completed",
          childThreadId: delegatedParentThreadId,
          childTurnId: null,
          startedAt: "2026-09-01T00:00:00.000Z",
          completedAt: "2026-09-01T00:01:00.000Z",
          result: { summary: "Done.", childThreadId: delegatedParentThreadId, childTurnId: null },
          acknowledgedAt: null,
        },
        access: {
          allowedToolIds: ["Task", "WebSearch"],
          memoryScopes: [],
          sandbox: null,
          runtimeMode: "approval-required",
          hasUserComputer: false,
          enabledMcpServerIds: [],
          disabledMcpServerIds: [],
          approvalCeiling: "none",
        },
      };

      return provideController(
        Effect.gen(function* () {
          const controller = yield* AgentController;
          yield* controller.configureDelegation!({
            readSnapshot: async () => groupParentSnapshot,
            dispatch: async () => ({ sequence: 1 }),
          });
          yield* controller.resolveEngine({
            threadId: orphanThreadId,
            engine: null,
            fallback: codexSelection,
            mode: "default",
            botConversation: true,
          });
          yield* controller.startSession(orphanThreadId, {
            threadId: orphanThreadId,
            provider: ProviderDriverKind.make("codex"),
            providerInstanceId: codexInstanceId,
            cwd: process.cwd(),
            modelSelection: codexSelection,
            runtimeMode: "approval-required",
            botId: bossBotId,
            botName: "Boss",
            mcpServers: [linearServer],
          });
          const runtime = mastra.harnessOptions[0]?.toolRuntime;
          assert.isDefined(runtime);
          const tools = runtime.toolsForThread(String(orphanThreadId)).map((tool) => tool.id);
          expect(tools).toContain("WebSearch");

          for (const toolId of ["Read", "Task", "linear_update"]) {
            expect(tools).not.toContain(toolId);
          }
        }),
        bridge.service,
        mastra.factory,
        () => mcpManager as never,
      ).pipe(
        Effect.provideService(
          ProjectionSnapshotQuery.ProjectionSnapshotQuery,
          ProjectionSnapshotQuery.ProjectionSnapshotQuery.of(
            projectionQueryFixture({
              getThreadRuntimeContext: (threadId: ThreadId) =>
                Effect.succeed(
                  Option.some(
                    providerRuntimeContext(
                      threadId === orphanThreadId
                        ? {
                            id: threadId,
                            botId: bossBotId,
                            parentThreadId: delegatedParentThreadId,
                          }
                        : { id: threadId, botId: bossBotId },
                    ),
                  ),
                ),
              getBotById: () => Effect.succeed(Option.none()),
              getGroupById: () => Effect.succeed(Option.none()),
              listThreadDelegations: (threadId: ThreadId) =>
                Effect.succeed(threadId === delegatedParentThreadId ? [parentDelegation] : []),
            }),
          ),
        ),
      );
    });
  });
});