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.9 KB
Raw Blame
import { assert, it } from "@effect/vitest";
import {
  AKERU_TOOL_CATALOG,
  AKERU_WORKER_TIMEOUT_MS,
  type AkeruDelegationAccessGrant,
  type AkeruWorkerId,
  type AkeruWorkerStatus,
  ThreadId,
  TurnId,
} from "@akeru/contracts";
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Queue from "effect/Queue";
import * as TestClock from "effect/testing/TestClock";

import {
  AkeruWorkerError,
  type AkeruWorkerParent,
  type AkeruWorkerPort,
  makeAkeruWorkerRuntime,
} from "./AkeruWorkerRuntime.ts";

const access: AkeruDelegationAccessGrant = {
  allowedToolIds: AKERU_TOOL_CATALOG.map((tool) => tool.id),
  memoryScopes: ["private", "bot"],
  sandbox: null,
  runtimeMode: "full-access",
  hasUserComputer: true,
  enabledMcpServerIds: [],
  disabledMcpServerIds: [],
  approvalCeiling: "secrets",
};

const parent: AkeruWorkerParent = {
  threadId: ThreadId.make("parent-thread"),
  turnId: TurnId.make("parent-turn"),
  depth: 0,
  access,
};

/**
 * A fake orchestration port. `turns` receives each child turn as it starts.
 * `failTurns` makes every turn dispatch fail.
 */
const makeHarnessWith = (options?: {
  readonly failTurns?: boolean;
  /** Holds child creation until the deferred completes. */
  readonly createGate?: Deferred.Deferred<void>;
}) =>
  Effect.gen(function* () {
    const turns = yield* Queue.unbounded<{
      readonly childThreadId: ThreadId;
      readonly text: string;
    }>();

    const interrupted: ThreadId[] = [];
    const discarded: ThreadId[] = [];
    const discards = yield* Queue.unbounded<ThreadId>();
    let created = 0;
    let ids = 0;

    const port: AkeruWorkerPort = {
      createChild: () =>
        (options?.createGate ? Deferred.await(options.createGate) : Effect.void).pipe(
          Effect.andThen(Effect.sync(() => ThreadId.make(`child-${++created}`))),
        ),
      messageChild: (childThreadId, text) =>
        options?.failTurns
          ? Effect.fail(new AkeruWorkerError({ reason: "start_failed", detail: "rejected" }))
          : Effect.asVoid(Queue.offer(turns, { childThreadId, text })),
      interruptChild: (childThreadId) => Effect.sync(() => void interrupted.push(childThreadId)),
      discardChild: (childThreadId) =>
        Effect.sync(() => void discarded.push(childThreadId)).pipe(
          Effect.andThen(Queue.offer(discards, childThreadId)),
          Effect.asVoid,
        ),
    };

    const runtime = yield* makeAkeruWorkerRuntime(port, { makeId: () => String(++ids) });

    return { runtime, turns, interrupted, discarded, discards };
  });

const makeHarness = makeHarnessWith();

const phaseOf = (status: AkeruWorkerStatus) => status.phase._tag;

