ocean-brain 0.8.2 → 0.11.0

package/server/dist/features/search/hybrid-search.js

@@ -0,0 +1,176 @@
+import {
+  buildNoteSearchText,
+  NOTE_SEARCH_TEXT_SCHEMA_VERSION,
+  parseNoteSearchQuery
+} from "../../features/note/services/search.js";
+import models from "../../models.js";
+import { runDataMaintenanceInBackground } from "../../modules/data-maintenance.js";
+import { fuseHybridSearchRanks } from "./hybrid-ranking.js";
+import { getDefaultSemanticSearchManager } from "./search-manager.js";
+const MAX_HYBRID_CANDIDATES = 80;
+const MAX_HYBRID_SEMANTIC_CANDIDATES = 30;
+const unavailableSemanticAttempt = (error) => ({
+  available: false,
+  used: false,
+  matches: [],
+  error: error instanceof Error ? error.message : "Semantic search is unavailable."
+});
+const buildLexicalWhere = (query) => {
+  const parsedQuery = parseNoteSearchQuery(query);
+  if (!parsedQuery.hasFilters) {
+    return void 0;
+  }
+  return {
+    AND: [
+      { searchableTextVersion: NOTE_SEARCH_TEXT_SCHEMA_VERSION },
+      ...parsedQuery.included.length > 0 ? [
+        {
+          OR: parsedQuery.included.map((term) => ({ searchableText: { contains: term } }))
+        }
+      ] : [],
+      ...parsedQuery.excluded.map((term) => ({ NOT: { searchableText: { contains: term } } }))
+    ]
+  };
+};
+const matchesHybridLexicalQuery = (searchableText, query) => {
+  const parsedQuery = parseNoteSearchQuery(query);
+  const normalizedSearchableText = searchableText.toLowerCase();
+  const includesAnyTerm = parsedQuery.included.length === 0 || parsedQuery.included.some((term) => normalizedSearchableText.includes(term));
+  return includesAnyTerm && parsedQuery.excluded.every((term) => !normalizedSearchableText.includes(term));
+};
+const scoreLexicalCandidate = (candidate, query) => {
+  const parsedQuery = parseNoteSearchQuery(query);
+  const phrase = parsedQuery.included.join(" ");
+  const title = candidate.title.toLowerCase();
+  const searchableText = candidate.searchableText.toLowerCase();
+  const matchingTermCount = parsedQuery.included.filter((term) => searchableText.includes(term)).length;
+  let score = 0;
+  if (phrase && title === phrase) {
+    score += 100;
+  } else if (phrase && title.includes(phrase)) {
+    score += 40;
+  }
+  if (phrase && searchableText.includes(phrase)) {
+    score += 15;
+  }
+  if (parsedQuery.included.length > 1 && matchingTermCount === parsedQuery.included.length) {
+    score += 20;
+  }
+  for (const term of parsedQuery.included) {
+    if (title.includes(term)) {
+      score += 8;
+    }
+    if (searchableText.includes(term)) {
+      score += 1;
+    }
+  }
+  return score;
+};
+const rankLexicalCandidates = (candidates, query) => {
+  return [...candidates].sort((left, right) => {
+    const scoreDifference = scoreLexicalCandidate(right, query) - scoreLexicalCandidate(left, query);
+    if (scoreDifference !== 0) {
+      return scoreDifference;
+    }
+    const updatedAtDifference = right.updatedAt.getTime() - left.updatedAt.getTime();
+    return updatedAtDifference !== 0 ? updatedAtDifference : left.id - right.id;
+  });
+};
+const listDefaultLexicalNoteIds = async (query, limit) => {
+  const where = buildLexicalWhere(query);
+  if (!where) {
+    return [];
+  }
+  const [freshCandidates, staleCandidates] = await Promise.all([
+    models.note.findMany({
+      where,
+      select: {
+        id: true,
+        title: true,
+        searchableText: true,
+        updatedAt: true
+      }
+    }),
+    models.note.findMany({
+      where: { searchableTextVersion: { not: NOTE_SEARCH_TEXT_SCHEMA_VERSION } },
+      select: {
+        id: true,
+        title: true,
+        content: true,
+        searchableText: true,
+        updatedAt: true
+      }
+    })
+  ]);
+  if (staleCandidates.length > 0) {
+    void runDataMaintenanceInBackground();
+  }
+  const matchingStaleCandidates = staleCandidates.map((candidate) => ({
+    ...candidate,
+    searchableText: buildNoteSearchText(candidate)
+  })).filter((candidate) => matchesHybridLexicalQuery(candidate.searchableText, query));
+  return rankLexicalCandidates([...freshCandidates, ...matchingStaleCandidates], query).slice(0, limit).map((candidate) => candidate.id);
+};
+const defaultDependencies = {
+  listLexicalNoteIds: listDefaultLexicalNoteIds,
+  trySemanticSearch: (query, limit) => getDefaultSemanticSearchManager().trySearch(query, limit),
+  findNotesByIds: (ids) => models.note.findMany({ where: { id: { in: ids } } })
+};
+const createHybridNoteSearch = (dependencies = defaultDependencies) => {
+  return async ({
+    query,
+    limit,
+    offset,
+    mode = "hybrid"
+  }) => {
+    const normalizedQuery = query.trim();
+    if (!normalizedQuery || limit <= 0 || offset < 0) {
+      return {
+        totalCount: 0,
+        notes: [],
+        matches: [],
+        semanticAvailable: false,
+        semanticUsed: false,
+        semanticError: null
+      };
+    }
+    const candidateLimit = MAX_HYBRID_CANDIDATES;
+    const semanticCandidateLimit = mode === "hybrid" ? MAX_HYBRID_SEMANTIC_CANDIDATES : MAX_HYBRID_CANDIDATES;
+    const [lexicalNoteIds, semanticAttempt] = await Promise.all([
+      mode === "semantic" ? Promise.resolve([]) : dependencies.listLexicalNoteIds(normalizedQuery, candidateLimit),
+      mode === "lexical" ? Promise.resolve({
+        available: false,
+        used: false,
+        matches: [],
+        error: null
+      }) : dependencies.trySemanticSearch(normalizedQuery, semanticCandidateLimit).catch((error) => unavailableSemanticAttempt(error))
+    ]);
+    const rankedCandidates = fuseHybridSearchRanks({
+      lexicalNoteIds,
+      semanticNoteIds: semanticAttempt.matches.slice(0, semanticCandidateLimit).map((match) => match.noteId)
+    });
+    const pageCandidates = rankedCandidates.slice(offset, offset + limit);
+    const notes = await dependencies.findNotesByIds(pageCandidates.map((candidate) => candidate.noteId));
+    const notesById = new Map(notes.map((note) => [note.id, note]));
+    const existingCandidates = pageCandidates.filter((candidate) => notesById.has(candidate.noteId));
+    return {
+      totalCount: rankedCandidates.length,
+      notes: existingCandidates.map((candidate) => notesById.get(candidate.noteId)),
+      matches: existingCandidates.map((candidate) => ({
+        noteId: candidate.noteId,
+        lexical: candidate.lexicalRank !== null,
+        semantic: candidate.semanticRank !== null
+      })),
+      semanticAvailable: semanticAttempt.available,
+      semanticUsed: semanticAttempt.used,
+      semanticError: semanticAttempt.error
+    };
+  };
+};
+const searchNotesHybrid = createHybridNoteSearch();
+export {
+  createHybridNoteSearch,
+  matchesHybridLexicalQuery,
+  rankLexicalCandidates,
+  searchNotesHybrid
+};

