ocean-brain 0.8.2 → 0.10.0

package/server/dist/features/search/graphql/resolver.js

@@ -0,0 +1,20 @@
+import { searchNotesHybrid } from "../hybrid-search.js";
+const createSearchNotesResolver = (search = searchNotesHybrid) => {
+  return async (_, { query, pagination, mode = "HYBRID" }) => {
+    return search({
+      query,
+      limit: Math.min(50, Math.max(0, pagination.limit)),
+      offset: Math.max(0, pagination.offset),
+      mode: mode.toLowerCase()
+    });
+  };
+};
+const searchResolvers = {
+  Query: {
+    searchNotes: createSearchNotesResolver()
+  }
+};
+export {
+  createSearchNotesResolver,
+  searchResolvers
+};

package/server/dist/features/search/graphql/type-defs.js

@@ -0,0 +1,30 @@
+import { gql } from "../../../modules/graphql.js";
+const searchTypeDefs = gql`
+    enum SearchMode {
+        HYBRID
+        LEXICAL
+        SEMANTIC
+    }
+
+    type SearchNoteMatch {
+        noteId: ID!
+        lexical: Boolean!
+        semantic: Boolean!
+    }
+
+    type SearchNotesResult {
+        totalCount: Int!
+        notes: [Note!]!
+        matches: [SearchNoteMatch!]!
+        semanticAvailable: Boolean!
+        semanticUsed: Boolean!
+        semanticError: String
+    }
+
+    extend type Query {
+        searchNotes(query: String!, pagination: PaginationInput!, mode: SearchMode = HYBRID): SearchNotesResult!
+    }
+`;
+export {
+  searchTypeDefs
+};

package/server/dist/features/search/http/handlers.js

@@ -0,0 +1,108 @@
+import { createAppError } from "../../../modules/error-handler.js";
+import { normalizeEmbeddingApiKey } from "../embedding-api-key-store.js";
+import { normalizeEmbeddingModelsUrl } from "../embedding-client.js";
+import { normalizeSemanticSearchConfig } from "../search-config.js";
+import {
+  getDefaultSemanticSearchManager
+} from "../search-manager.js";
+import { stripTrailingSlashes } from "../url-normalization.js";
+const parseApiKeyInput = (value) => {
+  if (!value || typeof value !== "object" || !Object.hasOwn(value, "apiKey")) {
+    return { provided: false };
+  }
+  const rawApiKey = value.apiKey;
+  if (rawApiKey !== null && typeof rawApiKey !== "string") {
+    throw createAppError(400, "INVALID_EMBEDDING_API_KEY", "Embedding API key must be a string or null.");
+  }
+  try {
+    return {
+      provided: true,
+      apiKey: rawApiKey === null ? void 0 : normalizeEmbeddingApiKey(rawApiKey)
+    };
+  } catch (error) {
+    throw createAppError(
+      400,
+      "INVALID_EMBEDDING_API_KEY",
+      error instanceof Error ? error.message : "Embedding API key is invalid."
+    );
+  }
+};
+const parseConfig = (value) => {
+  if (!value || typeof value !== "object") {
+    throw createAppError(400, "INVALID_SEARCH_CONFIG", "Semantic search settings must be an object.");
+  }
+  const config = value;
+  if (typeof config.enabled !== "boolean" || typeof config.baseUrl !== "string" || typeof config.model !== "string" || typeof config.queryInstruction !== "string") {
+    throw createAppError(
+      400,
+      "INVALID_SEARCH_CONFIG",
+      "enabled, baseUrl, model, and queryInstruction are required."
+    );
+  }
+  try {
+    return normalizeSemanticSearchConfig(config);
+  } catch (error) {
+    throw createAppError(
+      400,
+      "INVALID_SEARCH_CONFIG",
+      error instanceof Error ? error.message : "Semantic search settings are invalid."
+    );
+  }
+};
+const parseBaseUrl = (value) => {
+  if (!value || typeof value !== "object" || typeof value.baseUrl !== "string") {
+    throw createAppError(400, "INVALID_EMBEDDING_API_URL", "Embedding API URL is required.");
+  }
+  const inputBaseUrl = value.baseUrl;
+  if (inputBaseUrl.length > 2048) {
+    throw createAppError(400, "INVALID_EMBEDDING_API_URL", "Embedding API URL is too long.");
+  }
+  const baseUrl = stripTrailingSlashes(inputBaseUrl.trim());
+  try {
+    normalizeEmbeddingModelsUrl(baseUrl);
+  } catch (error) {
+    throw createAppError(
+      400,
+      "INVALID_EMBEDDING_API_URL",
+      error instanceof Error ? error.message : "Embedding API URL is invalid."
+    );
+  }
+  return baseUrl;
+};
+const createSearchAdminStatusHandler = (manager = getDefaultSemanticSearchManager()) => {
+  return async (_req, res) => {
+    res.status(200).json(await manager.getStatus()).end();
+  };
+};
+const createSearchAdminSaveConfigHandler = (manager = getDefaultSemanticSearchManager()) => {
+  return async (req, res) => {
+    const status = await manager.saveConfig(parseConfig(req.body), parseApiKeyInput(req.body));
+    res.status(200).json(status).end();
+  };
+};
+const createSearchAdminTestConnectionHandler = (manager = getDefaultSemanticSearchManager()) => {
+  return async (req, res) => {
+    const config = parseConfig({ ...req.body, enabled: true });
+    const result = await manager.testConnection(config, parseApiKeyInput(req.body));
+    res.status(200).json(result).end();
+  };
+};
+const createSearchAdminListModelsHandler = (listModels = (baseUrl, apiKeyInput) => getDefaultSemanticSearchManager().listModels(baseUrl, apiKeyInput)) => {
+  return async (req, res) => {
+    const models = await listModels(parseBaseUrl(req.body), parseApiKeyInput(req.body));
+    res.status(200).json({ models }).end();
+  };
+};
+const createSearchAdminReindexHandler = (manager = getDefaultSemanticSearchManager()) => {
+  return async (_req, res) => {
+    const result = await manager.startReindex();
+    res.status(result.started ? 202 : 200).json(result).end();
+  };
+};
+export {
+  createSearchAdminListModelsHandler,
+  createSearchAdminReindexHandler,
+  createSearchAdminSaveConfigHandler,
+  createSearchAdminStatusHandler,
+  createSearchAdminTestConnectionHandler
+};

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

