@remnic/core 9.3.562 → 9.3.564

package/src/search/orama-backend.ts

@@ -1,8 +1,8 @@
 import path from "node:path";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { log } from "../logger.js";
 import type { SearchBackend, SearchExecutionOptions, SearchQueryOptions, SearchResult } from "./port.js";
-import type { EmbedHelper } from "./embed-helper.js";
+import type { EmbedHelper, EmbedProviderIdentity, EmbedWithProviderResult } from "./embed-helper.js";
 import { scanMemoryDir } from "./document-scanner.js";
 import { isSearchAborted, throwIfSearchAborted } from "./abort.js";
 
@@ -54,6 +54,10 @@ export class OramaBackend implements SearchBackend {
   private db: any = null;
   private oramaModule: any = null;
   private persistModule: any = null;
+  private readonly vectorProviderCompatibility = new WeakMap<
+    object,
+    { providerIdentity: EmbedProviderIdentity; compatible: boolean }
+  >();
 
   constructor(opts: OramaBackendOptions) {
     this.dbPath = opts.dbPath;
@@ -149,26 +153,44 @@ export class OramaBackend implements SearchBackend {
     const db = await this.ensureDbForCollection(collection);
     if (isSearchAborted(execution)) return;
     if (!db) return;
-    const { search: oramaSearch, insert, remove, count } = this.oramaModule;
+    const { search: oramaSearch, insert, remove, count, getByID } = this.oramaModule;
 
     const docs = await scanMemoryDir(this.memoryDir);
     if (isSearchAborted(execution)) return;
     const docMap = new Map(docs.map((d) => [d.docid, d]));
     const { update: oramaUpdate } = this.oramaModule;
 
+    const embeddingProviderIdentity = this.embedHelper.getProviderIdentity();
+    let allRowsCompatible = !!embeddingProviderIdentity && docs.length > 0;
     // Get existing docs to diff — map user doc ID → { internalId, vector }
-    const existingDocs = new Map<string, { internalId: string; vector?: number[] }>();
+    const existingDocs = new Map<string, {
+      internalId: string;
+      vector?: number[];
+      vectorProvider?: string;
+    }>();
     const existingCount = await count(db);
     if (existingCount > 0) {
-      const allHits = await oramaSearch(db, { term: "", limit: existingCount + 100 });
+      const allHits = await oramaSearch(db, {
+        term: "",
+        limit: existingCount + 100,
+      });
       for (const hit of allHits.hits) {
         if (isSearchAborted(execution)) return;
-        if (!docMap.has(hit.document.id)) {
+        const storedDocument =
+          typeof getByID === "function"
+            ? await getByID(db, hit.id)
+            : hit.document;
+        const document = storedDocument ?? hit.document ?? {};
+        if (!docMap.has(document.id)) {
           await remove(db, hit.id);
         } else {
-          existingDocs.set(hit.document.id, {
+          existingDocs.set(document.id, {
             internalId: hit.id,
-            vector: hit.document.vector,
+            vector: this.normalizeStoredVector(document.vector) ?? undefined,
+            vectorProvider:
+              typeof document.vectorProvider === "string"
+                ? document.vectorProvider
+                : undefined,
           });
         }
       }
@@ -185,23 +207,46 @@ export class OramaBackend implements SearchBackend {
           content: doc.content,
           snippet: doc.snippet,
         };
-        if (existing.vector && existing.vector.length > 0) {
+        const preservesCompatibleProvider =
+          !!embeddingProviderIdentity &&
+          existing.vectorProvider === embeddingProviderIdentity;
+        if (preservesCompatibleProvider) {
+          if (this.isCompatibleStoredVector(existing.vector)) {
+            payload.vector = existing.vector;
+            payload.vectorProvider = existing.vectorProvider ?? "";
+          } else {
+            payload.vector = this.zeroVector();
+            payload.vectorProvider = "";
+            allRowsCompatible = false;
+          }
+        } else if (!embeddingProviderIdentity && this.isCompatibleStoredVector(existing.vector)) {
           payload.vector = existing.vector;
+          payload.vectorProvider = existing.vectorProvider ?? "";
+          allRowsCompatible = false;
+        } else {
+          payload.vector = this.zeroVector();
+          payload.vectorProvider = "";
+          allRowsCompatible = false;
         }
         try {
           await oramaUpdate(db, existing.internalId, payload);
         } catch {
+          allRowsCompatible = false;
           // Update failed — skip and continue with remaining docs
         }
       } else {
+        allRowsCompatible = false;
         try {
           await insert(db, {
             id: doc.docid,
             path: doc.path,
             content: doc.content,
             snippet: doc.snippet,
+            vector: this.zeroVector(),
+            vectorProvider: "",
           });
         } catch {
+          allRowsCompatible = false;
           // Duplicate id edge case — skip
         }
       }
@@ -209,6 +254,11 @@ export class OramaBackend implements SearchBackend {
 
     if (isSearchAborted(execution)) return;
     await this.persistDbForCollection(db, collection);
+    this.rememberVectorProviderCompatibility(
+      db,
+      embeddingProviderIdentity,
+      allRowsCompatible,
+    );
   }
 
   async embed(): Promise<void> {
@@ -225,30 +275,80 @@ export class OramaBackend implements SearchBackend {
     const existingCount = await count(db);
     if (existingCount === 0) return;
 
-    // Find docs without vectors
+    const embeddingProviderIdentity = this.embedHelper.getProviderIdentity();
+    // Find docs without vectors or with vectors from a different provider.
     const allHits = await oramaSearch(db, { term: "", limit: existingCount + 100 });
-    const needsEmbed = allHits.hits.filter((h: any) => !h.document.vector || h.document.vector.length === 0);
-
-    if (needsEmbed.length === 0) return;
+    const needsEmbed = allHits.hits.filter((h: any) => {
+      const vector = this.normalizeStoredVector(h.document?.vector);
+      return (
+        (embeddingProviderIdentity &&
+          h.document?.vectorProvider !== embeddingProviderIdentity) ||
+        !this.isCompatibleStoredVector(vector)
+      );
+    });
+
+    if (needsEmbed.length === 0) {
+      this.rememberVectorProviderCompatibility(db, embeddingProviderIdentity, true);
+      return;
+    }
 
-    const texts = needsEmbed.map((h: any) => h.document.content as string);
-    const vectors = await this.embedHelper.embedBatch(texts);
+    let rowsToEmbed = needsEmbed;
+    let embedResult = await this.embedHelper.embedBatchWithProvider(
+      rowsToEmbed.map((h: any) => h.document.content as string),
+    );
+    if (!embedResult) return;
+    if (
+      embeddingProviderIdentity &&
+      embedResult.providerIdentity !== embeddingProviderIdentity
+    ) {
+      const effectiveProviderIdentity = embedResult.providerIdentity;
+      const originalIds = new Set(rowsToEmbed.map((h: any) => h.id));
+      const effectiveNeedsEmbed = allHits.hits.filter((h: any) => {
+        const vector = this.normalizeStoredVector(h.document?.vector);
+        return (
+          h.document?.vectorProvider !== effectiveProviderIdentity ||
+          !this.isCompatibleStoredVector(vector)
+        );
+      });
+      const sameRows =
+        effectiveNeedsEmbed.length === rowsToEmbed.length &&
+        effectiveNeedsEmbed.every((h: any) => originalIds.has(h.id));
+      if (!sameRows) {
+        const effectiveTexts = effectiveNeedsEmbed.map((h: any) => h.document.content as string);
+        const effectiveEmbedResult = await this.embedHelper.embedBatchWithProvider(effectiveTexts);
+        if (effectiveEmbedResult) {
+          rowsToEmbed = effectiveNeedsEmbed;
+          embedResult = effectiveEmbedResult;
+        }
+      }
+    }
+    const { vectors, providerIdentity } = embedResult;
 
-    for (let i = 0; i < needsEmbed.length; i++) {
+    let allEmbedded = true;
+    for (let i = 0; i < rowsToEmbed.length; i++) {
       const vec = vectors[i];
-      if (!vec) continue;
+      if (!this.isExpectedDimensionVector(vec)) {
+        allEmbedded = false;
+        continue;
+      }
       // Orama update is remove+insert — must include all fields to avoid data loss
-      const doc = needsEmbed[i].document;
-      await oramaUpdate(db, needsEmbed[i].id, {
+      const doc = rowsToEmbed[i].document;
+      await oramaUpdate(db, rowsToEmbed[i].id, {
         id: doc.id,
         path: doc.path,
         content: doc.content,
         snippet: doc.snippet,
         vector: vec,
+        vectorProvider: providerIdentity,
       });
     }
 
     await this.persistDbForCollection(db, collection);
+    if (allEmbedded) {
+      this.rememberVectorProviderCompatibility(db, providerIdentity, true);
+    } else {
+      this.rememberVectorProviderCompatibility(db, providerIdentity, false);
+    }
   }
 
   async ensureCollection(
@@ -277,25 +377,19 @@ export class OramaBackend implements SearchBackend {
     await mkdir(this.dbPath, { recursive: true });
     const filePath = this.dbFilePath(this.collection);
 
+    let raw: string;
     try {
-      const raw = await readFile(filePath, "utf-8");
-      this.db = await this.persistModule.restore("json", raw);
-      return this.db;
+      raw = await readFile(filePath, "utf-8");
     } catch {
       // No existing DB — create fresh
+      this.db = await this.createDb();
+      return this.db;
     }
 
-    const { create } = this.oramaModule;
-    const schema: Record<string, string> = {
-      id: "string",
-      path: "string",
-      content: "string",
-      snippet: "string",
-    };
-    if (this.embedHelper.isAvailable()) {
-      schema.vector = `vector[${this.embeddingDimension}]`;
-    }
-    this.db = await create({ schema });
+    this.db = await this.migrateLegacyVectorProviderSchema(
+      await this.persistModule.restore("json", raw),
+      this.collection,
+    );
     return this.db;
   }
 
@@ -307,31 +401,92 @@ export class OramaBackend implements SearchBackend {
     await mkdir(this.dbPath, { recursive: true });
     const filePath = this.dbFilePath(collection);
 
+    let raw: string;
     try {
-      const raw = await readFile(filePath, "utf-8");
-      return await this.persistModule.restore("json", raw);
+      raw = await readFile(filePath, "utf-8");
     } catch {
       // No existing DB — create fresh
+      return await this.createDb();
     }
 
+    return await this.migrateLegacyVectorProviderSchema(
+      await this.persistModule.restore("json", raw),
+      collection,
+    );
+  }
+
+  private async createDb(): Promise<any> {
     const { create } = this.oramaModule;
     const schema: Record<string, string> = {
       id: "string",
       path: "string",
       content: "string",
       snippet: "string",
+      vectorProvider: "string",
+      vector: `vector[${this.embeddingDimension}]`,
     };
-    if (this.embedHelper.isAvailable()) {
-      schema.vector = `vector[${this.embeddingDimension}]`;
-    }
     return await create({ schema });
   }
 
+  private async migrateLegacyVectorProviderSchema(db: any, collection: string): Promise<any> {
+    const { search: oramaSearch, count, insert } = this.oramaModule;
+    const existingCount = await count(db);
+    if (existingCount === 0) {
+      const migrated = await this.createDb();
+      await this.persistDbForCollection(migrated, collection);
+      return migrated;
+    }
+
+    const allHits = await oramaSearch(db, { term: "", limit: existingCount + 100 });
+    const hits = allHits.hits ?? [];
+    const needsMigration = hits.some((hit: any) =>
+      typeof hit.document?.vectorProvider !== "string"
+    );
+    if (!needsMigration) return db;
+
+    const migrated = await this.createDb();
+    for (const hit of hits) {
+      const doc = this.getStoredDocument(db, hit);
+      const vector = this.getStoredVector(db, hit, doc);
+      const payload: Record<string, unknown> = {
+        id: typeof doc.id === "string" && doc.id.length > 0 ? doc.id : String(hit.id),
+        path: typeof doc.path === "string" ? doc.path : "",
+        content: typeof doc.content === "string" ? doc.content : "",
+        snippet:
+          typeof doc.snippet === "string"
+            ? doc.snippet
+            : typeof doc.content === "string"
+              ? doc.content.slice(0, 200)
+              : "",
+        vectorProvider:
+          typeof doc.vectorProvider === "string" ? doc.vectorProvider : "",
+      };
+      if (vector) {
+        payload.vector = vector;
+      } else {
+        payload.vector = this.zeroVector();
+      }
+      await insert(migrated, payload);
+    }
+    await this.persistDbForCollection(migrated, collection);
+    return migrated;
+  }
+
   private async persistDbForCollection(db: any, collection: string): Promise<void> {
     const data = await this.persistModule.persist(db, "json");
     const filePath = this.dbFilePath(collection);
     await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, data, "utf-8");
+    const tempPath = path.join(
+      path.dirname(filePath),
+      `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`,
+    );
+    try {
+      await writeFile(tempPath, data, "utf-8");
+      await rename(tempPath, filePath);
+    } catch (err) {
+      await rm(tempPath, { force: true }).catch(() => undefined);
+      throw err;
+    }
   }
 
   private dbFilePath(collection: string): string {
@@ -353,8 +508,13 @@ export class OramaBackend implements SearchBackend {
     try {
       await this.ensureModules();
       const raw = await readFile(filePath, "utf-8");
-      return await this.persistModule.restore("json", raw);
-    } catch {
+      const collection = path.basename(filePath, ".msp");
+      return await this.migrateLegacyVectorProviderSchema(
+        await this.persistModule.restore("json", raw),
+        collection,
+      );
+    } catch (err) {
+      log.debug(`OramaBackend failed to load ${filePath}: ${err}`);
       return null;
     }
   }
@@ -375,22 +535,22 @@ export class OramaBackend implements SearchBackend {
       if (mode === "fulltext") {
         searchParams = { term: query, limit };
       } else if (mode === "vector") {
-        const vec = await this.embedHelper.embed(query, { signal: execution?.signal });
+        const embedResult = await this.resolveCompatibleQueryEmbedding(db, query, execution);
         throwIfSearchAborted(execution, `OramaBackend ${mode} search aborted`);
-        if (!vec) {
+        if (!embedResult) {
           // Fall back to fulltext if no embeddings available
           searchParams = { term: query, limit };
         } else {
-          searchParams = { mode: "vector", vector: { value: vec, property: "vector" }, limit };
+          searchParams = { mode: "vector", vector: { value: embedResult.vector, property: "vector" }, limit };
         }
       } else {
         // hybrid
-        const vec = await this.embedHelper.embed(query, { signal: execution?.signal });
+        const embedResult = await this.resolveCompatibleQueryEmbedding(db, query, execution);
         throwIfSearchAborted(execution, `OramaBackend ${mode} search aborted`);
-        if (!vec) {
+        if (!embedResult) {
           searchParams = { term: query, limit };
         } else {
-          searchParams = { mode: "hybrid", term: query, vector: { value: vec, property: "vector" }, limit };
+          searchParams = { mode: "hybrid", term: query, vector: { value: embedResult.vector, property: "vector" }, limit };
         }
       }
 
@@ -408,4 +568,215 @@ export class OramaBackend implements SearchBackend {
       return [];
     }
   }
+
+  private async resolveCompatibleQueryEmbedding(
+    db: any,
+    query: string,
+    execution?: SearchExecutionOptions,
+  ): Promise<EmbedWithProviderResult | null> {
+    const embedResult = await this.embedHelper.embedWithProvider(query, { signal: execution?.signal });
+    throwIfSearchAborted(execution, "OramaBackend query embedding aborted");
+    if (!embedResult || !this.isExpectedDimensionVector(embedResult.vector)) return null;
+
+    const storedProviderIdentity = await this.findCompatibleStoredVectorProvider(db, execution);
+    if (!storedProviderIdentity) {
+      this.rememberVectorProviderCompatibility(db, embedResult.providerIdentity, false);
+      return null;
+    }
+    if (storedProviderIdentity === embedResult.providerIdentity) return embedResult;
+
+    const fallbackEmbed = await this.embedQueryWithStoredFallbackProvider(query, storedProviderIdentity, execution);
+    throwIfSearchAborted(execution, "OramaBackend fallback query embedding aborted");
+    if (
+      fallbackEmbed &&
+      fallbackEmbed.providerIdentity === storedProviderIdentity &&
+      this.isExpectedDimensionVector(fallbackEmbed.vector)
+    ) {
+      return fallbackEmbed;
+    }
+
+    this.rememberVectorProviderCompatibility(db, embedResult.providerIdentity, false);
+    return null;
+  }
+
+  private async embedQueryWithStoredFallbackProvider(
+    query: string,
+    providerIdentity: EmbedProviderIdentity,
+    execution?: SearchExecutionOptions,
+  ): Promise<EmbedWithProviderResult | null> {
+    const embedWithIdentity = (this.embedHelper as unknown as {
+      embedWithFallbackProviderIdentity?: (
+        text: string,
+        identity: EmbedProviderIdentity,
+        options?: { signal?: AbortSignal },
+      ) => Promise<EmbedWithProviderResult | null>;
+    }).embedWithFallbackProviderIdentity;
+    if (typeof embedWithIdentity !== "function") return null;
+    return embedWithIdentity.call(this.embedHelper, query, providerIdentity, { signal: execution?.signal });
+  }
+
+  private async findCompatibleStoredVectorProvider(
+    db: any,
+    execution?: SearchExecutionOptions,
+  ): Promise<EmbedProviderIdentity | null> {
+    const { search: oramaSearch, count } = this.oramaModule;
+    try {
+      const cached = this.vectorProviderCompatibility.get(db);
+      if (cached?.compatible) return cached.providerIdentity;
+      const existingCount = await count(db);
+      if (existingCount === 0) return null;
+      const allHits = await oramaSearch(db, {
+        term: "",
+        limit: existingCount + 100,
+        properties: ["vectorProvider"],
+      });
+      let providerIdentity: EmbedProviderIdentity | null = null;
+      let compatible = (allHits.hits ?? []).length > 0;
+      for (const hit of allHits.hits ?? []) {
+        throwIfSearchAborted(execution, "OramaBackend vector provider check aborted");
+        const doc = this.getStoredDocument(db, hit);
+        if (
+          typeof doc.vectorProvider !== "string" ||
+          doc.vectorProvider.length === 0 ||
+          !this.isCompatibleStoredVector(this.getStoredVector(db, hit, doc))
+        ) {
+          compatible = false;
+          break;
+        }
+        if (providerIdentity && doc.vectorProvider !== providerIdentity) {
+          compatible = false;
+          break;
+        }
+        providerIdentity = doc.vectorProvider as EmbedProviderIdentity;
+      }
+      if (compatible && providerIdentity) {
+        this.vectorProviderCompatibility.set(db, {
+          providerIdentity,
+          compatible: true,
+        });
+        return providerIdentity;
+      }
+      return null;
+    } catch (err) {
+      if (isSearchAborted(execution)) throw err;
+      log.debug(`OramaBackend stored vector provider check failed: ${err}`);
+      return null;
+    }
+  }
+
+  private async dbHasCompatibleVectors(
+    db: any,
+    providerIdentity: EmbedProviderIdentity,
+    execution?: SearchExecutionOptions,
+  ): Promise<boolean> {
+    const { search: oramaSearch, count } = this.oramaModule;
+    try {
+      const cached = this.vectorProviderCompatibility.get(db);
+      if (cached?.providerIdentity === providerIdentity) return cached.compatible;
+      const existingCount = await count(db);
+      if (existingCount === 0) return false;
+      const allHits = await oramaSearch(db, {
+        term: "",
+        limit: existingCount + 100,
+        properties: ["vectorProvider"],
+      });
+      let compatible = (allHits.hits ?? []).length > 0;
+      for (const hit of allHits.hits ?? []) {
+        throwIfSearchAborted(execution, "OramaBackend vector provider check aborted");
+        const doc = this.getStoredDocument(db, hit);
+        if (
+          doc.vectorProvider !== providerIdentity ||
+          !this.isCompatibleStoredVector(this.getStoredVector(db, hit, doc))
+        ) {
+          compatible = false;
+          break;
+        }
+      }
+      this.vectorProviderCompatibility.set(db, { providerIdentity, compatible });
+      return compatible;
+    } catch (err) {
+      if (isSearchAborted(execution)) throw err;
+      log.debug(`OramaBackend vector provider check failed: ${err}`);
+      return false;
+    }
+  }
+
+  private rememberVectorProviderCompatibility(
+    db: unknown,
+    providerIdentity: EmbedProviderIdentity | null,
+    compatible: boolean,
+  ): void {
+    if (!db || typeof db !== "object") return;
+    if (!providerIdentity) {
+      this.vectorProviderCompatibility.delete(db);
+      return;
+    }
+    this.vectorProviderCompatibility.set(db, { providerIdentity, compatible });
+  }
+
+  private getStoredDocument(db: any, hit: any): Record<string, unknown> {
+    const internalId = this.getInternalDocumentId(db, hit);
+    const internalDoc =
+      internalId !== undefined && internalId !== null
+        ? db?.data?.docs?.docs?.[String(internalId)]
+        : undefined;
+    if (internalDoc && typeof internalDoc === "object") {
+      return internalDoc as Record<string, unknown>;
+    }
+    return hit?.document && typeof hit.document === "object"
+      ? hit.document as Record<string, unknown>
+      : {};
+  }
+
+  private getStoredVector(db: any, hit: any, doc: Record<string, unknown>): number[] | null {
+    const documentVector = this.normalizeStoredVector(doc.vector);
+    if (documentVector) return documentVector;
+    const internalId = this.getInternalDocumentId(db, hit);
+    if (internalId === undefined || internalId === null) return null;
+    const vectorEntry = db?.data?.index?.vectorIndexes?.vector?.node?.vectors?.get?.(internalId);
+    const vector = Array.isArray(vectorEntry) ? vectorEntry[1] : vectorEntry;
+    return this.normalizeStoredVector(vector);
+  }
+
+  private getInternalDocumentId(db: any, hit: any): unknown {
+    const publicId =
+      typeof hit?.id === "string"
+        ? hit.id
+        : typeof hit?.document?.id === "string"
+          ? hit.document.id
+          : undefined;
+    return publicId && typeof db?.internalDocumentIDStore?.idToInternalId?.get === "function"
+      ? db.internalDocumentIDStore.idToInternalId.get(publicId)
+      : undefined;
+  }
+
+  private isExpectedDimensionVector(vector: number[] | null | undefined): vector is number[] {
+    return Array.isArray(vector) && vector.length === this.embeddingDimension;
+  }
+
+  private isCompatibleStoredVector(vector: unknown): vector is number[] {
+    if (!vector || typeof vector !== "object") return false;
+    const arr = Array.from(vector as ArrayLike<number>);
+    return (
+      arr.length === this.embeddingDimension &&
+      arr.every((value) => Number.isFinite(value)) &&
+      arr.some((value) => value !== 0)
+    );
+  }
+
+  private zeroVector(): number[] {
+    return Array.from({ length: this.embeddingDimension }, () => 0);
+  }
+
+  private normalizeStoredVector(vector: unknown): number[] | null {
+    const values =
+      Array.isArray(vector)
+        ? vector
+        : ArrayBuffer.isView(vector) && !(vector instanceof DataView)
+          ? Array.from(vector as unknown as ArrayLike<unknown>)
+          : null;
+    if (!values || values.length !== this.embeddingDimension) return null;
+    const normalized = values.map((value) => Number(value));
+    return normalized.every((value) => Number.isFinite(value)) ? normalized : null;
+  }
 }

package/src/types.ts

@@ -585,6 +585,14 @@ export interface PluginConfig {
   qmdGenerateModel?: string;
   embeddingFallbackEnabled: boolean;
   embeddingFallbackProvider: "auto" | "openai" | "local";
+  /**
+   * Host adapters may register an embedding provider scoped to this memoryDir.
+   * Core remains host-agnostic: when no provider is registered, the existing
+   * OpenAI/local fallback path is used.
+   */
+  hostEmbeddingProviderEnabled: boolean;
+  hostEmbeddingProviderId?: string;
+  hostEmbeddingProviderModel?: string;
   /**
    * Optional model identifier for local embedding fallback requests.
    *
@@ -816,6 +824,10 @@ export interface PluginConfig {
   commandsListEnabled: boolean;
   openclawToolsEnabled: boolean;
   openclawToolSnippetMaxChars: number;
+  openclawMessageReceivedCaptureEnabled: boolean;
+  openclawReplyMetadataCaptureEnabled: boolean;
+  openclawReplyMetadataExtractionHintsEnabled: boolean;
+  openclawChannelEnvelopeCleaningEnabled: boolean;
   sessionTogglesEnabled: boolean;
   verboseRecallVisibility: boolean;
   recallTranscriptsEnabled: boolean;
@@ -3066,6 +3078,11 @@ export interface TranscriptEntry {
   metadata?: {
     compactAfter?: boolean;
     compactionId?: string | null;
+    messageId?: string;
+    threadId?: string;
+    replyToId?: string;
+    replyToBody?: string;
+    replyToSender?: string;
   };
 }