package/server/dist/features/search/note-change.js

@@ -0,0 +1,16 @@
+import { EventEmitter } from "node:events";
+const NOTE_CHANGE_CHANNEL = "semantic-search-note-change";
+const noteChangeEmitter = new EventEmitter();
+const notifySemanticSearchNoteChanged = (noteId) => {
+  if (Number.isInteger(noteId) && noteId > 0) {
+    noteChangeEmitter.emit(NOTE_CHANGE_CHANNEL, noteId);
+  }
+};
+const subscribeSemanticSearchNoteChanges = (listener) => {
+  noteChangeEmitter.on(NOTE_CHANGE_CHANNEL, listener);
+  return () => noteChangeEmitter.off(NOTE_CHANGE_CHANNEL, listener);
+};
+export {
+  notifySemanticSearchNoteChanged,
+  subscribeSemanticSearchNoteChanges
+};

package/server/dist/features/search/note-chunking.js

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import { extractVisibleSearchTextFromContent } from "../../features/note/services/search.js";
+const NOTE_EMBEDDING_TEXT_SCHEMA_VERSION = 1;
+const DEFAULT_NOTE_CHUNK_MAX_LENGTH = 900;
+const DEFAULT_NOTE_CHUNK_OVERLAP = 120;
+const normalizeText = (value) => value.replace(/\s+/g, " ").trim();
+const findWindowEnd = (text, start, maxLength) => {
+  const desiredEnd = Math.min(text.length, start + maxLength);
+  if (desiredEnd === text.length) {
+    return desiredEnd;
+  }
+  const minimumEnd = start + Math.floor(maxLength * 0.7);
+  const breakAt = text.lastIndexOf(" ", desiredEnd);
+  return breakAt >= minimumEnd ? breakAt : desiredEnd;
+};
+const findNextWindowStart = (text, start, end, overlap) => {
+  const desiredStart = Math.max(start + 1, end - overlap);
+  const nextSpace = text.indexOf(" ", desiredStart);
+  if (nextSpace === -1 || nextSpace >= end) {
+    return desiredStart;
+  }
+  return nextSpace + 1;
+};
+const splitSearchText = (text, options = {}) => {
+  const normalizedText = normalizeText(text);
+  if (!normalizedText) {
+    return [];
+  }
+  const maxLength = options.maxLength ?? DEFAULT_NOTE_CHUNK_MAX_LENGTH;
+  const overlap = options.overlap ?? DEFAULT_NOTE_CHUNK_OVERLAP;
+  if (!Number.isInteger(maxLength) || maxLength < 100) {
+    throw new Error("Note chunk maxLength must be an integer of at least 100.");
+  }
+  if (!Number.isInteger(overlap) || overlap < 0 || overlap >= maxLength) {
+    throw new Error("Note chunk overlap must be a non-negative integer smaller than maxLength.");
+  }
+  const chunks = [];
+  let start = 0;
+  while (start < normalizedText.length) {
+    const end = findWindowEnd(normalizedText, start, maxLength);
+    const chunk = normalizedText.slice(start, end).trim();
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    if (end >= normalizedText.length) {
+      break;
+    }
+    start = findNextWindowStart(normalizedText, start, end, overlap);
+  }
+  return chunks;
+};
+const buildSourceHash = (title, body) => {
+  return createHash("sha256").update(`${NOTE_EMBEDDING_TEXT_SCHEMA_VERSION}\0${title}\0${body}`).digest("hex");
+};
+const buildNoteEmbeddingChunks = (note, options = {}) => {
+  const title = normalizeText(note.title);
+  const body = normalizeText(extractVisibleSearchTextFromContent(note.content));
+  const bodyChunks = splitSearchText(body, options);
+  const searchableChunks = bodyChunks.length > 0 ? bodyChunks : title ? [""] : [];
+  const sourceHash = buildSourceHash(title, body);
+  return searchableChunks.map((chunk, chunkIndex) => ({
+    noteId: note.id,
+    chunkIndex,
+    sourceHash,
+    text: title ? `Title: ${title}
+Content: ${chunk}`.trimEnd() : chunk
+  }));
+};
+export {
+  DEFAULT_NOTE_CHUNK_MAX_LENGTH,
+  DEFAULT_NOTE_CHUNK_OVERLAP,
+  NOTE_EMBEDDING_TEXT_SCHEMA_VERSION,
+  buildNoteEmbeddingChunks,
+  splitSearchText
+};

