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.

17.5 KB
Raw Blame
import { emptyProviderSnapshot, providerThreadFixture } from "./projectionFixtures.ts";
import { sessionFixture } from "./partialFixtures.ts";
import type { AkeruMastraState } from "../../AkeruMastraHarness.ts";

import * as Match from "effect/Match";
import * as NodeServices from "@effect/platform-node/NodeServices";
import type { AgentControllerEvent, Session } from "@mastra/core/agent-controller";
import {
  BotId,
  GroupId,
  McpServerId,
  ProviderDriverKind,
  ProviderInstanceId,
  ProjectId,
  ThreadId,
  TurnId,
  type McpServer,
  type OrchestrationReadModel,
  type ProviderRuntimeEvent,
  type ProviderSession,
} from "@akeru/contracts";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Stream from "effect/Stream";
import { assert, vi } from "vite-plus/test";
import { ServerConfig } from "../../../config.ts";
import {
  ServerSettingsService,
  layerTest as serverSettingsLayerTest,
} from "../../../serverSettings.ts";
import { EntityMemoryRepository } from "../../../memory/Services/EntityMemoryRepository.ts";
import { AgentController } from "../../Services/AgentController.ts";
import { ProviderValidationError } from "../../Errors.ts";
import { LegacyProviderBridge } from "../../Services/LegacyProviderBridge.ts";
import type { ProviderServiceShape } from "../../Services/ProviderService.ts";
import { agentControllerLayerWith, type AgentControllerLiveOptions } from "../AgentController.ts";
import {
  RoutineDraftDispatcher,
  type RoutineDraftDispatcherShape,
} from "../../../routines/RoutineDraftDispatcher.ts";
import { BotUsageLedger, type BotUsageLedgerShape } from "../../../usage/BotUsageLedger.ts";
import {
  codexThreadId,
  claudeThreadId,
  grokThreadId,
  kimiThreadId,
  openCodeGoThreadId,
  codexInstanceId,
  claudeInstanceId,
  grokInstanceId,
  kimiInstanceId,
  openCodeGoInstanceId,
  codexSelection,
  instanceModelCatalog,
} from "./agentControllerFixtures.ts";
import { usageLedgerFixture } from "./agentControllerMemory.ts";
import { mastraHarnessFixture } from "./agentControllerHarness.ts";

export function makeProviderSession(
  threadId: ThreadId,
  provider: "codex" | "claudeAgent" | "opencode",
): ProviderSession {
  return {
    provider: ProviderDriverKind.make(provider),
    providerInstanceId: ProviderInstanceId.make(provider),
    threadId,
    status: "ready",
    runtimeMode: "full-access",
    model: Match.value(provider).pipe(
      Match.when("codex", () => "gpt-5.6-sol" as const),
      Match.when("opencode", () => "anthropic/claude-sonnet-4-5" as const),
      Match.orElse(() => "claude-fable-5" as const),
    ),
    createdAt: "2026-01-01T00:00:00.000Z",
    updatedAt: "2026-01-01T00:00:00.000Z",
  };
}

export function makeInstanceSnapshot(
  instanceId: ProviderInstanceId,
  driverKind: ProviderDriverKind,
  entry: {
    readonly models: ReadonlyArray<string>;
    readonly status?: "ready" | "warning" | "error";
  },
) {
  return {
    instanceId,
    driver: driverKind,
    enabled: true,
    installed: true,
    version: null,
    status: entry.status ?? ("ready" as const),
    auth: { status: "authenticated" as const },
    checkedAt: "2026-01-01T00:00:00.000Z",
    models: entry.models.map((slug) => ({
      slug,
      name: slug,
      isCustom: false,
      capabilities: null,
    })),
    slashCommands: [],
    skills: [],
  };
}

