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.

20.1 KB
Raw Blame
import { Predicate } from "effect";
import {
  delegationActions,
  threadDelegations,
} from "@akeru/client-runtime/delegation-presentation";
import { botChatTimeline } from "@akeru/client-runtime/state/bot-chat-timeline";
import {
  derivePendingApprovals,
  derivePendingUserInputs,
  type PendingApproval,
  type PendingUserInput,
} from "@akeru/client-runtime/pending-requests";
import type {
  AkeruDelegationRecord,
  ChannelProvider,
  OrchestrationThread,
  OrchestrationThreadActivity,
  ThreadId,
  TurnId,
} from "@akeru/contracts";
import * as Arr from "effect/Array";
import { buildBotStepMeters, type BotStepMeterData } from "@akeru/client-runtime/bot-step-usage";
import type {
  CollapsedWorkLogEntry,
  DerivedWorkLogEntry,
  RawThreadFeedEntry,
  ThreadFeedActivity,
  ThreadFeedEntry,
} from "./threadActivityTypes";
import {
  activityOrder,
  buildWorkEntryExpandedBody,
  deriveWorkLogEntries,
  memoizeValue,
  workEntryHasExpandedBody,
  workEntryHeading,
  workEntryIcon,
  workEntryPreview,
  workEntryStatus,
  workLogEntryIsToolLike,
} from "./threadWorkLog";

export type {
  ThreadFeedActivity,
  ThreadFeedEntry,
  ThreadFeedLatestTurn,
} from "./threadActivityTypes";

export {
  buildPendingUserInputAnswers,
  isPendingUserInputOptionSelected,
  setPendingUserInputCustomAnswer,
  togglePendingUserInputOptionSelection,
} from "./pendingUserInputAnswers";

export type { PendingUserInputDraftAnswer } from "./pendingUserInputAnswers";

export { deriveGroupSpeakerLabels, deriveThreadFeedPresentation } from "./threadFeedPresentation";

export type { PendingApproval, PendingUserInput };

export { derivePendingApprovals, derivePendingUserInputs };

function isEmptyMessage(entry: RawThreadFeedEntry): boolean {
  if (entry.type !== "message") {
    return false;
  }

  const hasText = entry.message.text.trim().length > 0;
  const hasAttachments = (entry.message.attachments ?? []).length > 0;

  return !hasText && !hasAttachments;
}

function groupAdjacentActivities(entries: ReadonlyArray<RawThreadFeedEntry>): ThreadFeedEntry[] {
  const grouped: ThreadFeedEntry[] = [];
  // Mutable backing array for the trailing group so appending an activity is
  // O(1) instead of re-copying the group (which made this loop quadratic on
  // long tool runs). The array is only mutated while it is the trailing group.
  let openGroupActivities: ThreadFeedActivity[] | null = null;
  let openGroupTurnId: TurnId | null = null;

  for (const entry of entries) {
    // Skip empty messages so they don't break activity grouping.
    if (isEmptyMessage(entry)) {
      continue;
    }

    if (entry.type !== "activity") {
      grouped.push(entry);
      openGroupActivities = null;
      continue;
    }

    if (openGroupActivities !== null && openGroupTurnId === entry.turnId) {
      openGroupActivities.push(entry.activity);
      continue;
    }

    openGroupActivities = [entry.activity];
    openGroupTurnId = entry.turnId;
    grouped.push({
      type: "activity-group",
      id: entry.id,
      createdAt: entry.createdAt,
      turnId: entry.turnId,
      activities: openGroupActivities,
    });
  }

  return grouped;
}

export interface ThreadFeedDelegations {
  readonly delegations: ReadonlyArray<AkeruDelegationRecord>;
  readonly waitingOnChildren: boolean;
}

const EMPTY_THREAD_FEED_DELEGATIONS: ThreadFeedDelegations = {
  delegations: [],
  waitingOnChildren: false,
};

/**
 * The delegation slice of the environment snapshot that feeds the selected
 * chat's cards and its waiting line. Scoped to one thread: callers pass the
 * ids separately, never a joined key, so no separator can desync. JSON keeps
 * the atom quiet unless this chat's cards actually changed.
 */
