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.3 KB
Raw Blame
import { assert, describe, expect, it } from "vite-plus/test";
import { AuthSessionId, BotId, CheckpointRef, MessageId, ThreadId, TurnId } from "@akeru/contracts";
import type { OrchestrationThread } from "@akeru/contracts";
import { applyThreadDetailEvent } from "./threadReducer.ts";
import { baseEventFields, baseThread } from "./threadReducer.test-support.ts";

describe("applyThreadDetailEvent", () => {
  describe("thread.message-sent", () => {
    const boundMessageId = MessageId.make("msg-bound");
    const boundTurnId = TurnId.make("turn-bound");

    const boundCheckpoint = {
      turnId: boundTurnId,
      checkpointTurnCount: 1,
      checkpointRef: CheckpointRef.make("ref-bound"),
      status: "ready",
      files: [],
      assistantMessageId: boundMessageId,
      completedAt: "2026-04-01T06:00:00.000Z",
    } satisfies OrchestrationThread["checkpoints"][number];

    const streamingEvent = {
      ...baseEventFields,
      sequence: 7,
      occurredAt: "2026-04-01T06:01:00.000Z",
      aggregateKind: "thread",
      aggregateId: baseThread.id,
      type: "thread.message-sent",
      payload: {
        threadId: baseThread.id,
        messageId: boundMessageId,
        role: "assistant",
        text: "delta",
        turnId: boundTurnId,
        streaming: true,
        createdAt: "2026-04-01T06:00:00.000Z",
        updatedAt: "2026-04-01T06:01:00.000Z",
      },
    } as const;

    it.each([
      { name: "empty checkpoints", checkpoints: [] },
      { name: "already-bound checkpoint", checkpoints: [boundCheckpoint] },
      {
        name: "unrelated checkpoint",
        checkpoints: [{ ...boundCheckpoint, turnId: TurnId.make("other-turn") }],
      },
    ])("preserves collection identity for $name", ({ checkpoints }) => {
      const result = applyThreadDetailEvent({ ...baseThread, checkpoints }, streamingEvent);
      assert(result.kind === "updated");
      expect(result.thread.checkpoints).toBe(checkpoints);
    });

    it("copies only checkpoints whose assistant binding changes", () => {
      const unrelated = { ...boundCheckpoint, turnId: TurnId.make("other-turn") };
      const unbound = { ...boundCheckpoint, assistantMessageId: null };
      const previouslyBound = { ...boundCheckpoint, assistantMessageId: MessageId.make("old") };
      const checkpoints = [unrelated, unbound, boundCheckpoint, previouslyBound];
      const result = applyThreadDetailEvent({ ...baseThread, checkpoints }, streamingEvent);
      assert(result.kind === "updated");
      expect(result.thread.checkpoints).not.toBe(checkpoints);
      expect(result.thread.checkpoints[0]).toBe(unrelated);
      expect(result.thread.checkpoints[2]).toBe(boundCheckpoint);
      expect(result.thread.checkpoints[1]).toEqual(boundCheckpoint);
      expect(result.thread.checkpoints[1]).not.toBe(unbound);
      expect(result.thread.checkpoints[3]).toEqual(boundCheckpoint);
      expect(result.thread.checkpoints[3]).not.toBe(previouslyBound);
      expect(unbound.assistantMessageId).toBeNull();
      expect(previouslyBound.assistantMessageId).toBe("old");
    });

    it("removes 100 no-op collection and entry replacements across 500 checkpoints", () => {
      const checkpoints = Array.from({ length: 500 }, (_, index) => ({
        ...boundCheckpoint,
        turnId: index === 0 ? boundTurnId : TurnId.make(`turn-${index}`),
      }));

      let thread: OrchestrationThread = { ...baseThread, checkpoints };
      let previousCheckpoints: OrchestrationThread["checkpoints"] = checkpoints;
      let oldCollectionReplacements = 0;
      let oldEntryReplacements = 0;
      let newCollectionReplacements = 0;
      let newEntryReplacements = 0;

      for (let index = 0; index < 100; index += 1) {
        const oldNext = previousCheckpoints.map((entry) =>
          entry.turnId === boundTurnId ? { ...entry, assistantMessageId: boundMessageId } : entry,
        );

        oldCollectionReplacements += Number(oldNext !== previousCheckpoints);
        oldEntryReplacements += oldNext.filter(
          (entry, i) => entry !== previousCheckpoints[i],
        ).length;
        previousCheckpoints = oldNext;

        const result = applyThreadDetailEvent(thread, { ...streamingEvent, sequence: index + 1 });
        assert(result.kind === "updated");
        newCollectionReplacements += Number(result.thread.checkpoints !== thread.checkpoints);
        newEntryReplacements += result.thread.checkpoints.filter(
          (entry, i) => entry !== thread.checkpoints[i],
        ).length;
        thread = result.thread;
      }

      expect({ oldCollectionReplacements, oldEntryReplacements }).toEqual({
        oldCollectionReplacements: 100,
        oldEntryReplacements: 100,
      });
      expect({ newCollectionReplacements, newEntryReplacements }).toEqual({
        newCollectionReplacements: 0,
        newEntryReplacements: 0,
      });
      expect(thread.checkpoints).toBe(checkpoints);
      expect(thread.messages[0]?.text).toBe("delta".repeat(100));
    });

    it("appends a new message", () => {
      const result = applyThreadDetailEvent(baseThread, {
        ...baseEventFields,
        sequence: 6,
        occurredAt: "2026-04-01T06:00:00.000Z",
        aggregateKind: "thread",
        aggregateId: ThreadId.make("thread-1"),
        type: "thread.message-sent",
        payload: {
          threadId: ThreadId.make("thread-1"),
          messageId: MessageId.make("msg-1"),
          role: "user",
          text: "Hello, world!",
          turnId: null,
          authorPersonId: AuthSessionId.make("person-1"),
          authorDisplayName: "Leo",
          channelOrigin: {
            provider: "telegram",
            externalThreadId: "chat-1",
            externalSenderId: "user-1",
          },
          streaming: false,
          createdAt: "2026-04-01T06:00:00.000Z",
          updatedAt: "2026-04-01T06:00:00.000Z",
        },
      });

      expect(result.kind).toBe("updated");

      if (result.kind === "updated") {
        expect(result.thread.messages).toHaveLength(1);
        expect(result.thread.messages[0]?.text).toBe("Hello, world!");
        expect(result.thread.messages[0]?.authorPersonId).toBe("person-1");
        expect(result.thread.messages[0]?.authorDisplayName).toBe("Leo");
        expect(result.thread.messages[0]?.channelOrigin).toEqual({
          provider: "telegram",
          externalThreadId: "chat-1",
          externalSenderId: "user-1",
        });
      }
    });

    it("appends text for streaming messages", () => {
      const threadWithMessage: OrchestrationThread = {
        ...baseThread,
        messages: [
          {
            id: MessageId.make("msg-2"),
            role: "assistant",
            text: "Hello",
            turnId: TurnId.make("turn-1"),
            streaming: true,
            createdAt: "2026-04-01T06:00:00.000Z",
            updatedAt: "2026-04-01T06:00:00.000Z",
          },
        ],
      };

      const result = applyThreadDetailEvent(threadWithMessage, {
        ...baseEventFields,
        sequence: 7,
        occurredAt: "2026-04-01T06:01:00.000Z",
        aggregateKind: "thread",
        aggregateId: ThreadId.make("thread-1"),
        type: "thread.message-sent",
        payload: {
          threadId: ThreadId.make("thread-1"),
          messageId: MessageId.make("msg-2"),
          role: "assistant",
          text: ", world!",
          turnId: TurnId.make("turn-1"),
          streaming: true,
          createdAt: "2026-04-01T06:00:00.000Z",
          updatedAt: "2026-04-01T06:01:00.000Z",
        },
      });

      expect(result.kind).toBe("updated");

      if (result.kind === "updated") {
        expect(result.thread.messages).toHaveLength(1);
        expect(result.thread.messages[0]?.text).toBe("Hello, world!");
      }
    });

    it("updates latestTurn for assistant messages with a turn", () => {
      const result = applyThreadDetailEvent(baseThread, {
        ...baseEventFields,
        sequence: 8,
        occurredAt: "2026-04-01T07:00:00.000Z",
        aggregateKind: "thread",
        aggregateId: ThreadId.make("thread-1"),
        type: "thread.message-sent",
        payload: {
          threadId: ThreadId.make("thread-1"),
          messageId: MessageId.make("msg-3"),
          role: "assistant",
          text: "Done.",
          turnId: TurnId.make("turn-1"),
          streaming: false,
          createdAt: "2026-04-01T07:00:00.000Z",
          updatedAt: "2026-04-01T07:00:00.000Z",
        },
      });

      expect(result.kind).toBe("updated");

      if (result.kind === "updated") {
        expect(result.thread.latestTurn?.turnId).toBe("turn-1");
        expect(result.thread.latestTurn?.state).toBe("completed");
        expect(result.thread.latestTurn?.assistantMessageId).toBe("msg-3");
      }
    });

    it("keeps latestTurn and checkpoints references across a streaming delta", () => {
      const streamingThread: OrchestrationThread = {
        ...baseThread,
        session: {
          threadId: ThreadId.make("thread-1"),
          status: "running",
          providerName: "claude",
          runtimeMode: "full-access",
          activeTurnId: TurnId.make("turn-1"),
          lastError: null,
          updatedAt: "2026-04-01T06:59:00.000Z",
        },
        latestTurn: {
          turnId: TurnId.make("turn-1"),
          state: "running",
          requestedAt: "2026-04-01T06:59:00.000Z",
          startedAt: "2026-04-01T06:59:00.000Z",
          completedAt: null,
          assistantMessageId: MessageId.make("msg-2"),
          requestMessageId: MessageId.make("msg-1"),
          respondingBotId: BotId.make("bot-scout"),
        },
        messages: [
          {
            id: MessageId.make("msg-2"),
            role: "assistant",
            text: "Hello",
            turnId: TurnId.make("turn-1"),
            streaming: true,
            createdAt: "2026-04-01T06:00:00.000Z",
            updatedAt: "2026-04-01T06:00:00.000Z",
          },
        ],
        checkpoints: [
          {
            turnId: TurnId.make("turn-1"),
            checkpointTurnCount: 1,
            checkpointRef: CheckpointRef.make("ref-1"),
            status: "ready",
            files: [],
            assistantMessageId: MessageId.make("msg-2"),
            completedAt: "2026-04-01T06:00:30.000Z",
          },
        ],
      };

      const result = applyThreadDetailEvent(streamingThread, {
        ...baseEventFields,
        sequence: 9,
        occurredAt: "2026-04-01T07:00:00.000Z",
        aggregateKind: "thread",
        aggregateId: ThreadId.make("thread-1"),
        type: "thread.message-sent",
        payload: {
          threadId: ThreadId.make("thread-1"),
          messageId: MessageId.make("msg-2"),
          role: "assistant",
          text: ", world",
          turnId: TurnId.make("turn-1"),
          streaming: true,
          createdAt: "2026-04-01T06:00:00.000Z",
          updatedAt: "2026-04-01T07:00:00.000Z",
        },
      });

      expect(result.kind).toBe("updated");

      if (result.kind === "updated") {
        expect(result.thread.messages).not.toBe(streamingThread.messages);
        expect(result.thread.messages[0]?.text).toBe("Hello, world");
        expect(result.thread.latestTurn).toBe(streamingThread.latestTurn);
        expect(result.thread.latestTurn?.requestMessageId).toBe("msg-1");
        expect(result.thread.latestTurn?.respondingBotId).toBe("bot-scout");
        expect(result.thread.checkpoints).toBe(streamingThread.checkpoints);
      }
    });

    it("replaces latestTurn and checkpoints when the first assistant message binds the turn", () => {
      const unboundThread: OrchestrationThread = {
        ...baseThread,
        session: {
          threadId: ThreadId.make("thread-1"),
          status: "running",
          providerName: "claude",
          runtimeMode: "full-access",
          activeTurnId: TurnId.make("turn-1"),
          lastError: null,
          updatedAt: "2026-04-01T06:59:00.000Z",
        },
        latestTurn: {
          turnId: TurnId.make("turn-1"),
          state: "running",
          requestedAt: "2026-04-01T06:59:00.000Z",
          startedAt: "2026-04-01T06:59:00.000Z",
          completedAt: null,
          assistantMessageId: null,
        },
        checkpoints: [
          {
            turnId: TurnId.make("turn-1"),
            checkpointTurnCount: 1,
            checkpointRef: CheckpointRef.make("ref-1"),
            status: "ready",
            files: [],
            assistantMessageId: null,
            completedAt: "2026-04-01T06:59:30.000Z",
          },
        ],
      };

      const result = applyThreadDetailEvent(unboundThread, {
        ...baseEventFields,
        sequence: 9,
        occurredAt: "2026-04-01T07:00:00.000Z",
        aggregateKind: "thread",
        aggregateId: ThreadId.make("thread-1"),
        type: "thread.message-sent",
        payload: {
          threadId: ThreadId.make("thread-1"),
          messageId: MessageId.make("msg-2"),
          role: "assistant",
          text: "Hello",
          turnId: TurnId.make("turn-1"),
          streaming: true,
          createdAt: "2026-04-01T07:00:00.000Z",
          updatedAt: "2026-04-01T07:00:00.000Z",
        },
      });

      expect(result.kind).toBe("updated");

      if (result.kind === "updated") {
        expect(result.thread.latestTurn).not.toBe(unboundThread.latestTurn);
        expect(result.thread.latestTurn?.assistantMessageId).toBe("msg-2");
        expect(result.thread.checkpoints).not.toBe(unboundThread.checkpoints);
        expect(result.thread.checkpoints[0]?.assistantMessageId).toBe("msg-2");
      }
    });

    it("keeps latestTurn running for interim assistant messages while the session runs the turn", () => {
      const threadWithRunningSession: OrchestrationThread = {
        ...baseThread,
        session: {
          threadId: ThreadId.make("thread-1"),
          status: "running",
          providerName: "claude",
          runtimeMode: "full-access",
          activeTurnId: TurnId.make("turn-1"),
          lastError: null,
          updatedAt: "2026-04-01T06:59:00.000Z",
        },
        latestTurn: {
          turnId: TurnId.make("turn-1"),
          state: "running",
          requestedAt: "2026-04-01T06:59:00.000Z",
          startedAt: "2026-04-01T06:59:00.000Z",
          completedAt: null,
          assistantMessageId: null,
        },
      };

      const result = applyThreadDetailEvent(threadWithRunningSession, {
        ...baseEventFields,
        sequence: 8,
        occurredAt: "2026-04-01T07:00:00.000Z",
        aggregateKind: "thread",
        aggregateId: ThreadId.make("thread-1"),
        type: "thread.message-sent",
        payload: {
          threadId: ThreadId.make("thread-1"),
          messageId: MessageId.make("msg-3"),
          role: "assistant",
          text: "Interim commentary between tool calls.",
          turnId: TurnId.make("turn-1"),
          streaming: false,
          createdAt: "2026-04-01T07:00:00.000Z",
          updatedAt: "2026-04-01T07:00:00.000Z",
        },
      });

      expect(result.kind).toBe("updated");

      if (result.kind === "updated") {
        expect(result.thread.latestTurn?.state).toBe("running");
        expect(result.thread.latestTurn?.completedAt).toBeNull();
      }
    });
  });

  describe("thread.message-reaction-set", () => {
    it("projects person-authored reactions without a bot identity", () => {
      const personId = AuthSessionId.make("person-1");
      const messageId = MessageId.make("msg-reaction");

      const threadWithMessage: OrchestrationThread = {
        ...baseThread,
        messages: [
          {
            id: messageId,
            role: "assistant",
            text: "Done.",
            turnId: null,
            streaming: false,
            createdAt: "2026-04-01T07:00:00.000Z",
            updatedAt: "2026-04-01T07:00:00.000Z",
          },
        ],
      };

      const result = applyThreadDetailEvent(threadWithMessage, {
        ...baseEventFields,
        sequence: 9,
        occurredAt: "2026-04-01T07:01:00.000Z",
        aggregateKind: "thread",
        aggregateId: ThreadId.make("thread-1"),
        type: "thread.message-reaction-set",
        payload: {
          threadId: ThreadId.make("thread-1"),
          messageId,
          personId,
          emoji: "👍",
          present: true,
          updatedAt: "2026-04-01T07:01:00.000Z",
        },
      });

      expect(result.kind).toBe("updated");

      if (result.kind === "updated") {
        expect(result.thread.messages[0]?.reactions).toEqual([{ personId, emoji: "👍" }]);
      }
    });
  });
});