export function makeBridge() {
  instanceModelCatalog.clear();
  let instanceEnabled = true;
  let disableBeforeNextDispatchAdmission = false;
  let nextDispatchAdmissionWait: Promise<void> | undefined;
  let releaseNextDispatchAdmission: (() => void) | undefined;
  let nextDispatchAdmissionReached = Promise.resolve();
  let markNextDispatchAdmissionReached: (() => void) | undefined;

  const startSession = vi.fn<ProviderServiceShape["startSession"]>((threadId, input) =>
    Effect.succeed(
      makeProviderSession(
        threadId,
        Match.value(String(input.provider)).pipe(
          Match.when("codex", () => "codex" as const),
          Match.when("opencode", () => "opencode" as const),
          Match.orElse(() => "claudeAgent" as const),
        ),
      ),
    ),
  );

  const sendTurn = vi.fn<ProviderServiceShape["sendTurn"]>((input) =>
    Effect.succeed({ threadId: input.threadId, turnId: TurnId.make("legacy-turn") }),
  );

  const interruptTurn = vi.fn<ProviderServiceShape["interruptTurn"]>(() => Effect.void);
  const respondToRequest = vi.fn<ProviderServiceShape["respondToRequest"]>(() => Effect.void);
  const respondToUserInput = vi.fn<ProviderServiceShape["respondToUserInput"]>(() => Effect.void);
  const stopSession = vi.fn<ProviderServiceShape["stopSession"]>(() => Effect.void);

  const rollbackConversation = vi.fn<ProviderServiceShape["rollbackConversation"]>(
    () => Effect.void,
  );

  const getCapabilities = vi.fn<ProviderServiceShape["getCapabilities"]>(() =>
    Effect.succeed({ sessionModelSwitch: "in-session" }),
  );

  const service: ProviderServiceShape = {
    startSession,
    sendTurn,
    interruptTurn,
    respondToRequest,
    respondToUserInput,
    stopSession,
    rollbackConversation,
    listSessions: () => Effect.succeed([]),
    getCapabilities,
    getInstanceInfo: (instanceId) =>
      Effect.sync(() => {
        const driverKind = ProviderDriverKind.make(
          instanceId === kimiInstanceId ? "kimi" : String(instanceId),
        );

        const advertisedModels = instanceModelCatalog.get(String(instanceId));

        return {
          instanceId,
          driverKind,
          displayName: undefined,
          enabled: instanceEnabled,
          continuationIdentity: {
            driverKind,
            continuationKey: `${driverKind}:instance:${instanceId}`,
          },
          ...(advertisedModels !== undefined
            ? {
                instanceSnapshot: makeInstanceSnapshot(instanceId, driverKind, advertisedModels),
              }
            : {}),
        };
      }),
    dispatchIfEnabled: (instanceId, operation, dispatch) => {
      const dispatchNow = () => {
        if (disableBeforeNextDispatchAdmission) {
          disableBeforeNextDispatchAdmission = false;
          instanceEnabled = false;
        }

        return instanceEnabled
          ? Effect.sync(dispatch)
          : Effect.fail(
              new ProviderValidationError({
                operation,
                issue: `Provider instance '${instanceId}' is disabled in Akeru Bot settings.`,
              }),
            );
      };

      return Effect.suspend(() => {
        const wait = nextDispatchAdmissionWait;
        nextDispatchAdmissionWait = undefined;
        markNextDispatchAdmissionReached?.();
        markNextDispatchAdmissionReached = undefined;

        return wait ? Effect.promise(() => wait).pipe(Effect.flatMap(dispatchNow)) : dispatchNow();
      });
    },
    uploadFeedback: (input) => Effect.succeed({ feedbackId: `feedback-${String(input.threadId)}` }),
    streamEvents: Stream.empty,
  };

  return {
    service,
    startSession,
    sendTurn,
    interruptTurn,
    respondToRequest,
    respondToUserInput,
    stopSession,
    rollbackConversation,
    getCapabilities,
    setInstanceEnabled: (enabled: boolean) => {
      instanceEnabled = enabled;
    },
    disableBeforeNextDispatchAdmission: () => {
      disableBeforeNextDispatchAdmission = true;
    },
    blockNextDispatchAdmission: () => {
      nextDispatchAdmissionWait = new Promise<void>((resolve) => {
        releaseNextDispatchAdmission = resolve;
      });
      nextDispatchAdmissionReached = new Promise<void>((resolve) => {
        markNextDispatchAdmissionReached = resolve;
      });
    },
    waitForNextDispatchAdmission: () => nextDispatchAdmissionReached,
    releaseNextDispatchAdmission: () => {
      releaseNextDispatchAdmission?.();
      releaseNextDispatchAdmission = undefined;
    },
  };
}