package/server/dist/features/search/related-notes.js

@@ -0,0 +1,186 @@
+import models, { Prisma } from "../../models.js";
+const MAX_RELATED_NOTES = 5;
+const normalizeLimit = (limit) => Math.min(MAX_RELATED_NOTES, Math.max(0, Math.trunc(limit)));
+const toDate = (value) => value instanceof Date ? value : new Date(value);
+const buildReasons = (candidate) => {
+  const reasons = [];
+  if (candidate.linked) {
+    reasons.push("Linked from this note");
+  }
+  if (candidate.backlink) {
+    reasons.push("Backlink to this note");
+  }
+  for (const tagName of candidate.sharedTagNames) {
+    reasons.push(`Shares ${tagName}`);
+  }
+  return reasons;
+};
+const compareCandidates = (left, right) => {
+  const leftScore = (left.linked ? 100 : 0) + (left.backlink ? 100 : 0) + left.sharedTagNames.length * 20;
+  const rightScore = (right.linked ? 100 : 0) + (right.backlink ? 100 : 0) + right.sharedTagNames.length * 20;
+  if (leftScore !== rightScore) {
+    return rightScore - leftScore;
+  }
+  const updatedAtDifference = right.updatedAt.getTime() - left.updatedAt.getTime();
+  return updatedAtDifference !== 0 ? updatedAtDifference : left.id - right.id;
+};
+const findCandidatesFromIndex = async ({
+  noteId,
+  tagIds,
+  limit
+}) => {
+  const rows = tagIds.length === 0 ? await models.$queryRaw(Prisma.sql`
+                  WITH candidate_scores AS (
+                      SELECT
+                          note."id" AS "id",
+                          note."title" AS "title",
+                          note."updatedAt" AS "updatedAt",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS outgoing
+                              WHERE outgoing."sourceNoteId" = ${noteId}
+                                AND outgoing."targetNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "linked",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS incoming
+                              WHERE incoming."targetNoteId" = ${noteId}
+                                AND incoming."sourceNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "backlink",
+                          0 AS "sharedTagCount"
+                      FROM "Note" AS note
+                      WHERE note."id" <> ${noteId}
+                        AND (
+                            EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS outgoing
+                                WHERE outgoing."sourceNoteId" = ${noteId}
+                                  AND outgoing."targetNoteId" = note."id"
+                            )
+                            OR EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS incoming
+                                WHERE incoming."targetNoteId" = ${noteId}
+                                  AND incoming."sourceNoteId" = note."id"
+                            )
+                        )
+                  )
+                  SELECT *, ("linked" * 100 + "backlink" * 100 + "sharedTagCount" * 20) AS "score"
+                  FROM candidate_scores
+                  ORDER BY "score" DESC, "updatedAt" DESC, "id" ASC
+                  LIMIT ${limit}
+              `) : await models.$queryRaw(Prisma.sql`
+                  WITH candidate_scores AS (
+                      SELECT
+                          note."id" AS "id",
+                          note."title" AS "title",
+                          note."updatedAt" AS "updatedAt",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS outgoing
+                              WHERE outgoing."sourceNoteId" = ${noteId}
+                                AND outgoing."targetNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "linked",
+                          CASE WHEN EXISTS (
+                              SELECT 1
+                              FROM "NoteReference" AS incoming
+                              WHERE incoming."targetNoteId" = ${noteId}
+                                AND incoming."sourceNoteId" = note."id"
+                          ) THEN 1 ELSE 0 END AS "backlink",
+                          COUNT(DISTINCT noteTags."B") AS "sharedTagCount"
+                      FROM "Note" AS note
+                      LEFT JOIN "_NoteToTag" AS noteTags
+                        ON noteTags."A" = note."id"
+                       AND noteTags."B" IN (${Prisma.join(tagIds)})
+                      WHERE note."id" <> ${noteId}
+                        AND (
+                            EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS outgoing
+                                WHERE outgoing."sourceNoteId" = ${noteId}
+                                  AND outgoing."targetNoteId" = note."id"
+                            )
+                            OR EXISTS (
+                                SELECT 1
+                                FROM "NoteReference" AS incoming
+                                WHERE incoming."targetNoteId" = ${noteId}
+                                  AND incoming."sourceNoteId" = note."id"
+                            )
+                            OR noteTags."B" IS NOT NULL
+                        )
+                      GROUP BY note."id", note."title", note."updatedAt"
+                  )
+                  SELECT *, ("linked" * 100 + "backlink" * 100 + "sharedTagCount" * 20) AS "score"
+                  FROM candidate_scores
+                  ORDER BY "score" DESC, "updatedAt" DESC, "id" ASC
+                  LIMIT ${limit}
+              `);
+  if (rows.length === 0) {
+    return [];
+  }
+  const candidateIds = rows.map((row) => row.id);
+  const candidateNotes = await models.note.findMany({
+    where: { id: { in: candidateIds } },
+    select: {
+      id: true,
+      tags: {
+        select: {
+          id: true,
+          name: true
+        }
+      }
+    }
+  });
+  const tagsByNoteId = new Map(candidateNotes.map((note) => [note.id, note.tags]));
+  const sourceTagIds = new Set(tagIds);
+  return rows.map((row) => ({
+    id: row.id,
+    title: row.title || "Untitled",
+    updatedAt: toDate(row.updatedAt),
+    linked: Number(row.linked) === 1,
+    backlink: Number(row.backlink) === 1,
+    sharedTagNames: (tagsByNoteId.get(row.id) ?? []).filter((tag) => sourceTagIds.has(tag.id)).map((tag) => tag.name).sort((left, right) => left.localeCompare(right))
+  }));
+};
+const defaultDependencies = {
+  findSourceNote: (noteId) => models.note.findUnique({
+    where: { id: noteId },
+    select: {
+      id: true,
+      tags: {
+        select: {
+          id: true,
+          name: true
+        }
+      }
+    }
+  }),
+  findCandidates: findCandidatesFromIndex
+};
+const createSearchRelatedNotes = (dependencies = defaultDependencies) => {
+  return async (noteId, limit = MAX_RELATED_NOTES) => {
+    const normalizedLimit = normalizeLimit(limit);
+    if (!Number.isSafeInteger(noteId) || noteId <= 0 || normalizedLimit === 0) {
+      return [];
+    }
+    const source = await dependencies.findSourceNote(noteId);
+    if (!source) {
+      return [];
+    }
+    const candidates = await dependencies.findCandidates({
+      noteId,
+      tagIds: source.tags.map((tag) => tag.id),
+      limit: normalizedLimit
+    });
+    return candidates.filter((candidate) => candidate.linked || candidate.backlink || candidate.sharedTagNames.length > 0).sort(compareCandidates).slice(0, normalizedLimit).map((candidate) => ({
+      id: candidate.id,
+      title: candidate.title || "Untitled",
+      reasons: buildReasons(candidate)
+    }));
+  };
+};
+const searchRelatedNotes = createSearchRelatedNotes();
+export {
+  createSearchRelatedNotes,
+  searchRelatedNotes
+};

