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.

5.0 KB
Raw Blame
import * as NodeFS from "node:fs";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import {
  AkeruMemoryTenantId,
  AkeruMemoryUserId,
  BotId,
  ProviderDriverKind,
  ProjectId,
  type AkeruDelegationAccessGrant,
} 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 Scope from "effect/Scope";
import { describe, expect, vi } from "vite-plus/test";
import { BotMemoryStore } from "../../memory/BotMemory.ts";
import { AgentController } from "../Services/AgentController.ts";
import { type AgentControllerLiveOptions } from "./AgentController.ts";
import {
  codexThreadId,
  codexInstanceId,
  codexSelection,
} from "./test-support/agentControllerFixtures.ts";
import { makeBridge, makeLayer, resolveCodex } from "./test-support/agentControllerLayers.ts";
import { mastraHarnessFixture } from "./test-support/agentControllerHarness.ts";

describe("AgentControllerLive", () => {
  it.effect("keeps the memory tool for a delegated turn granted memory scopes", () => {
    const bridge = makeBridge();
    const mastra = mastraHarnessFixture();
    const memoryDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-delegated-grant-"));
    const botMemoryStore = new BotMemoryStore(memoryDir);

    const access: AkeruDelegationAccessGrant = {
      allowedToolIds: ["Read"],
      memoryScopes: ["bot"],
      sandbox: "local",
      runtimeMode: "approval-required",
      hasUserComputer: false,
      enabledMcpServerIds: [],
      disabledMcpServerIds: [],
      approvalCeiling: "send",
    };

    const runtime = {
      send: vi.fn(async () => {
        throw new Error("not used");
      }),
      sendToUser: vi.fn(async () => {
        throw new Error("not used");
      }),
      parentFinished: vi.fn(async () => undefined),
      accessForThread: () => access,
    };

    const layer = makeLayer(
      bridge.service,
      mastra.factory,
      undefined,
      undefined,
      undefined,
      { botMemoryStore },
      runtime,
    );

    const memoryToolIds = () =>
      mastra.harnessOptions[0]?.toolRuntime
        .toolsForThread(String(codexThreadId))
        .map((tool) => tool.id)
        .filter((id) => id === "memory");

    return Effect.gen(function* () {
      const controller = yield* AgentController;
      yield* resolveCodex(controller);
      yield* controller.startSession(codexThreadId, {
        threadId: codexThreadId,
        provider: ProviderDriverKind.make("codex"),
        providerInstanceId: codexInstanceId,
        cwd: process.cwd(),
        modelSelection: codexSelection,
        runtimeMode: "approval-required",
        memoryAccess: {
          tenantId: AkeruMemoryTenantId.make("local"),
          userId: AkeruMemoryUserId.make("owner"),
          threadId: codexThreadId,
          projectId: ProjectId.make("delegation-memory-grant"),
          workspaceRoot: process.cwd(),
          botId: BotId.make("delegated-bot"),
          respondingBotId: BotId.make("delegated-bot"),
          groupId: null,
          groupMemberBotIds: [],
        },
      });
      expect(memoryToolIds()).toEqual(["memory"]);
      yield* controller.sendTurn({ threadId: codexThreadId, input: "Do the delegated task." });
      expect(mastra.session.sendMessage).toHaveBeenCalled();
      // Admission runs the turn without durable memory but keeps the granted tool.
      expect(memoryToolIds()).toEqual(["memory"]);
      expect(mastra.session.state.get()).not.toHaveProperty("persistentMemoryContext");
    }).pipe(
      Effect.provide(layer),
      Effect.orDie,
      Effect.ensuring(
        Effect.sync(() => NodeFS.rmSync(memoryDir, { recursive: true, force: true })),
      ),
    );
  });
});

describe("AgentControllerLive", () => {
  it.effect("waits for observational memory shutdown before closing the controller scope", () => {
    const bridge = makeBridge();
    const mastra = mastraHarnessFixture();
    const destroyStarted = Promise.withResolvers<void>();
    const destroyReleased = Promise.withResolvers<void>();

    const factory: NonNullable<AgentControllerLiveOptions["makeMastraHarness"]> = (options) =>
      Effect.acquireRelease(mastra.factory(options), () =>
        Effect.promise(async () => {
          destroyStarted.resolve();
          await destroyReleased.promise;
        }),
      );

    return Effect.gen(function* () {
      const scope = yield* Scope.make("sequential");
      yield* Layer.buildWithScope(makeLayer(bridge.service, factory), scope);
      let scopeClosed = false;

      const closeScope = yield* Scope.close(scope, Exit.void).pipe(
        Effect.tap(() => Effect.sync(() => (scopeClosed = true))),
        Effect.forkScoped,
      );

      yield* Effect.promise(() => destroyStarted.promise);
      yield* Effect.yieldNow;
      expect(scopeClosed).toBe(false);

      destroyReleased.resolve();
      yield* Fiber.join(closeScope);
      expect(scopeClosed).toBe(true);
    });
  });
});