export function deriveThreadFeedDelegations(
  threadId: ThreadId | undefined,
  snapshotDelegations: ReadonlyArray<AkeruDelegationRecord> | undefined,
): string {
  if (!threadId) {
    return JSON.stringify(EMPTY_THREAD_FEED_DELEGATIONS);
  }

  return JSON.stringify(threadDelegations(snapshotDelegations ?? [], threadId));
}

/**
 * Sorts activities into lifecycle order. `derivePendingApprovals` and
 * `derivePendingUserInputs` both expect this ordering; sorting once and
 * passing the result to both avoids re-sorting the full activity history
 * per derivation.
 */
export function sortThreadActivities(
  activities: ReadonlyArray<OrchestrationThreadActivity>,
): ReadonlyArray<OrchestrationThreadActivity> {
  return Arr.sort(activities, activityOrder);
}

/**
 * Drops the `delegation.<state>` delivery activities whose record renders as a
 * card; the card already shows that state and result. Activities without a
 * card, such as `delegation.retry.failed`, stay in the work log.
 */
function withoutCardedDelegationActivities(
  activities: ReadonlyArray<OrchestrationThreadActivity>,
  delegations: ReadonlyArray<AkeruDelegationRecord>,
): ReadonlyArray<OrchestrationThreadActivity> {
  if (delegations.length === 0) return activities;
  const cardIds = new Set<string>(delegations.map((delegation) => delegation.delegationId));

  return activities.filter((activity) => {
    if (!activity.kind.startsWith("delegation.")) return true;

    const payload =
      activity.payload && Predicate.isObject(activity.payload) ? activity.payload : null;

    const delegationId = payload?.delegationId;

    return !Predicate.isString(delegationId) || !cardIds.has(delegationId);
  });
}

const activityFeedDerivations = new WeakMap<
  ReadonlyArray<OrchestrationThreadActivity>,
  {
    readonly delegations: ReadonlyArray<AkeruDelegationRecord>;
    readonly botStepMeters: ReturnType<typeof buildBotStepMeters>;
    readonly workLogEntries: ReturnType<typeof deriveWorkLogEntries>;
  }
>();

const NO_FEED_DELEGATIONS: ReadonlyArray<AkeruDelegationRecord> = Object.freeze([]);

function deriveActivityFeed(
  activities: ReadonlyArray<OrchestrationThreadActivity>,
  delegations: ReadonlyArray<AkeruDelegationRecord>,
) {
  const cached = activityFeedDerivations.get(activities);

  if (cached !== undefined && sameEntries(cached.delegations, delegations)) return cached;

  const derivation = {
    delegations,
    botStepMeters: buildBotStepMeters(activities),
    workLogEntries: deriveWorkLogEntries(
      withoutCardedDelegationActivities(activities, delegations),
    ),
  };

  activityFeedDerivations.set(activities, derivation);

  return derivation;
}

