sailfork / t3code-github / packages/ client-runtime/ src/ platform/ threadCacheEncoding.ts

import {
  omitLocalVisibleTurnItems,
  restoreLocalVisibleTurnItems,
} from "@t3tools/shared/orchestrationV2BoundedSnapshot";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import { StoredOrchestrationThreadSnapshot } from "./orchestrationCache.ts";

// Keep the full format for web/desktop; older clients discard compact records.
export const COMPACT_THREAD_CACHE_SCHEMA_VERSION = 6 as const;

const StoredCompactThreadSnapshot = StoredOrchestrationThreadSnapshot.mapFields((fields) => ({
  ...fields,
  schemaVersion: Schema.Literal(COMPACT_THREAD_CACHE_SCHEMA_VERSION),
  snapshot: fields.snapshot.mapFields((snapshotFields) => ({
    ...snapshotFields,
    // Required metadata prevents partial compact records from masquerading as full ones.
    turnItemsOmitLocalVisible: Schema.Boolean,
    turnItemCount: Schema.Int,
    visibleTurnItemCount: Schema.Int,
  })),
}));

class InvalidThreadCache extends Schema.TaggedError<InvalidThreadCache>()(
  "InvalidThreadCache",
  {},
) {}

const encodeCompact = Schema.encodeEffect(Schema.fromJsonString(StoredCompactThreadSnapshot));
const decodeCompatible = Schema.decodeUnknownEffect(
  Schema.fromJsonString(
    Schema.Union([StoredCompactThreadSnapshot, StoredOrchestrationThreadSnapshot]),
  ),
);

export const encodeStoredThreadSnapshot = Effect.fn("ThreadCache.encode")(function* (
  stored: Pick<
    typeof StoredOrchestrationThreadSnapshot.Type,
    "environmentId" | "threadId" | "snapshot"
  >,
) {
  const { snapshot } = stored;
  const compact = omitLocalVisibleTurnItems(snapshot.projection);
  return yield* encodeCompact({
    ...stored,
    schemaVersion: COMPACT_THREAD_CACHE_SCHEMA_VERSION,
    snapshot: {
      ...snapshot,
      projection: compact ?? snapshot.projection,
      turnItemsOmitLocalVisible: compact !== null,
      turnItemCount: snapshot.projection.turnItems.length,
      visibleTurnItemCount: snapshot.projection.visibleTurnItems.length,
    },
  });
});

export const decodeStoredThreadSnapshot = Effect.fn("ThreadCache.decode")(function* (raw: string) {
  const stored = yield* decodeCompatible(raw);
  if (stored.schemaVersion !== COMPACT_THREAD_CACHE_SCHEMA_VERSION) return stored;
  const { turnItemsOmitLocalVisible, turnItemCount, visibleTurnItemCount, ...snapshot } =
    stored.snapshot;
  const { projection } = snapshot;
  const threadId = projection.thread.id;
  let previousPosition = -1;
  const visibleIds = new Set<string>();
  const validRows = projection.visibleTurnItems.every((row) => {
    const identity = JSON.stringify([row.sourceThreadId, row.sourceItemId]);
    const valid =
      row.sourceItemId === row.item.id &&
      (row.sourceThreadId === row.item.threadId ||
        (row.item.type === "fork" &&
          row.item.source.type === "run" &&
          row.sourceThreadId === row.item.source.threadId)) &&
      (row.visibility !== "local" || row.sourceThreadId === threadId) &&
      (row.visibility !== "inherited" || row.sourceThreadId !== threadId) &&
      row.position > previousPosition &&
      !visibleIds.has(identity);
    previousPosition = row.position;
    visibleIds.add(identity);
    return valid;
  });
  const restored = turnItemsOmitLocalVisible
    ? restoreLocalVisibleTurnItems(projection)
    : projection;
  const itemIds = new Set<string>();
  const validItems = restored.turnItems.every((item) => {
    const valid = item.threadId === threadId && !itemIds.has(item.id);
    itemIds.add(item.id);
    return valid;
  });
  if (
    stored.threadId !== threadId ||
    restored.turnItems.length !== turnItemCount ||
    projection.visibleTurnItems.length !== visibleTurnItemCount ||
    !validRows ||
    !validItems ||
    projection.visibleTurnItems.some(
      (row) => row.sourceThreadId === threadId && !itemIds.has(row.sourceItemId),
    )
  ) {
    return yield* new InvalidThreadCache();
  }
  return { ...stored, snapshot: { ...snapshot, projection: restored } };
});