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 {
  AkeruMemoryEntityId,
  AkeruMemoryId,
  AkeruMemoryPartitionId,
  AkeruMemoryRootId,
  AkeruMemoryTenantId,
  AkeruMemoryUserId,
  BotId,
  EnvironmentId,
  ProviderInstanceId,
  ProjectId,
  ThreadId,
  TurnId,
  type AkeruMemoryRevision,
} from "@akeru/contracts";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import { vi } from "vite-plus/test";
import * as McpMemoryToolSession from "../../../mcp/McpMemoryToolSession.ts";
import type { McpCapability } from "../../../mcp/McpInvocationContext.ts";
import type { ProviderServiceShape } from "../../Services/ProviderService.ts";
import { BotUsageLedger, type BotUsageLedgerShape } from "../../../usage/BotUsageLedger.ts";

export class MemoryToolCallError extends Data.TaggedError("MemoryToolCallError")<{
  readonly cause: Error;
}> {}

export function completeLegacyTurnWithMemoryReview(
  input: Parameters<ProviderServiceShape["sendTurn"]>[0],
  turnId: TurnId,
  successfulMemoryCalls = 1,
) {
  return Effect.promise(async () => {
    if (input.persistentMemoryContext?.includes("<automatic-memory-review>")) {
      const handler = McpMemoryToolSession.readMcpMemoryToolSession(input.threadId);

      if (!handler) throw new Error("Foreground memory review handler was not registered.");

      for (let call = 0; call < successfulMemoryCalls; call += 1) {
        await handler({
          threadId: String(input.threadId),
          toolId: "memory",
          toolCallId: `foreground-memory-review-${String(turnId)}-${call}`,
          input: { target: "user", operations: [] },
          approvalMode: "require-grant",
        });
      }
    }

    return { threadId: input.threadId, turnId };
  });
}

export function privatePolicyRevisions(
  botId: BotId,
  projectId: ProjectId,
): Array<AkeruMemoryRevision> {
  const revision = (scope: AkeruMemoryRevision["partition"]["scope"], fact: string) =>
    ({
      id: AkeruMemoryId.make(`memory-${scope}`),
      rootId: AkeruMemoryRootId.make(`memory-${scope}`),
      revision: 1,
      partition: {
        tenantId: AkeruMemoryTenantId.make("local"),
        scope,
        partitionId: AkeruMemoryPartitionId.make(`${scope}-partition`),
      },
      entityKind: scope === "project" ? "project" : "bot",
      entityId: AkeruMemoryEntityId.make(scope === "project" ? String(projectId) : String(botId)),
      kind: "fact",
      value: {},
      fact,
      sourceThreadId: null,
      sourceMessageId: null,
      authorBotId: botId,
      initiatingUserId: AkeruMemoryUserId.make("owner"),
      createdAt: "2026-09-01T00:00:00.000Z",
      confirmedAt: "2026-09-01T00:00:00.000Z",
      updatedAt: "2026-09-01T00:00:00.000Z",
      confidence: 0.5,
      approvalState: "approved",
      supersedesId: null,
      supersededById: null,
      visibility: scope === "project" ? "shared" : "private",
      deletionState: "active",
      pinned: false,
      sensitive: false,
      affectedBotIds: [botId],
    }) as AkeruMemoryRevision;

  return [
    revision("bot", "Bot-private entity fact."),
    revision("bot-user", "Bot-about-you entity fact."),
    revision("project", "Shared project entity fact."),
  ];
}

export function entityMemorySection<Context>(context: Context): string {
  const match = /<entity-memory>[\s\S]*?<\/entity-memory>/u.exec(String(context ?? ""));

  return match?.[0] ?? "";
}

export function makeMemoryOnlyCredentialOptions() {
  const requests: Array<{
    readonly threadId: ThreadId;
    readonly providerInstanceId: ProviderInstanceId;
    readonly capabilities?: ReadonlySet<McpCapability>;
  }> = [];

  const revoked: Array<ThreadId> = [];

  return {
    requests,
    revoked,
    issueMcpCredential: (request: (typeof requests)[number]) => {
      requests.push(request);

      if (!request.capabilities?.has("memory")) return Effect.as(Effect.void, undefined);

      return Effect.succeed({
        config: {
          environmentId: EnvironmentId.make("environment-test"),
          threadId: request.threadId,
          providerSessionId: `session-${String(request.threadId)}`,
          providerInstanceId: request.providerInstanceId,
          endpoint: "http://127.0.0.1:1/mcp",
          authorizationHeader: "Bearer test-memory-only",
        },
      });
    },
    revokeMcpCredential: (threadId: ThreadId) =>
      Effect.sync(() => {
        revoked.push(threadId);
      }),
  };
}

export function usageLedgerFixture() {
  const reserve = vi.fn<BotUsageLedgerShape["reserve"]>(() => Effect.succeed({} as never));
  const settle = vi.fn<BotUsageLedgerShape["settle"]>(() => Effect.succeed({} as never));

  const recordMeasurement = vi.fn<BotUsageLedgerShape["recordMeasurement"]>(() =>
    Effect.succeed({} as never),
  );

  const recordStart = vi.fn<BotUsageLedgerShape["recordStart"]>(() => Effect.succeed({} as never));
  const unused = () => Effect.die("unused");

  return {
    reserve,
    settle,
    recordMeasurement,
    recordStart,
    service: BotUsageLedger.of({
      reserve,
      settle,
      bindTurn: unused,
      settleForTurn: unused,
      finalizeForTurn: unused,
      recordMeasurement,
      recordStart,
      summarize: unused,
      pricingTotals: unused,
    }),
  };
}