package/server/dist/features/search/search-config.js

@@ -0,0 +1,150 @@
+import { normalizeEmbeddingApiUrl } from "./embedding-client.js";
+import { stripTrailingSlashes } from "./url-normalization.js";
+const SEMANTIC_SEARCH_CONFIG_CACHE_KEY = "SEMANTIC_SEARCH_CONFIG_V1";
+const SEMANTIC_SEARCH_VALIDATED_CONNECTION_CACHE_KEY = "SEMANTIC_SEARCH_VALIDATED_CONNECTION_V1";
+const LEGACY_KOREAN_QUERY_INSTRUCTION = "Given a vague Korean memory query, retrieve relevant passages from personal notes.";
+const DEFAULT_SEMANTIC_SEARCH_CONFIG = {
+  enabled: false,
+  baseUrl: "",
+  model: "",
+  queryInstruction: ""
+};
+const parseStoredConfig = (value) => {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed.enabled !== "boolean" || typeof parsed.baseUrl !== "string" || typeof parsed.model !== "string" || typeof parsed.queryInstruction !== "string") {
+      return null;
+    }
+    return {
+      enabled: parsed.enabled,
+      baseUrl: parsed.baseUrl,
+      model: parsed.model,
+      queryInstruction: parsed.queryInstruction
+    };
+  } catch {
+    return null;
+  }
+};
+const readStoredAuthFingerprint = ({
+  authFingerprint,
+  usesBearerAuth
+}) => {
+  if (typeof authFingerprint === "string") {
+    return authFingerprint;
+  }
+  if (usesBearerAuth === false) {
+    return "";
+  }
+  return "legacy-bearer-auth";
+};
+const parseValidatedConnection = (value) => {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed.baseUrl !== "string" || typeof parsed.model !== "string" || typeof parsed.validatedAt !== "string") {
+      return null;
+    }
+    return {
+      baseUrl: parsed.baseUrl,
+      model: parsed.model,
+      validatedAt: parsed.validatedAt,
+      authFingerprint: readStoredAuthFingerprint(parsed)
+    };
+  } catch {
+    return null;
+  }
+};
+const normalizeSemanticSearchConfig = (input) => {
+  if (input.baseUrl.length > 2048) {
+    throw new Error("Embedding API URL is too long.");
+  }
+  const config = {
+    enabled: input.enabled,
+    baseUrl: stripTrailingSlashes(input.baseUrl.trim()),
+    model: input.model.trim(),
+    queryInstruction: input.queryInstruction.trim()
+  };
+  if (config.baseUrl) {
+    normalizeEmbeddingApiUrl(config.baseUrl);
+  }
+  if (config.enabled && (!config.baseUrl || !config.model)) {
+    throw new Error("Embedding API URL and model are required when semantic search is enabled.");
+  }
+  if (config.model.length > 200) {
+    throw new Error("Embedding model name is too long.");
+  }
+  if (config.queryInstruction.length > 1e3) {
+    throw new Error("Embedding query instruction is too long.");
+  }
+  return config;
+};
+class SemanticSearchConfigStore {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  cache;
+  async get() {
+    const row = await this.cache.findUnique({ where: { key: SEMANTIC_SEARCH_CONFIG_CACHE_KEY } });
+    const config = row ? parseStoredConfig(row.value) : null;
+    if (!config) {
+      return DEFAULT_SEMANTIC_SEARCH_CONFIG;
+    }
+    if (config.queryInstruction.trim() === LEGACY_KOREAN_QUERY_INSTRUCTION) {
+      return this.set({ ...config, queryInstruction: "" });
+    }
+    return config;
+  }
+  async set(input) {
+    const config = normalizeSemanticSearchConfig(input);
+    const value = JSON.stringify(config);
+    await this.cache.upsert({
+      where: { key: SEMANTIC_SEARCH_CONFIG_CACHE_KEY },
+      create: { key: SEMANTIC_SEARCH_CONFIG_CACHE_KEY, value },
+      update: { value }
+    });
+    return config;
+  }
+  async getValidatedConnection() {
+    const row = await this.cache.findUnique({
+      where: { key: SEMANTIC_SEARCH_VALIDATED_CONNECTION_CACHE_KEY }
+    });
+    return row ? parseValidatedConnection(row.value) : null;
+  }
+  async isConnectionValidated(input, authFingerprint = "") {
+    const config = normalizeSemanticSearchConfig({
+      ...DEFAULT_SEMANTIC_SEARCH_CONFIG,
+      baseUrl: input.baseUrl,
+      model: input.model
+    });
+    const validated = await this.getValidatedConnection();
+    return Boolean(
+      validated && validated.baseUrl === config.baseUrl && validated.model === config.model && validated.authFingerprint === authFingerprint
+    );
+  }
+  async markConnectionValidated(input, authFingerprint = "") {
+    const config = normalizeSemanticSearchConfig({
+      ...DEFAULT_SEMANTIC_SEARCH_CONFIG,
+      baseUrl: input.baseUrl,
+      model: input.model
+    });
+    const validated = {
+      baseUrl: config.baseUrl,
+      model: config.model,
+      validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      authFingerprint
+    };
+    const value = JSON.stringify(validated);
+    await this.cache.upsert({
+      where: { key: SEMANTIC_SEARCH_VALIDATED_CONNECTION_CACHE_KEY },
+      create: { key: SEMANTIC_SEARCH_VALIDATED_CONNECTION_CACHE_KEY, value },
+      update: { value }
+    });
+    return validated;
+  }
+}
+export {
+  DEFAULT_SEMANTIC_SEARCH_CONFIG,
+  SEMANTIC_SEARCH_CONFIG_CACHE_KEY,
+  SEMANTIC_SEARCH_VALIDATED_CONNECTION_CACHE_KEY,
+  SemanticSearchConfigStore,
+  normalizeSemanticSearchConfig
+};