export function makeLayer(
  bridge: ProviderServiceShape,
  factory: NonNullable<AgentControllerLiveOptions["makeMastraHarness"]>,
  makeMcpManager?: NonNullable<AgentControllerLiveOptions["makeMcpManager"]>,
  baseDir?: string,
  usageLedger: BotUsageLedgerShape = usageLedgerFixture().service,
  overrides?: Pick<
    AgentControllerLiveOptions,
    | "resolveComputerUseServer"
    | "entityMemoryRepository"
    | "issueMcpCredential"
    | "revokeMcpCredential"
    | "makeBotBrowser"
    | "botMemoryStore"
    | "webFetch"
    | "generateImage"
    | "readAttachment"
  >,
  delegationRuntime?: AgentControllerLiveOptions["delegationRuntime"],
  settingsOverrides?: Parameters<typeof serverSettingsLayerTest>[0],
  settingsLayer?: Layer.Layer<ServerSettingsService>,
) {
  return agentControllerLayerWith({
    makeMastraHarness: factory,
    ...(makeMcpManager ? { makeMcpManager } : {}),
    ...overrides,
    ...(delegationRuntime ? { delegationRuntime } : {}),
    makeBotBrowser:
      overrides?.makeBotBrowser ??
      (() => ({
        tools: {},
        attachment: async () => undefined,
        reconnect: async () => undefined,
        close: async () => undefined,
      })),
  }).pipe(
    Layer.provideMerge(
      Layer.mergeAll(
        Layer.succeed(LegacyProviderBridge, bridge),
        Layer.succeed(BotUsageLedger, usageLedger),
        Layer.mock(EntityMemoryRepository)({}),
        settingsLayer ?? serverSettingsLayerTest(settingsOverrides ?? {}),
        ServerConfig.layerTest(
          process.cwd(),
          baseDir ?? { prefix: "akeru-mastra-controller-test-" },
        ).pipe(Layer.provide(NodeServices.layer)),
        NodeServices.layer,
      ),
    ),
  );
}

export function provideController<A, E>(
  effect: Effect.Effect<
    A,
    E,
    AgentController | ServerSettingsService | FileSystem.FileSystem | Path.Path
  >,
  bridge: ProviderServiceShape,
  factory: NonNullable<AgentControllerLiveOptions["makeMastraHarness"]>,
  makeMcpManager?: NonNullable<AgentControllerLiveOptions["makeMcpManager"]>,
  baseDir?: string,
  usageLedger?: BotUsageLedgerShape,
  overrides?: Pick<
    AgentControllerLiveOptions,
    | "resolveComputerUseServer"
    | "entityMemoryRepository"
    | "issueMcpCredential"
    | "revokeMcpCredential"
    | "makeBotBrowser"
    | "botMemoryStore"
    | "webFetch"
    | "generateImage"
    | "readAttachment"
  >,
  settingsOverrides?: Parameters<typeof serverSettingsLayerTest>[0],
  settingsLayer?: Layer.Layer<ServerSettingsService>,
) {
  return effect.pipe(
    Effect.provide(
      makeLayer(
        bridge,
        factory,
        makeMcpManager,
        baseDir,
        usageLedger,
        overrides,
        undefined,
        settingsOverrides,
        settingsLayer,
      ),
    ),
    Effect.orDie,
  );
}

