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.

16.2 KB
Raw Blame
import * as Schema from "effect/Schema";

import {
  createdAt,
  projectId,
  modelSelection,
  PROMPT,
  fakeAdapter,
  fakeSubscriptions,
  testLayer,
  tempBaseDir,
  createBot,
  createProject,
  createBotThread,
  sendUserMessage,
  generatedMessages,
} from "./testUtils/imageGenerationRuntime.ts";
import * as NodeFS from "node:fs";
import { assert, describe, it } from "@effect/vitest";
import { AuthSessionId, BotId, CommandId, GroupId, ThreadId } from "@akeru/contracts";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Scope from "effect/Scope";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import { resolveAttachmentPath } from "../attachmentStore.ts";
import { ServerConfig } from "../config.ts";
import { OrchestrationEngineService } from "../orchestration/Services/OrchestrationEngine.ts";
import { BotUsageLedger } from "../usage/BotUsageLedger.ts";
import { type ImageAdapterRequest } from "./adapters.ts";
import { ImageGenerationRuntime, makeImageGenerationRuntime } from "./ImageGenerationRuntime.ts";
import { base64, pngBytes } from "./testImages.ts";

describe("ImageGenerationRuntime", () => {
  it.effect("reports a partial result when some returned images are unusable", () => {
    const chatgpt = fakeAdapter("chatgpt");
    let call = 0;

    const adapters = {
      chatgpt: {
        ...chatgpt,
        run: (request: ImageAdapterRequest, signal: AbortSignal) => {
          call += 1;

          return call === 1
            ? chatgpt.run(request, signal)
            : Promise.resolve({
                images: [new Uint8Array([1, 2, 3])],
                model: "chatgpt-image-model",
              });
        },
      },
      grok: fakeAdapter("grok"),
    };

    return Effect.gen(function* () {
      const runtime = yield* ImageGenerationRuntime;
      const botId = BotId.make("bot-partial");
      const threadId = ThreadId.make("thread-partial");
      yield* createProject;
      yield* createBot(botId, "claudeAgent", null);
      yield* createBotThread(threadId, botId);
      yield* sendUserMessage(threadId, "partial");

      const result = yield* runtime.generate(threadId, {
        operation: "generate",
        prompt: PROMPT,
        count: 2,
      });

      assert.equal(result.status === "failed" && result.kind, "provider-failed");
      const [message] = yield* generatedMessages(threadId);
      assert.equal(message?.attachments?.length, 1);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });

  it.effect("removes saved images when posting them fails", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt"), grok: fakeAdapter("grok") };

    return Effect.gen(function* () {
      const config = yield* ServerConfig;
      const engine = yield* OrchestrationEngineService;
      const botId = BotId.make("bot-post-fails");
      const threadId = ThreadId.make("thread-post-fails");
      yield* createProject;
      yield* createBot(botId, "claudeAgent", null);
      yield* createBotThread(threadId, botId);
      yield* sendUserMessage(threadId, "post-fails");

      const runtime = yield* makeImageGenerationRuntime({
        adapters,
        subscriptionAuth: fakeSubscriptions(),
      }).pipe(
        Effect.provideService(OrchestrationEngineService, {
          ...engine,
          dispatch: (command) =>
            command.type === "thread.message.assistant.delta"
              ? Effect.die("post failed")
              : engine.dispatch(command),
        }),
      );

      const result = yield* runtime.generate(threadId, { operation: "generate", prompt: PROMPT });

      assert.notEqual(result.status, "completed");

      const saved = NodeFS.existsSync(config.attachmentsDir)
        ? NodeFS.readdirSync(config.attachmentsDir, { recursive: true }).filter((entry) =>
            String(entry).includes("."),
          )
        : [];

      assert.deepEqual(saved, []);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });

  for (const blockedWrite of [1, 2]) {
    it.effect(
      `removes unposted files when interrupted during image ${blockedWrite} persistence`,
      () => {
        const adapters = { chatgpt: fakeAdapter("chatgpt"), grok: fakeAdapter("grok") };

        return Effect.gen(function* () {
          const fs = yield* FileSystem.FileSystem;
          const config = yield* ServerConfig;
          const writing = yield* Deferred.make<Fiber.Fiber<unknown, unknown>>();
          const resume = yield* Deferred.make<void>();
          const botId = BotId.make("bot-persist-cancel");
          const threadId = ThreadId.make("thread-persist-cancel");
          yield* createProject;
          yield* createBot(botId, "claudeAgent", null);
          yield* createBotThread(threadId, botId);

          let writes = 0;

          const runtime = yield* makeImageGenerationRuntime({
            adapters,
            subscriptionAuth: fakeSubscriptions(),
          }).pipe(
            Effect.provideService(FileSystem.FileSystem, {
              ...fs,
              writeFile: (filePath, bytes, options) =>
                Effect.gen(function* () {
                  yield* fs.writeFile(filePath, bytes, options);
                  writes += 1;

                  if (writes === blockedWrite) {
                    yield* Effect.withFiber((fiber) => Deferred.succeed(writing, fiber));
                    yield* Deferred.await(resume);
                  }
                }),
            }),
          );

          const request = yield* runtime
            .generate(threadId, {
              operation: "generate",
              prompt: PROMPT,
              count: 2,
            })
            .pipe(Effect.forkChild);

          const writer = yield* Deferred.await(writing);

          const staged = yield* fs.readDirectory(config.attachmentsDir);

          assert.equal(staged.length, blockedWrite);
          assert.equal(staged.filter((filePath) => filePath.endsWith(".part")).length, 1);
          yield* Effect.sync(() => writer.interruptUnsafe());
          yield* Deferred.succeed(resume, undefined);

          const result = yield* Fiber.join(request);

          assert.equal(result.status === "failed" && result.kind, "cancelled");
          assert.deepEqual(yield* fs.readDirectory(config.attachmentsDir), []);
          assert.equal((yield* generatedMessages(threadId)).length, 0);
        }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
      },
    );
  }

  it.effect("keeps saved images once the message references them", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt"), grok: fakeAdapter("grok") };

    return Effect.gen(function* () {
      const config = yield* ServerConfig;
      const engine = yield* OrchestrationEngineService;
      const botId = BotId.make("bot-complete-fails");
      const threadId = ThreadId.make("thread-complete-fails");
      yield* createProject;
      yield* createBot(botId, "claudeAgent", null);
      yield* createBotThread(threadId, botId);
      yield* sendUserMessage(threadId, "complete-fails");

      const runtime = yield* makeImageGenerationRuntime({
        adapters,
        subscriptionAuth: fakeSubscriptions(),
      }).pipe(
        Effect.provideService(OrchestrationEngineService, {
          ...engine,
          dispatch: (command) =>
            command.type === "thread.message.assistant.complete"
              ? Effect.die("complete failed")
              : engine.dispatch(command),
        }),
      );

      const result = yield* runtime.generate(threadId, { operation: "generate", prompt: PROMPT });

      assert.notEqual(result.status, "completed");

      const saved = NodeFS.existsSync(config.attachmentsDir)
        ? NodeFS.readdirSync(config.attachmentsDir, { recursive: true }).filter((entry) =>
            String(entry).includes("."),
          )
        : [];

      assert.equal(saved.length, 1);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });

  it.effect("rejects input images that are not from the chat", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt"), grok: fakeAdapter("grok") };

    return Effect.gen(function* () {
      const runtime = yield* ImageGenerationRuntime;
      const botId = BotId.make("bot-foreign");
      const threadId = ThreadId.make("thread-foreign");
      yield* createProject;
      yield* createBot(botId, "codex", null);
      yield* createBotThread(threadId, botId);

      const result = yield* runtime.generate(threadId, {
        operation: "edit",
        prompt: PROMPT,
        inputImages: ["other-thread-image"],
      });

      const strict = yield* runtime.generate(threadId, {
        operation: "generate",
        prompt: PROMPT,
        size: "4096x4096",
      });

      assert.equal(result.status === "failed" && result.kind, "invalid-request");
      assert.equal(strict.status === "failed" && strict.kind, "invalid-request");
      assert.equal(adapters.chatgpt.calls.length, 0);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });

  it.effect("cancels an in-flight request for the chat and posts nothing", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt", "hang"), grok: fakeAdapter("grok") };

    return Effect.gen(function* () {
      const runtime = yield* ImageGenerationRuntime;
      const ledger = yield* BotUsageLedger;
      const botId = BotId.make("bot-cancel");
      const threadId = ThreadId.make("thread-cancel");
      yield* createProject;
      yield* createBot(botId, "claudeAgent", null);
      yield* createBotThread(threadId, botId);

      const fiber = yield* runtime
        .generate(threadId, { operation: "generate", prompt: PROMPT })
        .pipe(Effect.forkChild);

      yield* Deferred.await(adapters.chatgpt.started);
      yield* runtime.cancelThread(threadId);
      const result = yield* Fiber.join(fiber);

      assert.equal(result.status === "failed" && result.kind, "cancelled");
      assert.equal(adapters.chatgpt.signals[0]!.aborted, true);
      assert.equal(adapters.grok.calls.length, 0);
      assert.equal((yield* generatedMessages(threadId)).length, 0);
      assert.equal((yield* ledger.summarize(botId)).entries.length, 0);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });

  it.effect("aborts in-flight requests when the runtime shuts down", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt", "hang"), grok: fakeAdapter("grok") };

    return Effect.gen(function* () {
      const botId = BotId.make("bot-shutdown");
      const threadId = ThreadId.make("thread-shutdown");
      yield* createProject;
      yield* createBot(botId, "claudeAgent", null);
      yield* createBotThread(threadId, botId);

      const scope = yield* Scope.make();

      const runtime = yield* makeImageGenerationRuntime({
        adapters,
        subscriptionAuth: fakeSubscriptions(),
      }).pipe(Scope.provide(scope));

      const fiber = yield* runtime
        .generate(threadId, { operation: "generate", prompt: PROMPT })
        .pipe(Effect.forkChild);

      yield* Deferred.await(adapters.chatgpt.started);
      yield* Scope.close(scope, Exit.void);
      const result = yield* Fiber.join(fiber);

      assert.equal(result.status === "failed" && result.kind, "cancelled");
      assert.equal(adapters.chatgpt.signals[0]!.aborted, true);
      assert.equal((yield* generatedMessages(threadId)).length, 0);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });

  it.effect("charges the responding bot in a group chat and posts to the group", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt"), grok: fakeAdapter("grok") };

    return Effect.gen(function* () {
      const runtime = yield* ImageGenerationRuntime;
      const engine = yield* OrchestrationEngineService;
      const ledger = yield* BotUsageLedger;
      const boss = BotId.make("bot-boss");
      const specialist = BotId.make("bot-specialist");
      const groupId = GroupId.make("group-images");
      const threadId = ThreadId.make("thread-group");
      const personId = AuthSessionId.make("person-designer");
      yield* createProject;
      yield* createBot(boss, "codex", null);
      yield* createBot(specialist, "claudeAgent", "grok");
      yield* engine.dispatch({
        type: "group.create",
        commandId: CommandId.make("cmd-group"),
        groupId,
        name: "Design",
        bossBotId: boss,
        specialistBotIds: [specialist],
        creator: { kind: "person", personId, displayName: "Designer" },
        createdAt,
      });
      yield* engine.dispatch({
        type: "thread.create",
        commandId: CommandId.make("cmd-group-thread"),
        threadId,
        projectId,
        groupId,
        title: "Group poster",
        modelSelection,
        runtimeMode: "full-access",
        interactionMode: "default",
        branch: null,
        worktreePath: null,
        createdAt,
      });
      yield* sendUserMessage(threadId, "group", [], { respondingBotId: specialist, personId });

      const result = yield* runtime.generate(threadId, { operation: "generate", prompt: PROMPT });

      assert.equal(result.status === "completed" && result.provider, "grok");
      assert.equal((yield* generatedMessages(threadId)).length, 1);
      assert.equal((yield* ledger.summarize(specialist)).entries.length, 1);
      assert.equal((yield* ledger.summarize(boss)).entries.length, 0);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });

  it.effect("keeps generated images after a restart", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt"), grok: fakeAdapter("grok") };
    const baseDir = tempBaseDir();
    const threadId = ThreadId.make("thread-restart");

    return Effect.gen(function* () {
      const attachmentId = yield* Effect.gen(function* () {
        const runtime = yield* ImageGenerationRuntime;
        const botId = BotId.make("bot-restart");
        yield* createProject;
        yield* createBot(botId, "claudeAgent", null);
        yield* createBotThread(threadId, botId);

        const result = yield* runtime.generate(threadId, {
          operation: "generate",
          prompt: PROMPT,
        });

        return result.status === "completed" ? result.artifacts[0]!.attachmentId : "";
      }).pipe(Effect.provide(testLayer({ baseDir, adapters })));

      yield* Effect.gen(function* () {
        const config = yield* ServerConfig;
        const [message] = yield* generatedMessages(threadId);
        const attachment = message?.attachments?.[0];
        assert.equal(attachment?.id, attachmentId);

        const path = resolveAttachmentPath({
          attachmentsDir: config.attachmentsDir,
          attachment: attachment!,
        })!;

        assert.equal(NodeFS.existsSync(path), true);
      }).pipe(Effect.provide(testLayer({ baseDir, adapters })));
    });
  });

  it.effect("keeps prompts and image bytes out of events and usage rows", () => {
    const adapters = { chatgpt: fakeAdapter("chatgpt"), grok: fakeAdapter("grok") };

    return Effect.gen(function* () {
      const runtime = yield* ImageGenerationRuntime;
      const sql = yield* SqlClient.SqlClient;
      const botId = BotId.make("bot-private");
      const threadId = ThreadId.make("thread-private");
      yield* createProject;
      yield* createBot(botId, "claudeAgent", null);
      yield* createBotThread(threadId, botId);

      const result = yield* runtime.generate(threadId, { operation: "generate", prompt: PROMPT });
      assert.equal(result.status, "completed");

      const events = yield* sql<{ readonly payload: string }>`
        SELECT payload_json AS "payload" FROM orchestration_events
      `;

      const usage = yield* sql<Schema.JsonObject>`SELECT * FROM akeru_bot_usage_entries`;
      assert.equal(events.length > 0 && usage.length === 1, true);

      const stored = [
        ...events.map((event) => event.payload),
        ...usage.flatMap((row) => Object.values(row).map(String)),
      ].join("\n");

      assert.equal(stored.includes(PROMPT), false);
      assert.equal(stored.includes(base64(pngBytes(1024, 1024))), false);
      assert.equal(Object.values(result).map(String).join("\n").includes(PROMPT), false);
    }).pipe(Effect.provide(testLayer({ baseDir: tempBaseDir(), adapters })));
  });
});