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.

24.4 KB
Raw Blame
import {
  expectFailureMessage,
  connectChannel,
  disconnectChannel,
  detachChannelConnection,
  dispatchInboundChannelMessage,
  sendChannelMessage,
  sendCompletedChannelReply,
  stopChannelsForBot,
  handleWhatsAppWebhook,
  NOW,
  BOT_ID,
  PROJECT_ID,
  SECOND_PROJECT_ID,
  makeBot,
  makeMessage,
  makeChatSdkMessage,
  makeThread,
  makeHarness,
  telegramConnect,
  imessageConnect,
  whatsappConnect,
  slackConnect,
  discordConnect,
  signedWhatsAppRequest,
  externalAdapters,
} from "./testUtils/channelRuntime.ts";
import * as NodeCrypto from "node:crypto";
import { MessageId, ThreadId, TurnId, type OrchestrationThread } from "@akeru/contracts";
import * as Effect from "effect/Effect";
import { it } from "@effect/vitest";
import { describe, expect, vi } from "vite-plus/test";
import {
  channelThreadId,
  ignoredInbound,
  mentionWithContext,
  type ChannelRuntimeDependencies,
} from "./ChannelRuntime.ts";

describe("channel runtime", () => {
  it("gives each external conversation a stable isolated thread", () => {
    const first = channelThreadId(BOT_ID, PROJECT_ID, "telegram", "telegram:123");

    expect(channelThreadId(BOT_ID, PROJECT_ID, "telegram", "telegram:123")).toBe(first);
    expect(channelThreadId(BOT_ID, PROJECT_ID, "telegram", "telegram:456")).not.toBe(first);
    expect(channelThreadId(BOT_ID, PROJECT_ID, "imessage", "telegram:123")).not.toBe(first);
  });

  it.effect("routes an inbound message to the selected project instead of the first project", () =>
    Effect.gen(function* () {
      const harness = makeHarness({});

      yield* dispatchInboundChannelMessage(harness.dependencies, {
        botId: BOT_ID,
        projectId: SECOND_PROJECT_ID,
        provider: "telegram",
        externalThreadId: "chat-project-2",
        externalMessageId: "message-project-2",
        text: "Work in project two",
      });

      expect(harness.commands.find((command) => command.type === "thread.create")).toMatchObject({
        projectId: SECOND_PROJECT_ID,
      });
    }),
  );

  it.effect("starts a new thread when the legacy conversation belongs to another project", () =>
    Effect.gen(function* () {
      const externalThreadId = "telegram:legacy-other-project";

      const legacyThreadId = ThreadId.make(
        `channel-${NodeCrypto.createHash("sha256")
          .update(`${BOT_ID}\0telegram\0${externalThreadId}`)
          .digest("hex")}`,
      );

      const harness = makeHarness({ threads: [makeThread(legacyThreadId, BOT_ID, [])] });

      yield* dispatchInboundChannelMessage(harness.dependencies, {
        botId: BOT_ID,
        projectId: SECOND_PROJECT_ID,
        provider: "telegram",
        externalThreadId,
        externalMessageId: "new-project-message",
        text: "Use the selected project",
      });

      const created = harness.commands.find((command) => command.type === "thread.create");
      expect(created).toMatchObject({ projectId: SECOND_PROJECT_ID });
      expect(created?.threadId).not.toBe(legacyThreadId);
      expect(
        harness.commands.find((command) => command.type === "thread.turn.start"),
      ).toMatchObject({
        threadId: created?.threadId,
      });
    }),
  );

  it.effect("continues a channel thread created before project-aware thread IDs", () =>
    Effect.gen(function* () {
      const externalThreadId = "telegram:legacy-chat";

      const legacyThreadId = ThreadId.make(
        `channel-${NodeCrypto.createHash("sha256")
          .update(`${BOT_ID}\0telegram\0${externalThreadId}`)
          .digest("hex")}`,
      );

      const harness = makeHarness({ threads: [makeThread(legacyThreadId, BOT_ID, [])] });

      yield* dispatchInboundChannelMessage(harness.dependencies, {
        botId: BOT_ID,
        projectId: PROJECT_ID,
        provider: "telegram",
        externalThreadId,
        externalMessageId: "legacy-message",
        text: "Continue here",
      });

      expect(harness.commands.some((command) => command.type === "thread.create")).toBe(false);
      expect(
        harness.commands.find((command) => command.type === "thread.turn.start"),
      ).toMatchObject({
        threadId: legacyThreadId,
      });
    }),
  );

  it.effect("derives stable command and message identities from the provider message", () =>
    Effect.gen(function* () {
      const harness = makeHarness({});

      const input = {
        botId: BOT_ID,
        projectId: PROJECT_ID,
        provider: "telegram" as const,
        externalThreadId: "chat-dedupe",
        externalMessageId: "provider-message-1",
        text: "Only once",
      };

      yield* dispatchInboundChannelMessage(harness.dependencies, input);
      yield* dispatchInboundChannelMessage(harness.dependencies, input);

      const turns = harness.commands.filter((command) => command.type === "thread.turn.start");
      expect(turns).toHaveLength(2);
      expect(turns[0]?.commandId).toBe(turns[1]?.commandId);
      expect(turns[0]?.message.messageId).toBe(turns[1]?.message.messageId);
    }),
  );

  it.effect("preserves the inbound provider, thread, and sender on the turn command", () =>
    Effect.gen(function* () {
      const harness = makeHarness({});

      yield* dispatchInboundChannelMessage(harness.dependencies, {
        botId: BOT_ID,
        projectId: PROJECT_ID,
        provider: "telegram",
        externalThreadId: "chat-a",
        externalSenderId: "sender-7",
        text: "Hello",
      });

      const turn = harness.commands.find((command) => command.type === "thread.turn.start");
      expect(turn?.type).toBe("thread.turn.start");

      if (turn?.type !== "thread.turn.start") throw new Error("Expected a turn command.");
      expect(turn.message.channelOrigin).toEqual({
        provider: "telegram",
        externalThreadId: "chat-a",
        externalSenderId: "sender-7",
      });
    }),
  );

  it.effect("validates and dispatches inbound WhatsApp DMs", () =>
    Effect.gen(function* () {
      const harness = makeHarness({ startTransport: null });
      yield* connectChannel(harness.dependencies, whatsappConnect(BOT_ID));

      const payload = JSON.stringify({
        object: "whatsapp_business_account",
        entry: [
          {
            id: "business-id",
            changes: [
              {
                field: "messages",
                value: {
                  messaging_product: "whatsapp",
                  metadata: {
                    display_phone_number: "+15550001111",
                    phone_number_id: "phone-number-id",
                  },
                  contacts: [{ profile: { name: "Alice" }, wa_id: "15551234567" }],
                  messages: [
                    {
                      from: "15551234567",
                      id: "wamid.1",
                      timestamp: "1788220000",
                      text: { body: "Hello from WhatsApp" },
                      type: "text",
                    },
                  ],
                },
              },
            ],
          },
        ],
      });

      const invalidSignature = yield* handleWhatsAppWebhook(
        BOT_ID,
        new Request(`https://akeru.example/api/channels/whatsapp/${BOT_ID}/webhook`, {
          method: "POST",
          body: payload,
        }),
      );

      const invalidPayload = yield* handleWhatsAppWebhook(BOT_ID, signedWhatsAppRequest("{}"));
      const accepted = yield* handleWhatsAppWebhook(BOT_ID, signedWhatsAppRequest(payload));

      expect(invalidSignature.status).toBe(401);
      expect(invalidPayload.status).toBe(400);
      expect(accepted.status).toBe(200);
      const turn = harness.commands.find((command) => command.type === "thread.turn.start");
      expect(turn?.type).toBe("thread.turn.start");

      if (turn?.type !== "thread.turn.start") throw new Error("Expected a turn command.");
      expect(turn.message.channelOrigin).toEqual({
        provider: "whatsapp",
        externalThreadId: "whatsapp:phone-number-id:15551234567",
        externalMessageId: "wamid.1",
        externalSenderId: "15551234567",
      });
    }),
  );

  it.effect("accepts iMessage direct messages and ignores group messages", () =>
    Effect.gen(function* () {
      let directMessage:
        | Parameters<NonNullable<ChannelRuntimeDependencies["startTransport"]>>[1]
        | undefined;

      const harness = makeHarness({
        startTransport: async (_input, onDirectMessage) => {
          directMessage = onDirectMessage;

          return {
            externalIdentity: "Photon hosted",
            runtime: { post: async () => undefined, shutdown: async () => undefined },
          };
        },
      });

      yield* connectChannel(harness.dependencies, imessageConnect(BOT_ID));

      yield* Effect.promise(async () =>
        directMessage?.({
          externalThreadId: "imessage:iMessage;-;+15551234567",
          externalMessageId: "direct-1",
          externalSenderId: "+15551234567",
          externalSenderName: "Alice",
          text: "DM without a mention",
        }),
      );

      const turns = harness.commands.filter((command) => command.type === "thread.turn.start");
      expect(turns).toHaveLength(1);
      expect(turns[0]?.message.channelOrigin).toMatchObject({
        provider: "imessage",
        externalMessageId: "direct-1",
        externalThreadId: "imessage:iMessage;-;+15551234567",
      });
    }),
  );

  it.effect("bounds first-mention context and preserves sender attribution", () =>
    Effect.gen(function* () {
      const threadId = "slack:C123:1710000000.000001";

      const history = Array.from({ length: 12 }, (_, index) =>
        makeChatSdkMessage(threadId, `history-${index}`, `context ${index}`, `U${index}`),
      );

      const current = makeChatSdkMessage(
        threadId,
        "mention-current",
        "@Akeru investigate",
        "U-current",
        true,
      );

      const thread = {
        id: threadId,
        recentMessages: [...history, current],
        refresh: async () => undefined,
      };

      const normalized = yield* Effect.promise(() => mentionWithContext(thread, current));

      expect(normalized.text).not.toContain("U0: context 0\n");
      expect(normalized.text).not.toContain("U1: context 1\n");
      expect(normalized.text.split("\n")).toHaveLength(11);
      expect(normalized.externalSenderName).toBe("U-current");
      expect(normalized.externalMessageId).toBe("mention-current");
    }),
  );

  it.effect("limits large prior context without truncating the current mention", () =>
    Effect.gen(function* () {
      const threadId = "slack:C123:large-context";

      const current = makeChatSdkMessage(
        threadId,
        "current",
        "@Akeru investigate",
        "U-current",
        true,
      );

      const thread = {
        id: threadId,
        recentMessages: [
          makeChatSdkMessage(threadId, "earlier", "x".repeat(20_000), "U1"),
          makeChatSdkMessage(threadId, "latest", "Latest detail", "U2"),
          current,
        ],
        refresh: async () => undefined,
      };

      const normalized = yield* Effect.promise(() => mentionWithContext(thread, current));

      expect(normalized.text.length).toBe(8_000 + 1 + current.text.length);
      expect(normalized.text).toContain("U2: Latest detail");
      expect(normalized.text.endsWith(`\n${current.text}`)).toBe(true);
    }),
  );

  it.effect("routes Slack direct messages and subscribed mention threads", () =>
    Effect.gen(function* () {
      const harness = makeHarness({ startTransport: null });
      yield* connectChannel(harness.dependencies, slackConnect(BOT_ID));

      if (!externalAdapters.slackChat || !externalAdapters.slackAdapter) {
        throw new Error("Expected the Slack Chat runtime.");
      }

      const { slackChat, slackAdapter } = externalAdapters;

      const directThreadId = "slack:D123:";
      yield* Effect.promise(() =>
        slackChat.processMessage(
          slackAdapter,
          directThreadId,
          makeChatSdkMessage(directThreadId, "slack-dm-1", "Direct work", "U1"),
        ),
      );
      const channelThreadId = "slack:C123:1710000000.000001";
      yield* Effect.promise(() =>
        slackChat.processMessage(
          slackAdapter,
          channelThreadId,
          makeChatSdkMessage(channelThreadId, "slack-mention-1", "@Akeru investigate", "U2", true),
        ),
      );
      yield* Effect.promise(() =>
        slackChat.processMessage(
          slackAdapter,
          channelThreadId,
          makeChatSdkMessage(channelThreadId, "slack-followup-1", "One more detail", "U3"),
        ),
      );

      const turns = harness.commands.filter((command) => command.type === "thread.turn.start");
      expect(turns.map((turn) => turn.message.channelOrigin?.externalMessageId)).toEqual([
        "slack-dm-1",
        "slack-mention-1",
        "slack-followup-1",
      ]);
      expect(turns[1]?.threadId).toBe(turns[2]?.threadId);

      yield* disconnectChannel(harness.dependencies, BOT_ID, "slack");
      expect(externalAdapters.slackDisconnects).toBeGreaterThan(0);
    }),
  );

  it.effect("restores Slack and Discord platform-thread subscriptions", () =>
    Effect.gen(function* () {
      const slackThreadId = ThreadId.make("thread-slack-restored");
      const discordThreadId = ThreadId.make("thread-discord-restored");

      const harness = makeHarness({
        startTransport: null,
        commandModelOmitsMessages: true,
        threads: [
          makeThread(slackThreadId, BOT_ID, [
            makeMessage(MessageId.make("slack-origin"), "user", "Mention", {
              provider: "slack",
              externalThreadId: "slack:C1:1",
            }),
          ]),
          makeThread(discordThreadId, BOT_ID, [
            makeMessage(MessageId.make("discord-origin"), "user", "Mention", {
              provider: "discord",
              externalThreadId: "discord:G1:C1:T1",
            }),
          ]),
        ],
      });

      yield* connectChannel(harness.dependencies, slackConnect(BOT_ID));
      yield* connectChannel(harness.dependencies, discordConnect(BOT_ID));

      expect(externalAdapters.slackRestoredBeforeInitialize).toBe(true);
      expect(externalAdapters.slackSubscriptions).toContain("slack:C1:1");
      expect(externalAdapters.discordSubscriptions).toContain("discord:G1:C1:T1");
    }),
  );

  it.effect("routes normalized Discord direct messages and mention-thread continuation", () =>
    Effect.gen(function* () {
      let directMessage:
        | Parameters<NonNullable<ChannelRuntimeDependencies["startTransport"]>>[1]
        | undefined;

      let context:
        | Parameters<NonNullable<ChannelRuntimeDependencies["startTransport"]>>[2]
        | undefined;

      const harness = makeHarness({
        startTransport: async (_input, onDirectMessage, transportContext) => {
          directMessage = onDirectMessage;
          context = transportContext;

          return {
            externalIdentity: "akeru-discord",
            runtime: { post: async () => undefined, shutdown: async () => undefined },
          };
        },
      });

      yield* connectChannel(harness.dependencies, discordConnect(BOT_ID));

      yield* Effect.promise(async () =>
        directMessage?.({
          externalThreadId: "discord:@me:dm-channel",
          externalMessageId: "discord-dm-1",
          externalSenderId: "D1",
          text: "Direct work",
        }),
      );
      yield* Effect.promise(async () =>
        context?.onMention({
          externalThreadId: "discord:guild-1:channel-1:thread-1",
          externalMessageId: "discord-mention-1",
          externalSenderId: "D2",
          text: "@Akeru investigate",
        }),
      );
      yield* Effect.promise(async () =>
        context?.onSubscribedMessage({
          externalThreadId: "discord:guild-1:channel-1:thread-1",
          externalMessageId: "discord-followup-1",
          externalSenderId: "D3",
          text: "One more detail",
        }),
      );

      const turns = harness.commands.filter((command) => command.type === "thread.turn.start");
      expect(turns.map((turn) => turn.message.channelOrigin?.externalMessageId)).toEqual([
        "discord-dm-1",
        "discord-mention-1",
        "discord-followup-1",
      ]);
      expect(turns[1]?.threadId).toBe(turns[2]?.threadId);
    }),
  );

  it.effect("rejects inbound messages for archived bots", () =>
    Effect.gen(function* () {
      const harness = makeHarness({ bots: [makeBot(BOT_ID, { archivedAt: NOW })] });

      yield* expectFailureMessage(
        dispatchInboundChannelMessage(harness.dependencies, {
          botId: BOT_ID,
          projectId: PROJECT_ID,
          provider: "telegram",
          externalThreadId: "chat-a",
          text: "Hello",
        }),
        "unavailable",
      );
      expect(harness.commands).toEqual([]);
    }),
  );

  for (const operation of [disconnectChannel, detachChannelConnection]) {
    it.effect(`ignores inbound messages when ${operation.name} shutdown fails`, () =>
      Effect.gen(function* () {
        const callbacks: Array<
          Parameters<NonNullable<ChannelRuntimeDependencies["startTransport"]>>[1]
        > = [];

        const shutdown = vi.fn(async () => {
          throw new Error("shutdown failed");
        });

        const harness = makeHarness({
          startTransport: async (_input, onInbound) => {
            callbacks.push(onInbound);

            return {
              externalIdentity: "@akeru",
              runtime: { post: async () => undefined, shutdown },
            };
          },
        });

        yield* connectChannel(harness.dependencies, telegramConnect(BOT_ID));
        expect(callbacks).toHaveLength(1);

        yield* expectFailureMessage(
          operation(harness.dependencies, BOT_ID, "telegram"),
          "Channel provider request failed.",
        );
        expect(harness.readModel().bots[0]?.channelBindings[0]?.status).toBe("disconnected");
        const commandsBefore = harness.commands.length;
        yield* Effect.promise(async () =>
          callbacks[0]!({
            externalThreadId: "telegram:failed-shutdown",
            externalMessageId: "still-active",
            text: "Do not start a turn",
          }),
        );
        expect(harness.commands).toHaveLength(commandsBefore);
        expect(
          harness.commands.filter((command) => command.type === "thread.turn.start"),
        ).toHaveLength(0);

        // The failed transport is no longer registered, so a later stop leaves it alone.
        yield* stopChannelsForBot(BOT_ID);
        expect(shutdown).toHaveBeenCalledTimes(1);
      }),
    );
  }

  it.effect("sends an approved WhatsApp reply to the inbound DM", () =>
    Effect.gen(function* () {
      const messageId = MessageId.make("whatsapp-reply");
      const externalThreadId = "whatsapp:phone-number-id:15551234567";
      const threadId = channelThreadId(BOT_ID, PROJECT_ID, "whatsapp", externalThreadId);
      const posts: Array<{ readonly externalThreadId: string; readonly text: string }> = [];

      const harness = makeHarness({
        threads: [
          makeThread(threadId, BOT_ID, [
            makeMessage(MessageId.make("whatsapp-inbound"), "user", "Question", {
              provider: "whatsapp",
              externalThreadId,
              externalSenderId: "15551234567",
            }),
            makeMessage(messageId, "assistant", "Approved answer"),
          ]),
        ],
        post: async (target, text) => void posts.push({ externalThreadId: target, text }),
      });

      yield* connectChannel(harness.dependencies, whatsappConnect(BOT_ID));

      yield* sendChannelMessage(harness.dependencies, { botId: BOT_ID, threadId, messageId });

      expect(posts).toEqual([
        {
          externalThreadId,
          text: `Approved answer\n\nOpen in Akeru: https://akeru.example/bots/${BOT_ID}`,
        },
      ]);
    }),
  );

  it.effect("automatically sends one completed reply for an inbound channel turn", () =>
    Effect.gen(function* () {
      const turnId = TurnId.make("turn-auto-reply");
      const requestMessageId = MessageId.make("inbound-auto-reply");
      const messageId = MessageId.make("assistant-auto-reply");
      const threadId = ThreadId.make("thread-auto-reply");
      let posts = 0;

      const thread: OrchestrationThread = {
        ...makeThread(threadId, BOT_ID, [
          makeMessage(requestMessageId, "user", "Hello", {
            provider: "imessage",
            externalThreadId: "iMessage;-;sender",
          }),
          { ...makeMessage(messageId, "assistant", "Hello back"), turnId },
        ]),
        latestTurn: {
          turnId,
          state: "completed",
          requestedAt: NOW,
          startedAt: NOW,
          completedAt: NOW,
          assistantMessageId: messageId,
          requestMessageId,
          respondingBotId: BOT_ID,
        },
      };

      const harness = makeHarness({
        threads: [thread],
        post: async () => void (posts += 1),
      });

      yield* connectChannel(harness.dependencies, imessageConnect(BOT_ID));

      expect(
        yield* sendCompletedChannelReply(harness.dependencies, threadId, turnId),
      ).toBeGreaterThan(0);
      expect(
        yield* sendCompletedChannelReply(harness.dependencies, threadId, turnId),
      ).toBeGreaterThan(0);

      expect(posts).toBe(1);
      expect(harness.readModel().bots[0]?.channelBindings[0]?.sentMessageIds).toContain(messageId);

      expect(
        yield* sendCompletedChannelReply(
          harness.dependencies,
          threadId,
          TurnId.make("stale-auto-reply-turn"),
        ),
      ).toBeNull();
      expect(posts).toBe(1);
    }),
  );

  it("treats an unknown author as a bot except on Telegram", () => {
    const unknown = makeChatSdkMessage("thread", "unknown", "Hello", "sender", false, {
      isBot: "unknown",
    });

    const person = makeChatSdkMessage("thread", "person", "Hello", "sender");
    // Telegram marks messages sent on behalf of a chat (anonymous admins, channel posts) "unknown".
    expect(ignoredInbound("telegram", unknown)).toBe(false);

    for (const provider of ["discord", "slack", "whatsapp", "imessage"] as const) {
      expect(ignoredInbound(provider, unknown)).toBe(true);
    }

    for (const provider of ["telegram", "discord", "slack", "whatsapp", "imessage"] as const) {
      expect(ignoredInbound(provider, person)).toBe(false);
    }
  });

  it.effect("ignores bot-authored direct and subscribed-thread messages", () =>
    Effect.gen(function* () {
      const harness = makeHarness({ startTransport: null });
      yield* connectChannel(harness.dependencies, slackConnect(BOT_ID));

      if (!externalAdapters.slackChat || !externalAdapters.slackAdapter) {
        throw new Error("Expected the Slack Chat runtime.");
      }

      const { slackChat, slackAdapter } = externalAdapters;

      const process = (threadId: string, message: ReturnType<typeof makeChatSdkMessage>) =>
        Effect.promise(() => slackChat.processMessage(slackAdapter, threadId, message));

      const directThreadId = "slack:D123:";
      yield* process(
        directThreadId,
        makeChatSdkMessage(directThreadId, "slack-self-dm", "Echo", "U-AKERU", false, {
          isBot: true,
          isMe: true,
        }),
      );
      yield* process(
        directThreadId,
        makeChatSdkMessage(directThreadId, "slack-bot-dm", "Hi bot", "B2", false, {
          isBot: true,
        }),
      );
      const channelThreadId = "slack:C123:1710000000.000001";
      yield* process(
        channelThreadId,
        makeChatSdkMessage(channelThreadId, "slack-mention", "@Akeru investigate", "U2", true),
      );
      yield* process(
        channelThreadId,
        makeChatSdkMessage(channelThreadId, "slack-bot-followup", "Automated reply", "B2", false, {
          isBot: true,
        }),
      );
      yield* process(
        channelThreadId,
        makeChatSdkMessage(channelThreadId, "slack-self-followup", "My reply", "U-AKERU", false, {
          isBot: true,
          isMe: true,
        }),
      );
      yield* process(
        channelThreadId,
        makeChatSdkMessage(channelThreadId, "slack-unknown-followup", "Relayed", "B3", false, {
          isBot: "unknown",
        }),
      );
      yield* process(
        channelThreadId,
        makeChatSdkMessage(channelThreadId, "slack-human-followup", "Thanks", "U3"),
      );

      const turns = harness.commands.filter((command) => command.type === "thread.turn.start");
      expect(turns.map((turn) => turn.message.channelOrigin?.externalMessageId)).toEqual([
        "slack-mention",
        "slack-human-followup",
      ]);
      yield* disconnectChannel(harness.dependencies, BOT_ID, "slack");
    }),
  );
});