it.effect("returns the worker result and runs the child with a narrowed grant", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns } = yield* makeHarness;

      const spawned = yield* Effect.forkChild(
        runtime.spawn(parent, { task: "Summarize the README", expectedResult: "Three bullets" }),
      );

      const turn = yield* Queue.take(turns);
      assert.include(turn.text, "Task: Summarize the README");
      assert.include(turn.text, "Expected result: Three bullets");

      const childAccess = runtime.accessForThread(turn.childThreadId);
      assert.isDefined(childAccess);
      assert.deepStrictEqual(childAccess!.memoryScopes, []);
      assert.strictEqual(childAccess!.approvalCeiling, "none");
      // A null sandbox stays without a workspace; top-level callers pass `local` explicitly.
      assert.strictEqual(childAccess!.sandbox, null);
      assert.isFalse(childAccess!.hasUserComputer);
      assert.notInclude(childAccess!.allowedToolIds, "Task");
      assert.notInclude(childAccess!.allowedToolIds, "SendToAgent");
      assert.notInclude(childAccess!.allowedToolIds, "request_box_help");
      assert.notInclude(childAccess!.allowedToolIds, "ReactToMessage");
      assert.include(childAccess!.allowedToolIds, "Read");
      assert.strictEqual(runtime.depthForThread(turn.childThreadId), 1);
      assert.strictEqual(runtime.depthForThread(parent.threadId), 0);
      // A worker chat left over from before a restart still counts as a worker.
      assert.strictEqual(runtime.depthForThread(ThreadId.make("worker-thread-orphaned")), 1);

      yield* runtime.childTurnFinished(turn.childThreadId, {
        state: "completed",
        summary: "  done  ",
      });
      const status = yield* Fiber.join(spawned);
      assert.strictEqual(status.workerId, "worker-1");
      assert.deepInclude(status.phase, {
        _tag: "Completed",
        childThreadId: turn.childThreadId,
        result: "done",
      });
    }),
  ),
);

it.effect("reports a failed child turn as Failed", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns } = yield* makeHarness;
      const running = yield* runtime.spawn(parent, { task: "Break", background: true });
      const turn = yield* Queue.take(turns);
      yield* runtime.childTurnFinished(turn.childThreadId, { state: "failed", error: "boom" });
      const status = yield* runtime.check(parent, { workerId: running.workerId, wait: true });
      assert.deepInclude(status.phase, {
        _tag: "Failed",
        failureCode: "worker_failed",
        message: "boom",
      });
    }),
  ),
);

it.effect("discards the hidden child when its first turn cannot start", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, discarded } = yield* makeHarnessWith({ failTurns: true });
      const status = yield* runtime.spawn(parent, { task: "Never starts" });
      assert.deepInclude(status.phase, {
        _tag: "Failed",
        childThreadId: ThreadId.make("child-1"),
        failureCode: "internal",
        message: "rejected",
      });
      assert.deepStrictEqual(discarded, [ThreadId.make("child-1")]);
      assert.isUndefined(runtime.accessForThread(ThreadId.make("child-1")));
    }),
  ),
);

it.effect("refuses to start workers from a worker", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime } = yield* makeHarness;

      const error = yield* Effect.flip(
        runtime.spawn({ ...parent, depth: 1 }, { task: "Nested", background: true }),
      );

      assert.strictEqual(error.reason, "depth_limit");
      assert.strictEqual(error.message, "Temporary workers cannot start other workers.");
    }),
  ),
);

it.effect("limits running workers per turn and frees a slot when one stops", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime } = yield* makeHarness;
      const first = yield* runtime.spawn(parent, { task: "One", background: true });
      yield* runtime.spawn(parent, { task: "Two", background: true });
      yield* runtime.spawn(parent, { task: "Three", background: true });
      const error = yield* Effect.flip(runtime.spawn(parent, { task: "Four", background: true }));
      assert.strictEqual(error.reason, "concurrency_limit");
      assert.include(error.message, "3 running workers");

      const otherParent = { ...parent, threadId: ThreadId.make("other-thread") };
      yield* runtime.spawn(otherParent, { task: "Elsewhere", background: true });

      yield* runtime.stop(parent, { workerId: first.workerId });
      const fourth = yield* runtime.spawn(parent, { task: "Four", background: true });
      assert.strictEqual(phaseOf(fourth), "Running");
    }),
  ),
);