export function resolveCodex(controller: AgentController["Service"]) {
  return controller.resolveEngine({
    threadId: codexThreadId,
    engine: { provider: "codex", model: "gpt-5.6-sol" },
    fallback: codexSelection,
    mode: "default",
    botConversation: true,
  });
}

export const routineInput = {
  name: "Morning summary",
  instructions: "Summarize overnight changes.",
  schedule: { kind: "daily", time: "09:00" },
} as const;

export const openRoutineReview = (
  mastra: ReturnType<typeof mastraHarnessFixture>,
  events: Array<ProviderRuntimeEvent>,
) =>
  Effect.gen(function* () {
    const controller = yield* AgentController;
    yield* resolveCodex(controller);
    yield* controller.startSession(codexThreadId, {
      threadId: codexThreadId,
      provider: ProviderDriverKind.make("codex"),
      providerInstanceId: codexInstanceId,
      modelSelection: codexSelection,
      runtimeMode: "full-access",
    });
    const opened = yield* Deferred.make<string>();
    const nextOpened = yield* Deferred.make<string>();
    let openedCount = 0;
    yield* controller.streamEvents.pipe(
      Stream.runForEach((event) =>
        Effect.sync(() => {
          events.push(event);

          if (event.type === "request.opened" && event.requestId) {
            Deferred.doneUnsafe(
              openedCount++ === 0 ? opened : nextOpened,
              Exit.succeed(String(event.requestId)),
            );
          }
        }),
      ),
      Effect.forkChild({ startImmediately: true }),
    );
    yield* Effect.yieldNow;
    yield* controller.sendTurn({
      threadId: codexThreadId,
      input: "Make a routine.",
      timezone: "UTC",
    });
    const createRoutine = mastra.harnessOptions[0]?.createRoutine;
    assert.isDefined(createRoutine);

    const toolCall = yield* Effect.promise(() =>
      createRoutine(String(codexThreadId), routineInput).then(
        (value) => Exit.succeed(value),
        (cause: unknown) => Exit.fail(cause),
      ),
    ).pipe(Effect.forkChild({ startImmediately: true }));

    const requestId = yield* Deferred.await(opened);

    return { controller, toolCall, requestId, nextOpened };
  });

export const provideRoutineController = <A, E>(
  effect: Effect.Effect<A, E, AgentController | ServerSettingsService>,
  mastra: ReturnType<typeof mastraHarnessFixture>,
  dispatcher: Partial<RoutineDraftDispatcherShape>,
) =>
  effect.pipe(
    Effect.provide(
      makeLayer(makeBridge().service, mastra.factory).pipe(
        Layer.provide(Layer.mock(RoutineDraftDispatcher)(dispatcher)),
      ),
    ),
    Effect.orDie,
  );

export const bossBotId = BotId.make("bot-boss");

export const linearServer: McpServer = {
  id: McpServerId.make("linear"),
  name: "Linear",
  transport: "url",
  url: "https://mcp.example.com/linear",
  enabled: true,
  createdAt: "2026-09-01T00:00:00.000Z",
  updatedAt: "2026-09-01T00:00:00.000Z",
};

export const groupParentSnapshot = {
  ...emptyProviderSnapshot(),
  threads: [
    providerThreadFixture({
      id: codexThreadId,
      projectId: ProjectId.make("project-workers"),
      botId: null,
      groupId: GroupId.make("group-workers"),
      respondingBotId: bossBotId,
      runtimeMode: "approval-required",
      modelSelection: codexSelection,
      branch: null,
      worktreePath: null,
    }),
  ],
  bots: [],
  groups: [],
  delegations: [],
} satisfies OrchestrationReadModel;

