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.

5.1 KB
Raw Blame
import * as Schema from "effect/Schema";
import * as Exit from "effect/Exit";
import { flow } from "effect/Function";
import { type BotId } from "@akeru/contracts";
import {
  AKERU_MEMORY_REVIEW_BATCH_MAX_CHARS,
  AKERU_MEMORY_REVIEW_INPUT_MAX_CHARS,
  AKERU_MEMORY_REVIEW_PROMPT_INTERVAL,
} from "./BotMemoryReview.ts";

export interface BotMemoryReviewCadence {
  readonly acceptedPromptCount: number;
  readonly reviewedThroughPromptCount: number;
  readonly dueOnNextAcceptedPrompt: boolean;
}

export interface BotMemoryReviewReservation {
  readonly id: string;
  readonly botId: BotId;
  readonly groupId: string | null;
  /** @deprecated Review claims no longer use process ownership. */
  readonly ownerToken?: string;
  readonly memoryReviewIncluded: boolean;
  readonly reviewInputs: ReadonlyArray<BotMemoryReviewInput>;
  readonly pendingInput?: BotMemoryReviewInput;
}

export interface BotMemoryReviewInput {
  readonly id?: string;
  readonly threadId: string;
  readonly groupId: string | null;
  readonly text: string;
}

export interface BotMemoryReviewCadenceState {
  readonly acceptedPromptCount: number;
  readonly reviewedThroughPromptCount: number;
  readonly reviewInputs: ReadonlyArray<BotMemoryReviewInput>;
  readonly settledTurnIds?: ReadonlyArray<string>;
  readonly reviewClaim?: {
    readonly id: string;
    readonly acquiredAtMs: number;
    readonly leaseExpiresAtMs: number;
    readonly throughPromptCount: number;
    readonly inputIds: ReadonlyArray<string>;
  };
}

export const REVIEW_CLAIM_LEASE_MS = 60_000;

export const EMPTY_REVIEW_CADENCE: BotMemoryReviewCadenceState = {
  acceptedPromptCount: 0,
  reviewedThroughPromptCount: 0,
  reviewInputs: [],
};

export const CONSERVATIVE_REVIEW_CADENCE: BotMemoryReviewCadenceState = {
  acceptedPromptCount: AKERU_MEMORY_REVIEW_PROMPT_INTERVAL,
  reviewedThroughPromptCount: 0,
  reviewInputs: [],
};

export function boundReviewInputs(
  inputs: ReadonlyArray<BotMemoryReviewInput>,
): ReadonlyArray<BotMemoryReviewInput> {
  const kept: BotMemoryReviewInput[] = [];

  for (const input of inputs.toReversed()) {
    const bounded = { ...input, text: input.text.slice(0, AKERU_MEMORY_REVIEW_INPUT_MAX_CHARS) };

    if (
      kept.length >= AKERU_MEMORY_REVIEW_PROMPT_INTERVAL ||
      JSON.stringify([bounded, ...kept]).length > AKERU_MEMORY_REVIEW_BATCH_MAX_CHARS
    )
      continue;
    kept.unshift(bounded);
  }

  return kept;
}

export class InvalidReviewCadenceError extends Error {}

const ReviewInput = Schema.Struct({
  id: Schema.optional(Schema.String),
  threadId: Schema.String,
  groupId: Schema.NullOr(Schema.String),
  text: Schema.String,
});

const NonNegativeSafeInteger = Schema.Number.check(
  Schema.makeFilter((value) => Number.isSafeInteger(value) && value >= 0),
);

const ReviewClaim = Schema.Struct({
  id: Schema.String,
  acquiredAtMs: NonNegativeSafeInteger,
  leaseExpiresAtMs: NonNegativeSafeInteger,
  throughPromptCount: NonNegativeSafeInteger,
  inputIds: Schema.Array(Schema.String),
}).check(Schema.makeFilter((claim) => claim.leaseExpiresAtMs >= claim.acquiredAtMs));

const ReviewCadence = Schema.Struct({
  acceptedPromptCount: NonNegativeSafeInteger,
  reviewedThroughPromptCount: NonNegativeSafeInteger,
  reviewInputs: Schema.optional(Schema.Array(ReviewInput)),
  settledTurnIds: Schema.optional(Schema.Array(Schema.String)),
  reviewClaim: Schema.optional(ReviewClaim),
}).check(
  Schema.makeFilter((value) => value.reviewedThroughPromptCount <= value.acceptedPromptCount),
);

const decodeReviewInput = Schema.decodeUnknownExit(ReviewInput);

const decodeReviewInputs = Schema.decodeUnknownExit(
  Schema.UndefinedOr(Schema.Array(Schema.Unknown)),
);

const decodeReviewCadence = Schema.decodeUnknownSync(Schema.fromJsonString(ReviewCadence));

function normalizeReviewInput(entry: typeof ReviewInput.Type): BotMemoryReviewInput {
  return {
    ...(entry.id ? { id: entry.id } : {}),
    threadId: entry.threadId,
    groupId: entry.groupId,
    text: entry.text,
  };
}

export const parseReviewInput = flow(decodeReviewInput, (result): BotMemoryReviewInput => {
  if (Exit.isFailure(result)) throw new InvalidReviewCadenceError("A review input is invalid.");

  return normalizeReviewInput(result.value);
});

export const parseReviewInputs = flow(
  decodeReviewInputs,
  (result): ReadonlyArray<BotMemoryReviewInput> => {
    if (Exit.isFailure(result)) throw new InvalidReviewCadenceError("Review inputs are invalid.");

    return result.value?.map((value) => parseReviewInput(value)) ?? [];
  },
);

export function parseReviewCadence(raw: string): BotMemoryReviewCadenceState {
  try {
    const value = decodeReviewCadence(raw);

    return {
      acceptedPromptCount: value.acceptedPromptCount,
      reviewedThroughPromptCount: value.reviewedThroughPromptCount,
      reviewInputs: value.reviewInputs?.map(normalizeReviewInput) ?? [],
      ...(value.settledTurnIds === undefined ? {} : { settledTurnIds: value.settledTurnIds }),
      ...(value.reviewClaim === undefined ? {} : { reviewClaim: value.reviewClaim }),
    };
  } catch {
    throw new InvalidReviewCadenceError("The bot memory review cadence file is invalid.");
  }
}