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.1 KB
Raw Blame
import * as NodeServices from "@effect/platform-node/NodeServices";
import { BotId, TurnId, type OrchestrationCommand } from "@akeru/contracts";
import type { AkeruUsageEntry } from "@akeru/contracts";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import { ServerConfig } from "../../../config.ts";
import { layerTest as serverSettingsLayerTest } from "../../../serverSettings.ts";
import {
  layerWith as imageGenerationRuntimeLayerWith,
  type ImageSubscriptionAuth,
} from "../../../image-generation/ImageGenerationRuntime.ts";
import { type ImageProviderAdapter } from "../../../image-generation/adapters.ts";
import * as ProjectionSnapshotQuery from "../../../orchestration/Services/ProjectionSnapshotQuery.ts";
import { ProjectionBotRepository } from "../../../persistence/Services/ProjectionBots.ts";
import { ProjectionThreadMessageRepository } from "../../../persistence/Services/ProjectionThreadMessages.ts";
import * as OrchestrationEngine from "../../../orchestration/Services/OrchestrationEngine.ts";
import { BotUsageLedger } from "../../../usage/BotUsageLedger.ts";
import { usageLedgerFixture } from "./agentControllerMemory.ts";

export function makeImageRuntimeTestLayer(input: {
  readonly baseDir: string;
  readonly adapters: Readonly<Record<"chatgpt" | "grok", ImageProviderAdapter>>;
  readonly connected: ReadonlyArray<"openai-codex" | "xai">;
  readonly settings: { readonly chatgptEnabled?: boolean; readonly grokEnabled?: boolean };
  readonly botProvider: "chatgpt" | "grok" | null;
  readonly requestTimeout?: Duration.Input;
}) {
  const dispatched: OrchestrationCommand[] = [];
  const imageUsage: Array<unknown> = [];

  const subscriptionAuth: ImageSubscriptionAuth = {
    statuses: () =>
      input.connected.map((provider) => ({
        provider,
        connected: true,
        health: "healthy" as const,
        reconnectAction: "",
        healthTest: { status: "not-run" as const },
        dependentBots: [],
        dependentRoutines: [],
      })),
    recordImageGenerationSuccess: () => undefined,
    recordImageRequestFailure: () => undefined,
  };

  const layer = imageGenerationRuntimeLayerWith({
    adapters: input.adapters,
    subscriptionAuth,
    ...(input.requestTimeout ? { requestTimeout: input.requestTimeout } : {}),
  }).pipe(
    Layer.provideMerge(
      Layer.succeed(
        OrchestrationEngine.OrchestrationEngineService,
        OrchestrationEngine.OrchestrationEngineService.of({
          readEvents: () => Stream.empty,
          readThreadEvents: () => Stream.empty,
          getThreadReplayStats: () => Effect.die("unused"),
          subscribeDomainEvents: Effect.succeed(Stream.empty),
          latestSequence: Effect.succeed(0),
          dispatch: (command) =>
            Effect.sync(() => {
              dispatched.push(command);

              return { sequence: dispatched.length };
            }),
          streamDomainEvents: Stream.empty,
        }),
      ),
    ),
    Layer.provideMerge(
      Layer.succeed(ProjectionSnapshotQuery.ProjectionSnapshotQuery, {
        getThreadShellById: () =>
          Effect.succeed(
            Option.some({
              latestTurn: {
                state: "running",
                turnId: TurnId.make("turn-image"),
                respondingBotId: BotId.make("bot-image"),
                requestedAt: "2026-01-01T00:00:00.000Z",
                startedAt: null,
                completedAt: null,
                assistantMessageId: null,
              },
              respondingBotId: BotId.make("bot-image"),
              botId: BotId.make("bot-image"),
            }),
          ),
      } as never),
    ),
    Layer.provideMerge(
      Layer.succeed(ProjectionBotRepository, {
        getById: () =>
          Effect.succeed(
            Option.some({ id: BotId.make("bot-image"), imageProvider: input.botProvider }),
          ),
      } as never),
    ),
    Layer.provideMerge(
      Layer.succeed(ProjectionThreadMessageRepository, {
        listByThreadId: () => Effect.succeed([]),
      } as never),
    ),
    Layer.provideMerge(serverSettingsLayerTest({ imageGeneration: input.settings })),
    Layer.provideMerge(
      Layer.succeed(
        BotUsageLedger,
        BotUsageLedger.of({
          ...usageLedgerFixture().service,
          recordMeasurement: (measurement) =>
            Effect.sync(() => {
              imageUsage.push(measurement);

              return {
                ...measurement,
                state: "reported",
                reservedTokens: 0,
                unavailableReason: null,
                settledAt: measurement.createdAt,
              } as AkeruUsageEntry;
            }),
        }),
      ),
    ),
    Layer.provideMerge(Layer.succeed(SqlClient.SqlClient, {} as never)),
    Layer.provideMerge(ServerConfig.layerTest(process.cwd(), input.baseDir)),
    Layer.provideMerge(NodeServices.layer),
  );

  return { layer, dispatched, imageUsage };
}