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.

6.1 KB
Raw Blame
import * as Arr from "effect/Array";
import type {
  OrchestrationEvent,
  OrchestrationMessage,
  OrchestrationThread,
} from "@akeru/contracts";
import type { ThreadDetailReducerResult } from "./types.ts";
import {
  copyLatestTurnIdentities,
  rebindCheckpointAssistantMessage,
  reuseLatestTurn,
} from "./turns.ts";

export function applyChannelDeliverySetEvent(
  thread: OrchestrationThread,
  event: Extract<OrchestrationEvent, { readonly type: "thread.channel-delivery-set" }>,
): ThreadDetailReducerResult {
  const messages = thread.messages.map((entry) =>
    entry.id === event.payload.messageId
      ? {
          ...entry,
          channelDelivery: event.payload.delivery,
          updatedAt: event.payload.updatedAt,
        }
      : entry,
  );

  return {
    kind: "updated",
    thread: { ...thread, messages, updatedAt: event.payload.updatedAt },
  };
}

export function applyMessageSentEvent(
  thread: OrchestrationThread,
  event: Extract<OrchestrationEvent, { readonly type: "thread.message-sent" }>,
): ThreadDetailReducerResult {
  const message: OrchestrationMessage = {
    id: event.payload.messageId,
    role: event.payload.role,
    text: event.payload.text,
    ...(event.payload.attachments !== undefined ? { attachments: event.payload.attachments } : {}),
    turnId: event.payload.turnId,
    authorPersonId: event.payload.authorPersonId ?? null,
    authorDisplayName: event.payload.authorDisplayName ?? null,
    channelOrigin: event.payload.channelOrigin ?? null,
    streaming: event.payload.streaming,
    createdAt: event.payload.createdAt,
    updatedAt: event.payload.updatedAt,
  };

  const existingMessage = thread.messages.find((entry) => entry.id === message.id);

  const messages = existingMessage
    ? Arr.map(thread.messages, (entry) =>
        entry.id !== message.id
          ? entry
          : {
              ...entry,
              text: message.streaming
                ? `${entry.text}${message.text}`
                : message.text.length > 0
                  ? message.text
                  : entry.text,
              streaming: message.streaming,
              ...(message.turnId !== undefined ? { turnId: message.turnId } : {}),
              ...(message.streaming ? {} : { updatedAt: message.updatedAt }),
              ...(message.attachments !== undefined ? { attachments: message.attachments } : {}),
            },
      )
    : Arr.append(thread.messages, message);

  // Update latestTurn for assistant messages bound to a turn. A completed
  // assistant message only settles the turn once the session is no longer
  // running it — providers may emit several assistant messages per turn
  // (commentary between tool calls), and the turn must stay unsettled
  // until the provider reports turn end. Streaming deltas recompute the
  // same record, so the previous reference is kept when nothing changed.
  const turnStillRunning =
    event.payload.turnId !== null &&
    thread.session?.status === "running" &&
    thread.session.activeTurnId === event.payload.turnId;

  const settlesTurn = !event.payload.streaming && !turnStillRunning;

  const latestTurn = reuseLatestTurn(
    thread.latestTurn,
    event.payload.role === "assistant" &&
      event.payload.turnId !== null &&
      (thread.latestTurn === null || thread.latestTurn.turnId === event.payload.turnId)
      ? {
          turnId: event.payload.turnId,
          state: settlesTurn
            ? thread.latestTurn?.state === "interrupted"
              ? "interrupted"
              : thread.latestTurn?.state === "error"
                ? "error"
                : "completed"
            : "running",
          requestedAt:
            thread.latestTurn?.turnId === event.payload.turnId
              ? thread.latestTurn.requestedAt
              : event.payload.createdAt,
          startedAt:
            thread.latestTurn?.turnId === event.payload.turnId
              ? (thread.latestTurn.startedAt ?? event.payload.createdAt)
              : event.payload.createdAt,
          completedAt: settlesTurn
            ? event.payload.updatedAt
            : thread.latestTurn?.turnId === event.payload.turnId
              ? (thread.latestTurn.completedAt ?? null)
              : null,
          assistantMessageId: event.payload.messageId,
          ...copyLatestTurnIdentities(thread.latestTurn, event.payload.turnId),
        }
      : thread.latestTurn,
  );

  // Rebind checkpoint assistant message IDs for assistant messages.
  const checkpoints =
    event.payload.role === "assistant" && event.payload.turnId !== null
      ? rebindCheckpointAssistantMessage(
          thread.checkpoints,
          event.payload.turnId,
          event.payload.messageId,
        )
      : thread.checkpoints;

  return {
    kind: "updated",
    thread: {
      ...thread,
      messages,
      checkpoints,
      latestTurn,
      updatedAt: event.occurredAt,
    },
  };
}

export function applyMessageReactionSetEvent(
  thread: OrchestrationThread,
  event: Extract<OrchestrationEvent, { readonly type: "thread.message-reaction-set" }>,
): ThreadDetailReducerResult {
  const message = thread.messages.find((entry) => entry.id === event.payload.messageId);

  if (!message) return { kind: "unchanged" };

  const withoutReaction = (message.reactions ?? []).filter(
    (reaction) =>
      reaction.botId !== event.payload.botId ||
      reaction.personId !== event.payload.personId ||
      reaction.emoji !== event.payload.emoji,
  );

  return {
    kind: "updated",
    thread: {
      ...thread,
      messages: thread.messages.map((entry) =>
        entry.id === event.payload.messageId
          ? {
              ...entry,
              reactions: event.payload.present
                ? [
                    ...withoutReaction,
                    {
                      ...(event.payload.botId !== undefined
                        ? { botId: event.payload.botId }
                        : { personId: event.payload.personId }),
                      emoji: event.payload.emoji,
                    },
                  ]
                : withoutReaction,
              updatedAt: event.payload.updatedAt,
            }
          : entry,
      ),
      updatedAt: event.payload.updatedAt,
    },
  };
}