export function buildThreadFeed(
  thread: Pick<OrchestrationThread, "messages" | "activities">,
  options?: {
    readonly loadedMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
    readonly localMessages?: ReadonlyArray<OrchestrationThread["messages"][number]>;
    /**
     * Delegations this chat started, from the environment snapshot's
     * `delegations` list (thread detail payloads do not carry them).
     * `botChatTimeline` anchors each card to the turn that asked for it. Cards
     * stay outside collapsed work, and the `delegation.<state>` work-log rows
     * for a record that has a card are dropped so it shows once.
     */
    readonly delegations?: ReadonlyArray<AkeruDelegationRecord>;
  },
): ThreadFeedEntry[] {
  const loadedMessages = options?.loadedMessages ?? thread.messages;

  const messages = options?.localMessages
    ? [...loadedMessages, ...options.localMessages]
    : loadedMessages;

  // Assistant replies to a channel-originated user message deliver back to that
  // provider; track the nearest preceding channel origin so the feed can label
  // delivery state without rescanning messages at render time.
  const channelProviderByMessageId = new Map<string, ChannelProvider>();
  {
    let lastChannelProvider: ChannelProvider | null = null;

    for (const message of messages) {
      if (message.role === "user") {
        lastChannelProvider = message.channelOrigin?.provider ?? null;
      } else if (message.role === "assistant" && lastChannelProvider !== null) {
        channelProviderByMessageId.set(message.id, lastChannelProvider);
      }
    }
  }

  const oldestLoadedMessageCreatedAt =
    options?.loadedMessages !== undefined ? (loadedMessages[0]?.createdAt ?? null) : null;

  const { botStepMeters, workLogEntries } = deriveActivityFeed(
    thread.activities,
    options?.delegations ?? NO_FEED_DELEGATIONS,
  );

  const timed: Array<{ readonly at: number; readonly entry: RawThreadFeedEntry }> = [];

  for (const message of messages) {
    const entry = messageFeedEntry(
      message,
      message.turnId === null ? undefined : botStepMeters.get(message.turnId),
      channelProviderByMessageId.get(message.id),
    );

    timed.push({ at: Date.parse(entry.createdAt), entry });
  }

  for (const collapsed of workLogEntries) {
    if (
      options?.loadedMessages !== undefined &&
      oldestLoadedMessageCreatedAt !== null &&
      collapsed.entry.createdAt < oldestLoadedMessageCreatedAt
    ) {
      continue;
    }

    const entry = activityFeedEntry(collapsed);
    timed.push({ at: Date.parse(entry.createdAt), entry });
  }

  // Timestamps are parsed once above; sorting on numbers avoids allocating a
  // Date per comparison.
  timed.sort((left, right) => compareFeedTimes(left.at, right.at));

  return mergeDelegationCards(
    groupAdjacentActivities(timed.map((item) => item.entry)),
    messages,
    options?.delegations ?? [],
  );
}

export function createThreadFeedBuilder() {
  let previous:
    | {
        readonly messages: OrchestrationThread["messages"];
        readonly activities: OrchestrationThread["activities"];
        readonly loadedMessages: ReadonlyArray<OrchestrationThread["messages"][number]> | undefined;
        readonly localMessages: ReadonlyArray<OrchestrationThread["messages"][number]> | undefined;
        readonly delegations: ReadonlyArray<AkeruDelegationRecord>;
        readonly feed: ThreadFeedEntry[];
      }
    | undefined;

  return (
    thread: Pick<OrchestrationThread, "messages" | "activities">,
    options?: Parameters<typeof buildThreadFeed>[1],
  ): ThreadFeedEntry[] => {
    const delegations = options?.delegations ?? NO_FEED_DELEGATIONS;

    if (
      previous !== undefined &&
      previous.messages === thread.messages &&
      previous.activities === thread.activities &&
      previous.loadedMessages === options?.loadedMessages &&
      previous.localMessages === options?.localMessages &&
      sameEntries(previous.delegations, delegations)
    ) {
      return previous.feed;
    }

    const feed = buildThreadFeed(thread, options);
    previous = {
      messages: thread.messages,
      activities: thread.activities,
      loadedMessages: options?.loadedMessages,
      localMessages: options?.localMessages,
      delegations,
      feed,
    };

    return feed;
  };
}

/** Same ordering as `Order.Date`: stable ties, unparsable times first. */
function compareFeedTimes(left: number, right: number): number {
  if (left === right) return 0;
  const leftInvalid = Number.isNaN(left);
  const rightInvalid = Number.isNaN(right);

  if (leftInvalid && rightInvalid) return 0;

  if (leftInvalid) return -1;

  if (rightInvalid) return 1;

  return left < right ? -1 : 1;
}

type MessageFeedEntry = Extract<RawThreadFeedEntry, { type: "message" }>;

// Feed entries are cached on their source objects so unchanged rows keep their
// identity while a turn streams, letting the list skip re-rendering them.
const messageFeedEntryCache = new WeakMap<
  OrchestrationThread["messages"][number],
  MessageFeedEntry
>();

function messageFeedEntry(
  message: OrchestrationThread["messages"][number],
  botStepMeter: BotStepMeterData | undefined,
  channelProvider: ChannelProvider | undefined,
): MessageFeedEntry {
  const cached = messageFeedEntryCache.get(message);

  if (
    cached !== undefined &&
    cached.channelProvider === channelProvider &&
    botStepMetersEqual(cached.botStepMeter, botStepMeter)
  ) {
    return cached;
  }

  const entry: MessageFeedEntry = {
    type: "message",
    id: message.id,
    createdAt: message.createdAt,
    message,
    ...(channelProvider === undefined ? {} : { channelProvider }),
    ...(message.turnId === null ? {} : { botStepMeter }),
  };

  messageFeedEntryCache.set(message, entry);

  return entry;
}

