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.3 KB
Raw Blame
import type { AkeruControllerHarness } from "../../mastra/AkeruHarnessTypes.ts";
import type { AgentControllerShape } from "../../Services/AgentController.ts";
import { ThreadIdBrand, toProviderSession } from "./Policy.ts";

import { type ProviderRuntimeEvent } from "@akeru/contracts";

import * as Effect from "effect/Effect";

import * as PubSub from "effect/PubSub";

import * as Stream from "effect/Stream";

import { SubscriptionAuthService } from "../../../subscription-auth/service.ts";

import { AgentControllerRuntimeError } from "../../Errors.ts";

import { LegacyProviderBridge } from "../../Services/LegacyProviderBridge.ts";

import { type ResolvedEngine, type ActiveSession, type LegacyTurnMemoryState } from "./State.ts";
import { recordProviderAccessHealth } from "./ProviderAccess.ts";

export function createAuxiliaryOperations({
  bundle,
  runMastra,
  legacyProviderBridge,
  sessions,
  runtimeEvents,
  legacyHiddenWakeByTurn,
  legacyPending,
  subscriptionAuth,
  resolvedByThread,
  legacyBufferedTerminals,
  drainLegacyTerminals,
}: {
  readonly bundle: AkeruControllerHarness;
  readonly runMastra: <A>(
    operation: string,
    run: (signal: AbortSignal) => Promise<A>,
  ) => Effect.Effect<A, AgentControllerRuntimeError>;
  readonly legacyProviderBridge: LegacyProviderBridge["Service"];
  readonly sessions: Map<string, ActiveSession>;
  readonly runtimeEvents: PubSub.PubSub<ProviderRuntimeEvent>;
  readonly legacyHiddenWakeByTurn: Map<string, boolean>;
  readonly legacyPending: (key: string) => LegacyTurnMemoryState[];
  readonly subscriptionAuth: SubscriptionAuthService;
  readonly resolvedByThread: Map<string, ResolvedEngine>;
  readonly legacyBufferedTerminals: Map<string, Map<string, ProviderRuntimeEvent>>;
  readonly drainLegacyTerminals: (key: string) => Effect.Effect<void>;
}) {
  return {
    readConversationMemory: (threadId) =>
      bundle.readObservationalMemory
        ? runMastra("memory.read", () =>
            bundle.readObservationalMemory!(String(threadId), String(threadId)),
          )
        : Effect.fail(
            new AgentControllerRuntimeError({
              operation: "memory.read",
              detail: "Conversation memory is unavailable.",
            }),
          ),
    clearConversationMemory: (threadId) =>
      bundle.clearObservationalMemory
        ? runMastra("memory.clear", () =>
            bundle.clearObservationalMemory!(String(threadId), String(threadId)),
          )
        : Effect.fail(
            new AgentControllerRuntimeError({
              operation: "memory.clear",
              detail: "Conversation memory is unavailable.",
            }),
          ),
    restoreConversationMemory: (threadId, snapshot, expectedSnapshot) =>
      bundle.restoreObservationalMemory
        ? runMastra("memory.restore", () =>
            bundle.restoreObservationalMemory!(
              String(threadId),
              snapshot,
              String(threadId),
              expectedSnapshot,
            ),
          )
        : Effect.fail(
            new AgentControllerRuntimeError({
              operation: "memory.restore",
              detail: "Conversation memory restoration is unavailable.",
            }),
          ),
    listSessions: () =>
      Effect.map(legacyProviderBridge.listSessions(), (legacySessions) => [
        ...legacySessions,
        ...[...sessions.entries()].map(([threadId, active]) =>
          toProviderSession(ThreadIdBrand(threadId), active),
        ),
      ]),
    get streamEvents() {
      return Stream.merge(legacyProviderBridge.streamEvents, Stream.fromPubSub(runtimeEvents)).pipe(
        Stream.map((event) => {
          if (event.type !== "turn.started") return event;
          const key = String(event.threadId);

          const hiddenWake =
            event.turnId === undefined
              ? false
              : legacyHiddenWakeByTurn.get(`${key}:${String(event.turnId)}`) === true ||
                legacyPending(key).some(
                  (pending) => !pending.dispatchReturned && pending.hiddenWake,
                );

          return hiddenWake ? { ...event, payload: { ...event.payload, hiddenWake: true } } : event;
        }),
        Stream.tap((event) =>
          Effect.gen(function* () {
            const key = String(event.threadId);
            recordProviderAccessHealth(
              subscriptionAuth,
              event,
              resolvedByThread.get(key)?.modelSelection.model,
            );

            if (sessions.has(key)) return;
            const pendingTurns = legacyPending(key);

            if (pendingTurns.length === 0) return;

            const unseenPending = pendingTurns.filter(
              (pending) => !pending.seenEventIds.has(String(event.eventId)),
            );

            if (unseenPending.length === 0) return;

            for (const pending of unseenPending) {
              pending.seenEventIds.add(String(event.eventId));
            }

            if (event.type === "turn.completed" || event.type === "turn.aborted") {
              if (event.turnId) legacyHiddenWakeByTurn.delete(`${key}:${String(event.turnId)}`);

              if (!event.turnId) return;
              const terminals = legacyBufferedTerminals.get(key) ?? new Map();
              terminals.set(String(event.turnId), event);
              legacyBufferedTerminals.set(key, terminals);

              for (const pending of unseenPending) {
                if (!pending.dispatchReturned) {
                  pending.earlyEvents.push(event);
                }
              }

              yield* drainLegacyTerminals(key);

              return;
            }

            for (const pending of unseenPending) {
              if (!pending.dispatchReturned) {
                if (event.type === "content.delta") {
                  pending.earlyEvents.push(event);
                }

                continue;
              }

              if (!event.turnId || String(event.turnId) !== pending.turnId) continue;

              if (event.type === "content.delta" && event.payload.streamKind === "assistant_text") {
                pending.assistant += event.payload.delta;
                continue;
              }
            }
          }),
        ),
      );
    },
  } satisfies Pick<
    AgentControllerShape,
    | "readConversationMemory"
    | "clearConversationMemory"
    | "restoreConversationMemory"
    | "listSessions"
    | "streamEvents"
  >;
}