@@ -0,0 +1,55 @@
+const DEFAULT_RANK_CONSTANT = 60;
+const uniqueNoteIds = (noteIds) => {
+  return [...new Set(noteIds.filter((noteId) => Number.isInteger(noteId) && noteId > 0))];
+};
+const fuseHybridSearchRanks = ({
+  lexicalNoteIds,
+  semanticNoteIds,
+  lexicalWeight = 1,
+  semanticWeight = 1,
+  rankConstant = DEFAULT_RANK_CONSTANT
+}) => {
+  const lexicalIds = uniqueNoteIds(lexicalNoteIds);
+  const semanticIds = uniqueNoteIds(semanticNoteIds);
+  const candidates = /* @__PURE__ */ new Map();
+  const addRankedIds = (noteIds, source, weight) => {
+    noteIds.forEach((noteId, index) => {
+      const rank = index + 1;
+      const candidate = candidates.get(noteId) ?? {
+        noteId,
+        lexicalRank: null,
+        semanticRank: null,
+        score: 0
+      };
+      candidate.score += weight / (rankConstant + rank);
+      if (source === "lexical") {
+        candidate.lexicalRank = rank;
+      } else {
+        candidate.semanticRank = rank;
+      }
+      candidates.set(noteId, candidate);
+    });
+  };
+  addRankedIds(lexicalIds, "lexical", lexicalWeight);
+  addRankedIds(semanticIds, "semantic", semanticWeight);
+  return [...candidates.values()].sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
+    const leftBestRank = Math.min(left.lexicalRank ?? Number.POSITIVE_INFINITY, left.semanticRank ?? Infinity);
+    const rightBestRank = Math.min(right.lexicalRank ?? Number.POSITIVE_INFINITY, right.semanticRank ?? Infinity);
+    if (leftBestRank !== rightBestRank) {
+      return leftBestRank - rightBestRank;
+    }
+    if (left.lexicalRank !== null && right.lexicalRank === null) {
+      return -1;
+    }
+    if (left.lexicalRank === null && right.lexicalRank !== null) {
+      return 1;
+    }
+    return left.noteId - right.noteId;
+  });
+};
+export {
+  fuseHybridSearchRanks
+};

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

@@ -0,0 +1,174 @@
+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 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 [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, candidateLimit).catch((error) => unavailableSemanticAttempt(error))
+    ]);
+    const rankedCandidates = fuseHybridSearchRanks({
+      lexicalNoteIds,
+      semanticNoteIds: semanticAttempt.matches.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/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
+};