function botStepMetersEqual(
  left: BotStepMeterData | undefined,
  right: BotStepMeterData | undefined,
): boolean {
  if (left === right) return true;

  if (left === undefined || right === undefined) return false;

  return (
    left.tokens === right.tokens &&
    left.costUsd === right.costUsd &&
    (left.engine === right.engine ||
      (left.engine.provider === right.engine.provider &&
        left.engine.model === right.engine.model &&
        left.engine.options === right.engine.options))
  );
}

type ActivityFeedEntry = Extract<RawThreadFeedEntry, { type: "activity" }>;

// Keyed on the newest source entry; reused only when every source matches.
const activityFeedEntryCache = new WeakMap<
  DerivedWorkLogEntry,
  { readonly sources: ReadonlyArray<DerivedWorkLogEntry>; readonly entry: ActivityFeedEntry }
>();

function activityFeedEntry(collapsed: CollapsedWorkLogEntry): ActivityFeedEntry {
  const key = collapsed.sources[collapsed.sources.length - 1]!;
  const cached = activityFeedEntryCache.get(key);

  if (cached !== undefined && sameEntries(cached.sources, collapsed.sources)) {
    return cached.entry;
  }

  const entry = toActivityFeedEntry(collapsed.entry);
  activityFeedEntryCache.set(key, { sources: collapsed.sources, entry });

  return entry;
}

function sameEntries<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): boolean {
  if (left.length !== right.length) return false;

  for (let index = 0; index < left.length; index += 1) {
    if (left[index] !== right[index]) return false;
  }

  return true;
}

function toActivityFeedEntry(entry: DerivedWorkLogEntry): ActivityFeedEntry {
  const summary = workEntryHeading(entry);
  const detail = workEntryPreview(entry);
  const getFullDetail = memoizeValue(() => buildWorkEntryExpandedBody(entry));

  const getCopyText = memoizeValue(() =>
    [summary, detail, getFullDetail()]
      .filter((value, index, values): value is string => {
        return Boolean(value) && values.indexOf(value) === index;
      })
      .join("\n"),
  );

  return {
    type: "activity",
    id: entry.id,
    createdAt: entry.createdAt,
    turnId: entry.turnId,
    activity: {
      id: entry.id,
      createdAt: entry.createdAt,
      turnId: entry.turnId,
      summary,
      detail,
      canExpand: workEntryHasExpandedBody(entry),
      getFullDetail,
      getCopyText,
      icon: workEntryIcon(entry),
      toolLike: workLogEntryIsToolLike(entry),
      status: workEntryStatus(entry),
    },
  };
}

/**
 * Length of the leading run of `previous` that `next` still holds by identity.
 * Appends keep the whole previous length; a removal or replacement stops at the
 * first changed item so the caller rescans from there.
 */
export function unchangedPrefixLength(
  previous: ReadonlyArray<unknown>,
  next: ReadonlyArray<unknown>,
): number {
  const length = Math.min(previous.length, next.length);
  let index = 0;

  while (index < length && previous[index] === next[index]) {
    index += 1;
  }

  return index;
}

/**
 * Row equality for the thread feed list. Presentation rebuilds wrapper rows on
 * every feed change, so the list compares their rendered fields instead of
 * identity and keeps unchanged rows mounted without re-rendering them.
 */