it.effect("sends follow-ups and completes after the last open turn", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns } = yield* makeHarness;
      const running = yield* runtime.spawn(parent, { task: "Draft", background: true });
      const first = yield* Queue.take(turns);

      const messaged = yield* runtime.message(parent, {
        workerId: running.workerId,
        message: "Also add a title",
      });

      assert.strictEqual(phaseOf(messaged), "Running");
      const followUp = yield* Queue.take(turns);
      assert.deepStrictEqual(followUp, {
        childThreadId: first.childThreadId,
        text: "Also add a title",
      });

      yield* runtime.childTurnFinished(first.childThreadId, {
        state: "completed",
        summary: "draft",
      });
      const between = yield* runtime.check(parent, { workerId: running.workerId });
      assert.strictEqual(phaseOf(between), "Running");

      yield* runtime.childTurnFinished(first.childThreadId, {
        state: "completed",
        summary: "draft with title",
      });
      const done = yield* runtime.check(parent, { workerId: running.workerId, wait: true });
      assert.deepInclude(done.phase, { _tag: "Completed", result: "draft with title" });

      const error = yield* Effect.flip(
        runtime.message(parent, { workerId: running.workerId, message: "More" }),
      );

      assert.strictEqual(error.reason, "not_running");
    }),
  ),
);

it.effect("stops a worker, interrupts its child, and reports Canceled", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns, interrupted } = yield* makeHarness;
      const running = yield* runtime.spawn(parent, { task: "Long job", background: true });
      const turn = yield* Queue.take(turns);

      const stopped = yield* runtime.stop(parent, { workerId: running.workerId });
      assert.deepInclude(stopped.phase, { _tag: "Canceled", canceledBy: "stop" });
      assert.deepStrictEqual(interrupted, [turn.childThreadId]);

      const checked = yield* runtime.check(parent, { workerId: running.workerId });
      assert.deepInclude(checked.phase, { _tag: "Canceled", canceledBy: "stop" });

      // A late child result cannot resurrect a canceled worker.
      yield* runtime.childTurnFinished(turn.childThreadId, { state: "completed", summary: "x" });
      const again = yield* runtime.stop(parent, { workerId: running.workerId });
      assert.strictEqual(phaseOf(again), "Canceled");
      assert.deepStrictEqual(interrupted, [turn.childThreadId]);
    }),
  ),
);

it.effect("cancels every running worker when the parent turn ends", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns, interrupted } = yield* makeHarness;
      const background = yield* runtime.spawn(parent, { task: "Background", background: true });
      const foreground = yield* Effect.forkChild(runtime.spawn(parent, { task: "Foreground" }));
      const firstTurn = yield* Queue.take(turns);
      const secondTurn = yield* Queue.take(turns);

      yield* runtime.parentTurnEnded(parent.threadId);

      const waited = yield* Fiber.join(foreground);
      assert.deepInclude(waited.phase, { _tag: "Canceled", canceledBy: "parent-turn-ended" });
      const checked = yield* runtime.check(parent, { workerId: background.workerId });
      assert.deepInclude(checked.phase, { _tag: "Canceled", canceledBy: "parent-turn-ended" });
      assert.sameMembers(interrupted, [firstTurn.childThreadId, secondTurn.childThreadId]);
    }),
  ),
);

it.effect("fails a worker that outlives its deadline", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns, interrupted } = yield* makeHarness;
      const running = yield* runtime.spawn(parent, { task: "Slow", background: true });
      const turn = yield* Queue.take(turns);
      yield* TestClock.adjust(Duration.millis(AKERU_WORKER_TIMEOUT_MS));
      const status = yield* runtime.check(parent, { workerId: running.workerId, wait: true });
      assert.deepInclude(status.phase, { _tag: "Failed", failureCode: "timeout" });
      assert.deepStrictEqual(interrupted, [turn.childThreadId]);
    }),
  ).pipe(Effect.provide(TestClock.layer())),
);

it.effect("hides workers from other chats", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime } = yield* makeHarness;
      const running = yield* runtime.spawn(parent, { task: "Mine", background: true });

      const error = yield* Effect.flip(
        runtime.check(
          { threadId: ThreadId.make("other-thread") },
          { workerId: running.workerId as AkeruWorkerId },
        ),
      );

      assert.strictEqual(error.reason, "not_found");
    }),
  ),
);