export const makeWorkerSession = (base: Session<AkeruMastraState>) => {
  const listeners = new Set<(event: AgentControllerEvent) => void>();

  const session = sessionFixture({
    ...base,
    subscribe: vi.fn((listener: (event: AgentControllerEvent) => void) => {
      listeners.add(listener);

      return () => listeners.delete(listener);
    }),
    sendMessage: vi.fn(() => new Promise<void>(() => undefined)),
    respondToToolApproval: vi.fn(),
  });

  return {
    session,
    emit: (event: AgentControllerEvent) => {
      for (const listener of listeners) listener(event);
    },
  };
};

export const switchCases = [
  {
    provider: "codex",
    threadId: codexThreadId,
    instanceId: codexInstanceId,
    from: "gpt-5.6-sol",
    to: "gpt-5.6-astra",
    wirePrefix: "openai",
  },
  {
    provider: "claudeAgent",
    threadId: claudeThreadId,
    instanceId: claudeInstanceId,
    from: "claude-fable-5",
    to: "claude-opus-4-6",
    wirePrefix: "anthropic",
  },
  {
    provider: "grok",
    threadId: grokThreadId,
    instanceId: grokInstanceId,
    from: "grok-code-fast-1",
    to: "grok-4.20-beta",
    wirePrefix: "xai",
  },
  {
    provider: "opencodeGo",
    threadId: openCodeGoThreadId,
    instanceId: openCodeGoInstanceId,
    from: "gpt-5.6-sol",
    to: "gpt-5.6-luna",
    wirePrefix: "opencode-go",
  },
] as const;

export const kimiModel = (model: string) => ({
  instanceId: kimiInstanceId,
  model,
});

export const kimiStartInput = (
  model: string,
  runtimeMode: "approval-required" | "full-access" = "approval-required",
) =>
  ({
    threadId: kimiThreadId,
    provider: ProviderDriverKind.make("kimi"),
    providerInstanceId: kimiInstanceId,
    cwd: process.cwd(),
    modelSelection: kimiModel(model),
    runtimeMode,
  }) as const;

export const resolveKimi = (controller: AgentController["Service"], model = "k3-256k") =>
  controller.resolveEngine({
    threadId: kimiThreadId,
    engine: { provider: String(kimiInstanceId), model },
    fallback: codexSelection,
    mode: "default",
    botConversation: true,
  });

export const mastraWireCases = [
  {
    provider: ProviderDriverKind.make("codex"),
    threadId: codexThreadId,
    instanceId: codexInstanceId,
    model: "gpt-5.6-sol",
    options: [
      { id: "reasoningEffort", value: "high" },
      { id: "serviceTier", value: "priority" },
    ] as const,
    wireModelId: "openai/gpt-5.6-sol",
    modelOptions: { reasoningEffort: "high", serviceTier: "priority" },
  },
  {
    provider: ProviderDriverKind.make("claudeAgent"),
    threadId: claudeThreadId,
    instanceId: claudeInstanceId,
    model: "claude-opus-4-6",
    options: [{ id: "effort", value: "max" }] as const,
    wireModelId: "anthropic/claude-opus-4-6[1m]",
    modelOptions: undefined,
  },
  {
    provider: ProviderDriverKind.make("grok"),
    threadId: grokThreadId,
    instanceId: grokInstanceId,
    model: "grok-4.20-beta",
    options: undefined,
    wireModelId: "xai/grok-4.20-beta",
    modelOptions: undefined,
  },
  {
    provider: ProviderDriverKind.make("kimi"),
    threadId: kimiThreadId,
    instanceId: kimiInstanceId,
    model: "kimi-for-coding-highspeed",
    options: undefined,
    wireModelId: "kimi-for-coding/kimi-for-coding-highspeed",
    modelOptions: undefined,
  },
  {
    provider: ProviderDriverKind.make("opencodeGo"),
    threadId: openCodeGoThreadId,
    instanceId: openCodeGoInstanceId,
    model: "gpt-5.6-luna",
    options: undefined,
    wireModelId: "opencode-go/gpt-5.6-luna",
    modelOptions: undefined,
  },
] as const;