letagents 0.12.11 → 0.12.13

package/shared/routing-aliases.mjs

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Stable cross-engine fold: ASCII A-Z only. Unicode case conversion varies by
+ * JS/ICU/PostgreSQL version and locale, so non-ASCII aliases are deliberately
+ * case-sensitive while exact non-ASCII labels still match everywhere.
+ */
+function foldRoutingText(value) {
+  return String(value ?? "").replace(/[A-Z]/g, (character) =>
+    String.fromCharCode(character.charCodeAt(0) + 32));
+}
+
+export function normalizeRoutingSender(value) {
+  return foldRoutingText(typeof value === "string" ? value.trim() : "")
+    .replace(/\s+/g, " ");
+}
+
+export function normalizeRoutingHandle(value) {
+  return foldRoutingText(typeof value === "string" ? value.trim() : "")
+    .replace(/[^a-z0-9_.:/-]+/g, "");
+}
+
+function routingIdentityAliasInputs(identity) {
+  const agentKey = typeof identity?.agentKey === "string"
+    ? identity.agentKey
+    : typeof identity?.agent_key === "string"
+      ? identity.agent_key
+      : "";
+  return Array.from(new Set([
+    identity?.actorLabel ?? identity?.actor_label,
+    identity?.displayName ?? identity?.display_name,
+    agentKey,
+    agentKey.split("/").pop(),
+  ].map((value) => typeof value === "string" ? value.trim() : "").filter(Boolean)));
+}
+
+export function routingIdentityAliases(identity) {
+  const aliases = new Set();
+  for (const value of routingIdentityAliasInputs(identity)) {
+    const senderAlias = normalizeRoutingSender(value);
+    if (senderAlias) aliases.add(senderAlias);
+    const handleAlias = normalizeRoutingHandle(value);
+    if (handleAlias) aliases.add(handleAlias);
+  }
+  return aliases;
+}
+
+export function routingSenderAliasRows(sender, segmentLimit = 16) {
+  const raw = typeof sender === "string" ? sender : "";
+  const fullAlias = normalizeRoutingSender(raw);
+  const byAlias = new Map();
+  if (fullAlias) byAlias.set(fullAlias, true);
+  for (const segment of raw.split("|").slice(0, Math.max(0, segmentLimit))) {
+    const alias = normalizeRoutingSender(segment);
+    if (alias && !byAlias.has(alias)) byAlias.set(alias, false);
+  }
+  return [...byAlias].map(([alias, isFull]) => ({ alias, isFull }));
+}
+
+export function routingSenderAliases(sender, segmentLimit = 16) {
+  return new Set(routingSenderAliasRows(sender, segmentLimit).map(({ alias }) => alias));
+}
+
+export function routingAliasHash(alias) {
+  return createHash("md5").update(alias).digest("hex");
+}

package/shared/sqlite-thread-routing.d.mts

@@ -0,0 +1,72 @@
+import type { RoutingIdentityLike } from "./routing-aliases.mjs";
+
+export type SqliteRoutingDatabase = {
+  exec(sql: string): void;
+  prepare(sql: string): {
+    all(...params: unknown[]): Record<string, unknown>[];
+    get(...params: unknown[]): Record<string, unknown> | undefined;
+    run(...params: unknown[]): unknown;
+  };
+};
+
+export const LOCAL_THREAD_ROUTING_BACKFILL_BATCH_SIZE: number;
+export const LOCAL_THREAD_ROUTING_LOOKUP_BATCH_SIZE: number;
+export const LOCAL_THREAD_ROUTING_BACKFILL_TIME_BUDGET_MS: number;
+export class LocalThreadRoutingProjectionUnavailableError extends Error {}
+export function ensureLocalThreadRoutingProjectionSchema(database: SqliteRoutingDatabase): void;
+export function ensureLocalThreadRoutingProjectionSchemaAsync(
+  database: SqliteRoutingDatabase,
+  options?: { maxWaitMs?: number; random?: () => number },
+): Promise<void>;
+export function runLocalSqliteWriteTransactionAsync<T>(
+  database: SqliteRoutingDatabase,
+  work: () => T,
+  options?: { maxWaitMs?: number; random?: () => number },
+): Promise<T>;
+export function projectLocalThreadRoutingMessage(
+  database: SqliteRoutingDatabase,
+  row: {
+    room_id: string;
+    number: number;
+    thread_root_number?: number | null;
+    reply_to_number?: number | null;
+    sender: string;
+    text?: string;
+    source?: string | null;
+    timestamp?: string;
+    [key: string]: unknown;
+  },
+): void;
+export function runLocalThreadRoutingBackfillBatch(
+  database: SqliteRoutingDatabase,
+  batchSize?: number,
+): { processed: number; completed: boolean };
+export function scheduleLocalThreadRoutingBackfill(
+  database: SqliteRoutingDatabase,
+  options?: {
+    onError?: (error: unknown, delayMs: number | null) => void;
+    setImmediate?: (callback: () => void) => { unref?(): void } | unknown;
+    setTimeout?: (callback: () => void, delayMs: number) => { unref?(): void } | unknown;
+  },
+): void;
+export function scheduleLocalThreadRoutingRootsRepair(
+  database: SqliteRoutingDatabase,
+  roomId: string,
+  rootNumbers: readonly number[],
+): void;
+export function invalidateLocalThreadRoutingRoots(
+  database: SqliteRoutingDatabase,
+  roomId: string,
+  rootNumbers: readonly number[],
+): void;
+export function getLocalThreadRoutingAgentKeysForRoots(
+  database: SqliteRoutingDatabase,
+  roomId: string,
+  rootNumbers: readonly number[],
+  identities: readonly RoutingIdentityLike[],
+  options?: {
+    foregroundTimeBudgetMs?: number;
+    scheduleOnTimeout?: boolean;
+    signal?: AbortSignal;
+  },
+): Promise<Map<number, Set<string>>>;