export function threadFeedEntriesEqual(previous: ThreadFeedEntry, next: ThreadFeedEntry): boolean {
  if (previous === next) return true;

  if (previous.id !== next.id || previous.createdAt !== next.createdAt) return false;

  switch (previous.type) {
    case "delegation":
      return (
        next.type === "delegation" &&
        previous.delegation === next.delegation &&
        previous.actions.length === next.actions.length &&
        previous.actions.every((action, index) => action === next.actions[index])
      );
    case "message":
      return (
        next.type === "message" &&
        previous.message === next.message &&
        previous.channelProvider === next.channelProvider &&
        botStepMetersEqual(previous.botStepMeter, next.botStepMeter)
      );
    case "working":
      return next.type === "working";
    case "activity-group":
      return (
        next.type === "activity-group" &&
        previous.turnId === next.turnId &&
        previous.activities.length === next.activities.length &&
        previous.activities.every((activity, index) => activity === next.activities[index])
      );
    case "work-toggle":
      return (
        next.type === "work-toggle" &&
        previous.turnId === next.turnId &&
        previous.groupId === next.groupId &&
        previous.hiddenCount === next.hiddenCount &&
        previous.expanded === next.expanded &&
        previous.onlyToolActivities === next.onlyToolActivities
      );
    case "turn-fold":
      return (
        next.type === "turn-fold" &&
        previous.turnId === next.turnId &&
        previous.label === next.label &&
        previous.expanded === next.expanded
      );
  }
}

function mergeDelegationCards(
  grouped: ThreadFeedEntry[],
  messages: ReadonlyArray<OrchestrationThread["messages"][number]>,
  delegations: ReadonlyArray<AkeruDelegationRecord>,
): ThreadFeedEntry[] {
  // Delegation cards keep the same anchor placement as web. The shared
  // timeline runs over the thread's messages; each card lands just after the
  // feed row for the message the timeline placed it under.
  // .sort() on a copy, not .toSorted(): Hermes lacks ES2023 change-by-copy.
  const rawMessages = [...messages].sort((left, right) =>
    left.createdAt.localeCompare(right.createdAt),
  );

  // Positions are indexes into `grouped`, the array the merge below walks.
  // Activity groups count as one row here even when they hold several
  // activities; counting them by length desyncs the two index spaces and the
  // card lands late or drops entirely.
  const rawPositionByMessageId = new Map<string, number>();
  grouped.forEach((entry, position) => {
    if (entry.type === "message") {
      rawPositionByMessageId.set(entry.id, position);
    }
  });

  const delegationsByPosition = new Map<number, (ThreadFeedEntry & { type: "delegation" })[]>();
  const feedDelegations = delegations;

  const timelineEntries = botChatTimeline({
    messages: rawMessages.map((message) => ({
      id: message.id,
      turnId: message.turnId,
      createdAt: message.createdAt,
    })),
    delegations: feedDelegations,
  });

  let previousTimelineMessage:
    | Extract<(typeof timelineEntries)[number], { _tag: "Message" }>
    | undefined;

  for (const timelineEntry of timelineEntries) {
    if (Predicate.isTagged(timelineEntry, "Message")) {
      previousTimelineMessage = timelineEntry;
      continue;
    }

    if (!Predicate.isTagged(timelineEntry, "Delegation")) continue;

    const card: ThreadFeedEntry & { type: "delegation" } = {
      type: "delegation",
      id: `delegation:${timelineEntry.delegation.delegationId}`,
      createdAt: timelineEntry.delegation.createdAt,
      delegation: timelineEntry.delegation,
      actions: delegationActions(timelineEntry.delegation, feedDelegations),
    };

    if (previousTimelineMessage === undefined) {
      // Cards before the first message (empty chat or end-fallback) lead the feed.
      delegationsByPosition.set(0, [...(delegationsByPosition.get(0) ?? []), card]);
      continue;
    }

    // The preceding message can be an empty row the grouping pass dropped;
    // anchor to the nearest earlier message that is still rendered, then to
    // the front of the feed.
    let position: number | undefined;

    for (
      let rawIndex = previousTimelineMessage.index;
      rawIndex >= 0 && position === undefined;
      rawIndex--
    ) {
      const rawMessage = rawMessages[rawIndex];

      if (rawMessage !== undefined) {
        position = rawPositionByMessageId.get(rawMessage.id);
      }
    }

    const insertAt = position === undefined ? 0 : position + 1;
    delegationsByPosition.set(insertAt, [...(delegationsByPosition.get(insertAt) ?? []), card]);
  }

  if (delegationsByPosition.size === 0) return grouped;
  const merged: ThreadFeedEntry[] = [];
  grouped.forEach((entry, position) => {
    const cards = delegationsByPosition.get(position);

    if (cards) merged.push(...cards);
    merged.push(entry);
  });
  merged.push(...(delegationsByPosition.get(grouped.length) ?? []));

  return merged;
}