it.effect("discards the child of a worker stopped while the child was created", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const createGate = yield* Deferred.make<void>();
      const { runtime, turns, discarded, discards } = yield* makeHarnessWith({ createGate });
      const running = yield* runtime.spawn(parent, { task: "Early stop", background: true });
      // Stop answers while child creation is still stalled.
      const stopped = yield* runtime.stop(parent, { workerId: running.workerId });
      assert.strictEqual(phaseOf(stopped), "Canceled");
      yield* Deferred.succeed(createGate, undefined);
      assert.strictEqual(yield* Queue.take(discards), ThreadId.make("child-1"));
      assert.deepStrictEqual(discarded, [ThreadId.make("child-1")]);
      assert.strictEqual(yield* Queue.size(turns), 0);
    }),
  ),
);

it.effect("keeps workers of a newer turn when an earlier turn ends", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns } = yield* makeHarness;

      const running = yield* runtime.spawn(
        { ...parent, turnId: TurnId.make("next-turn") },
        { task: "Next turn work", background: true },
      );

      yield* Queue.take(turns);
      yield* runtime.parentTurnEnded(parent.threadId, parent.turnId);
      const checked = yield* runtime.check(parent, { workerId: running.workerId });
      assert.strictEqual(phaseOf(checked), "Running");
    }),
  ),
);

it.effect("forgets settled workers of earlier turns when a new turn starts one", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns } = yield* makeHarness;
      const earlier = yield* runtime.spawn(parent, { task: "Earlier", background: true });
      const earlierTurn = yield* Queue.take(turns);
      yield* runtime.parentTurnEnded(parent.threadId, parent.turnId);

      yield* runtime.spawn(
        { ...parent, turnId: TurnId.make("next-turn") },
        { task: "Next turn work", background: true },
      );
      yield* Queue.take(turns);
      const error = yield* Effect.flip(runtime.check(parent, { workerId: earlier.workerId }));
      assert.strictEqual(error.reason, "not_found");
      // The earlier child thread still counts as a worker with the worker grant.
      assert.strictEqual(
        runtime.accessForThread(earlierTurn.childThreadId)?.approvalCeiling,
        "none",
      );
      assert.strictEqual(runtime.depthForThread(earlierTurn.childThreadId), 1);
    }),
  ),
);

it.effect("lets a queued follow-up answer after an earlier turn fails", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns } = yield* makeHarness;
      const running = yield* runtime.spawn(parent, { task: "Retry", background: true });
      const first = yield* Queue.take(turns);
      yield* runtime.message(parent, { workerId: running.workerId, message: "Try again" });
      yield* Queue.take(turns);
      yield* runtime.childTurnFinished(first.childThreadId, { state: "failed", error: "boom" });
      const between = yield* runtime.check(parent, { workerId: running.workerId });
      assert.strictEqual(phaseOf(between), "Running");
      yield* runtime.childTurnFinished(first.childThreadId, {
        state: "completed",
        summary: "fixed",
      });
      const done = yield* runtime.check(parent, { workerId: running.workerId, wait: true });
      assert.deepInclude(done.phase, { _tag: "Completed", result: "fixed" });
    }),
  ),
);

it.effect("keeps the worker grant on a child after its parent session is released", () =>
  Effect.scoped(
    Effect.gen(function* () {
      const { runtime, turns } = yield* makeHarness;
      yield* runtime.spawn(parent, { task: "Released", background: true });
      const turn = yield* Queue.take(turns);
      yield* runtime.releaseThread(parent.threadId);
      assert.strictEqual(runtime.accessForThread(turn.childThreadId)?.approvalCeiling, "none");
      assert.strictEqual(runtime.depthForThread(turn.childThreadId), 1);
    }),
  ),
);