ocean-brain 0.8.2 → 0.10.0

package/server/dist/features/note/services/markdown-patch.js

@@ -21,6 +21,66 @@ const getLineRange = (markdown, match) => {
     lineEnd
   };
 };
+const MARKDOWN_PATCH_WHITESPACE_PATTERN = /\p{Zs}| |&#(?:x[0-9a-f]+|\d+);/giu;
+const SPACE_SEPARATOR_PATTERN = /^\p{Zs}$/u;
+const normalizePatchWhitespaceToken = (value) => {
+  if (!value.startsWith("&")) {
+    return " ";
+  }
+  if (/^ $/i.test(value)) {
+    return " ";
+  }
+  const numericValue = value.slice(2, -1);
+  const isHexadecimal = numericValue.toLowerCase().startsWith("x");
+  const codePoint = Number.parseInt(isHexadecimal ? numericValue.slice(1) : numericValue, isHexadecimal ? 16 : 10);
+  if (!Number.isSafeInteger(codePoint) || codePoint < 0 || codePoint > 1114111) {
+    return value;
+  }
+  return SPACE_SEPARATOR_PATTERN.test(String.fromCodePoint(codePoint)) ? " " : value;
+};
+const normalizeMarkdownPatchText = (value) => {
+  let text = "";
+  const rawStarts = [];
+  const rawEnds = [];
+  const appendText = (appendValue, rawStart, rawEnd) => {
+    text += appendValue;
+    for (let index = 0; index < appendValue.length; index += 1) {
+      rawStarts.push(rawStart);
+      rawEnds.push(rawEnd);
+    }
+  };
+  const appendRawRange = (start, end) => {
+    for (let index = start; index < end; ) {
+      const codePoint = value.codePointAt(index);
+      if (codePoint === void 0) {
+        break;
+      }
+      const character = String.fromCodePoint(codePoint);
+      appendText(character, index, index + character.length);
+      index += character.length;
+    }
+  };
+  let sourceCursor = 0;
+  for (const match of value.matchAll(MARKDOWN_PATCH_WHITESPACE_PATTERN)) {
+    const start = match.index;
+    const token = match[0];
+    const end = start + token.length;
+    appendRawRange(sourceCursor, start);
+    const normalizedToken = normalizePatchWhitespaceToken(token);
+    if (normalizedToken === token) {
+      appendRawRange(start, end);
+    } else {
+      appendText(normalizedToken, start, end);
+    }
+    sourceCursor = end;
+  }
+  appendRawRange(sourceCursor, value.length);
+  return {
+    text,
+    rawStarts,
+    rawEnds
+  };
+};
 const buildExcerpt = (markdown, start, end) => {
   const excerpt = markdown.slice(start, end).trim();
   return excerpt.length > 0 ? excerpt : void 0;
@@ -46,19 +106,27 @@ const toPatchMatch = (markdown, match, totalMatches) => {
 };
 const findExactTextMatches = (markdown, text) => {
   const matches = [];
+  const normalizedMarkdown = normalizeMarkdownPatchText(markdown);
+  const normalizedText = normalizeMarkdownPatchText(text).text;
   let searchStart = 0;
-  while (searchStart <= markdown.length) {
-    const start = markdown.indexOf(text, searchStart);
+  while (searchStart <= normalizedMarkdown.text.length) {
+    const start = normalizedMarkdown.text.indexOf(normalizedText, searchStart);
     if (start === -1) {
       break;
     }
+    const end = start + normalizedText.length;
+    const rawStart = normalizedMarkdown.rawStarts[start];
+    const rawEnd = normalizedMarkdown.rawEnds[end - 1];
+    if (rawStart === void 0 || rawEnd === void 0) {
+      break;
+    }
     matches.push({
       matchIndex: matches.length,
-      start,
-      end: start + text.length,
-      text
+      start: rawStart,
+      end: rawEnd,
+      text: markdown.slice(rawStart, rawEnd)
     });
-    searchStart = start + text.length;
+    searchStart = end;
   }
   return matches;
 };
@@ -238,10 +306,14 @@ const createChangePlan = ({
   };
 };
 const matchHasAnchors = (markdown, match, selector) => {
-  if (selector.before !== void 0 && !markdown.slice(0, match.start).endsWith(selector.before)) {
+  if (selector.before !== void 0 && !normalizeMarkdownPatchText(markdown.slice(0, match.start)).text.endsWith(
+    normalizeMarkdownPatchText(selector.before).text
+  )) {
     return false;
   }
-  if (selector.after !== void 0 && !markdown.slice(match.end).startsWith(selector.after)) {
+  if (selector.after !== void 0 && !normalizeMarkdownPatchText(markdown.slice(match.end)).text.startsWith(
+    normalizeMarkdownPatchText(selector.after).text
+  )) {
     return false;
   }
   return true;

package/server/dist/features/note/services/properties.js

@@ -329,6 +329,13 @@ const findReferencedRemovedPropertyOptionValue = ({
   }
   return null;
 };
+const viewQueryReferencesProperty = ({ query, key }) => {
+  const parsed = parseViewQueryRecord(query);
+  if (!parsed || !Array.isArray(parsed.propertyFilters)) {
+    return false;
+  }
+  return parsed.propertyFilters.some((filter) => isRecord(filter) && getNormalizedViewFilterKey(filter) === key);
+};
 const buildTypedValueData = async (input, definitionId, tx = models) => {
   const resetValues = {
     textValue: null,
@@ -695,6 +702,18 @@ const deleteNotePropertyDefinition = async ({
     if (!definition) {
       return null;
     }
+    const referencingViewSections = await tx.viewSection.findMany({
+      where: { query: { contains: definition.key } },
+      select: { title: true, query: true }
+    });
+    const referencingView = referencingViewSections.find(
+      (section) => viewQueryReferencesProperty({ query: section.query, key: definition.key })
+    );
+    if (referencingView) {
+      throw new InvalidNotePropertyInputError(
+        `Property ${definition.key} is used by view ${referencingView.title} and cannot be deleted.`
+      );
+    }
     const affectedNoteCount = definition._count.properties;
     if (affectedNoteCount > 0 && !confirmImpact) {
       throw new NotePropertyDeleteConfirmationRequiredError(normalizedKey, affectedNoteCount);
@@ -869,5 +888,6 @@ export {
   updateNotePropertiesWithVersionGuard,
   updateNotePropertiesWithVersionGuardAndSnapshot,
   updateNotePropertyDefinition,
-  validateNotePropertiesPatchValues
+  validateNotePropertiesPatchValues,
+  viewQueryReferencesProperty
 };

package/server/dist/features/note/services/property-restore.js

@@ -0,0 +1,26 @@
+const resolveRestoredPropertyTarget = async (property, deps) => {
+  const definition = await deps.findDefinitionByKey(property.key);
+  if (!definition || definition.valueType !== property.valueType) {
+    return null;
+  }
+  if (property.valueType !== "select") {
+    return {
+      propertyDefinitionId: definition.id,
+      optionId: null
+    };
+  }
+  if (!property.optionValue) {
+    return null;
+  }
+  const option = await deps.findOptionByValue(definition.id, property.optionValue);
+  if (!option) {
+    return null;
+  }
+  return {
+    propertyDefinitionId: definition.id,
+    optionId: option.id
+  };
+};
+export {
+  resolveRestoredPropertyTarget
+};

package/server/dist/features/note/services/snapshot.js

@@ -1,6 +1,6 @@
 import { FILE_HEADERS_ONLY, formatPatch, structuredPatch } from "diff";
 import { ensureTagByName } from "../../../features/tag/services/organization.js";
-import models from "../../../models.js";
+import models, { Prisma } from "../../../models.js";
 import { blocksToMarkdown, extractTagIdsFromContentJson } from "../../../modules/blocknote.js";
 import { parseBlockNoteContent, walkBlockNoteTree } from "../../../modules/blocknote-tree.js";
 import {
@@ -10,7 +10,9 @@ import {
   SNAPSHOT_RETENTION_DAYS
 } from "../../../modules/recovery-retention.js";
 import { calculateMarkdownSha256 } from "./markdown-patch.js";
+import { resolveRestoredPropertyTarget } from "./property-restore.js";
 import { buildNoteSearchProjection, extractVisibleSearchTextFromContent } from "./search.js";
+import { createNoteVersionConflictError, MissingNoteVersionError, parseNoteVersion } from "./write-conflict.js";
 const SNAPSHOT_CONTENT_PREVIEW_MAX_LENGTH = 240;
 const parseMeta = (value) => {
   if (!value) {
@@ -384,6 +386,19 @@ const createNoteSnapshotService = (deps) => ({
     if (!note) {
       return null;
     }
+    if (!note.updatedAt) {
+      throw new Error("Note update time is required to restore a snapshot.");
+    }
+    const expectedTimestamp = parseNoteVersion(options.expectedUpdatedAt);
+    if (expectedTimestamp === null) {
+      throw new MissingNoteVersionError();
+    }
+    if (note.updatedAt.getTime() !== expectedTimestamp) {
+      throw createNoteVersionConflictError({
+        expectedUpdatedAt: expectedTimestamp,
+        currentUpdatedAt: note.updatedAt.getTime()
+      });
+    }
     const payload = parsePayload(snapshot.payload);
     const resolvedTags = deps.resolveRestoredTags ? await deps.resolveRestoredTags(payload.content) : extractRestoredTagIds(payload.content);
     const restoredPayload = resolvedTags && !Array.isArray(resolvedTags) ? {
@@ -403,7 +418,8 @@ const createNoteSnapshotService = (deps) => ({
     }
     const restoredNote = await deps.updateNote(snapshot.noteId, {
       ...restoredPayload,
-      ...restoredTagIds !== void 0 ? { tagIds: restoredTagIds } : {}
+      ...restoredTagIds !== void 0 ? { tagIds: restoredTagIds } : {},
+      expectedUpdatedAt: options.expectedUpdatedAt
     });
     await deps.trimOverflowSnapshots(note.id, SNAPSHOT_MAX_PER_NOTE, RECOVERY_CLEANUP_BATCH_LIMIT);
     return restoredNote;
@@ -527,68 +543,72 @@ const defaultNoteSnapshotService = createNoteSnapshotService({
     });
   },
   updateNote: async (id, input) => {
-    const { tagIds, properties, ...noteInput } = input;
-    return models.$transaction(async (tx) => {
-      const note = await tx.note.update({
-        where: { id },
-        data: {
-          ...noteInput,
-          ...buildNoteSearchProjection({
-            title: noteInput.title,
-            content: noteInput.content
-          }),
-          ...tagIds !== void 0 ? { tags: { set: tagIds.map((tagId) => ({ id: tagId })) } } : {}
-        }
-      });
-      if (properties !== void 0) {
-        await tx.noteProperty.deleteMany({ where: { noteId: id } });
-        for (const property of properties) {
-          const definition = await tx.propertyDefinition.upsert({
-            where: { key: property.key },
-            create: {
-              key: property.key,
-              name: property.name,
-              valueType: property.valueType
-            },
-            update: {
-              name: property.name,
-              valueType: property.valueType
+    const { tagIds, properties, expectedUpdatedAt, ...noteInput } = input;
+    const expectedTimestamp = parseNoteVersion(expectedUpdatedAt);
+    if (expectedTimestamp === null) {
+      throw new MissingNoteVersionError();
+    }
+    try {
+      return await models.$transaction(async (tx) => {
+        const note = await tx.note.update({
+          where: { id, updatedAt: new Date(expectedTimestamp) },
+          data: {
+            ...noteInput,
+            ...buildNoteSearchProjection({
+              title: noteInput.title,
+              content: noteInput.content
+            }),
+            ...tagIds !== void 0 ? { tags: { set: tagIds.map((tagId) => ({ id: tagId })) } } : {}
+          }
+        });
+        if (properties !== void 0) {
+          await tx.noteProperty.deleteMany({ where: { noteId: id } });
+          for (const property of properties) {
+            const target = await resolveRestoredPropertyTarget(property, {
+              findDefinitionByKey: (key) => tx.propertyDefinition.findUnique({ where: { key } }),
+              findOptionByValue: (propertyDefinitionId, value) => tx.propertyOption.findUnique({
+                where: {
+                  propertyDefinitionId_value: {
+                    propertyDefinitionId,
+                    value
+                  }
+                }
+              })
+            });
+            if (!target) {
+              continue;
             }
-          });
-          const option = property.valueType === "select" && property.optionValue ? await tx.propertyOption.upsert({
-            where: {
-              propertyDefinitionId_value: {
-                propertyDefinitionId: definition.id,
-                value: property.optionValue
+            await tx.noteProperty.create({
+              data: {
+                noteId: id,
+                propertyDefinitionId: target.propertyDefinitionId,
+                optionId: target.optionId,
+                textValue: property.textValue ?? null,
+                textValueNormalized: property.textValueNormalized ?? null,
+                numberValue: property.numberValue ?? null,
+                dateValue: property.dateValue ? new Date(property.dateValue) : null,
+                boolValue: property.boolValue ?? null
               }
-            },
-            create: {
-              propertyDefinitionId: definition.id,
-              value: property.optionValue,
-              label: property.optionLabel ?? property.optionValue,
-              color: property.optionColor ?? null
-            },
-            update: {
-              label: property.optionLabel ?? property.optionValue,
-              color: property.optionColor ?? null
-            }
-          }) : null;
-          await tx.noteProperty.create({
-            data: {
-              noteId: id,
-              propertyDefinitionId: definition.id,
-              optionId: option?.id ?? null,
-              textValue: property.textValue ?? null,
-              textValueNormalized: property.textValueNormalized ?? null,
-              numberValue: property.numberValue ?? null,
-              dateValue: property.dateValue ? new Date(property.dateValue) : null,
-              boolValue: property.boolValue ?? null
-            }
+            });
+          }
+        }
+        return note;
+      });
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2025") {
+        const currentNote = await models.note.findUnique({
+          where: { id },
+          select: { updatedAt: true }
+        });
+        if (currentNote && currentNote.updatedAt.getTime() !== expectedTimestamp) {
+          throw createNoteVersionConflictError({
+            expectedUpdatedAt: expectedTimestamp,
+            currentUpdatedAt: currentNote.updatedAt.getTime()
           });
         }
       }
-      return note;
-    });
+      throw error;
+    }
   }
 });
 const captureNoteBaseline = async (input) => {

package/server/dist/features/note/services/trash.js

@@ -4,6 +4,7 @@ import {
   RECOVERY_CLEANUP_BATCH_LIMIT,
   TRASH_RETENTION_DAYS
 } from "../../../modules/recovery-retention.js";
+import { resolveRestoredPropertyTarget } from "./property-restore.js";
 import { buildNoteSearchProjection, extractVisibleSearchTextFromContent } from "./search.js";
 const TRASHED_NOTE_CONTENT_PREVIEW_MAX_LENGTH = 240;
 class NoteRestoreConflictError extends Error {
@@ -289,41 +290,25 @@ const noteTrashService = createNoteTrashService({
         }
       });
       for (const property of deletedNote.properties ?? []) {
-        const definition = await tx.propertyDefinition.upsert({
-          where: { key: property.key },
-          create: {
-            key: property.key,
-            name: property.name,
-            valueType: property.valueType
-          },
-          update: {
-            name: property.name,
-            valueType: property.valueType
-          }
-        });
-        const option = property.valueType === "select" && property.optionValue ? await tx.propertyOption.upsert({
-          where: {
-            propertyDefinitionId_value: {
-              propertyDefinitionId: definition.id,
-              value: property.optionValue
+        const target = await resolveRestoredPropertyTarget(property, {
+          findDefinitionByKey: (key) => tx.propertyDefinition.findUnique({ where: { key } }),
+          findOptionByValue: (propertyDefinitionId, value) => tx.propertyOption.findUnique({
+            where: {
+              propertyDefinitionId_value: {
+                propertyDefinitionId,
+                value
+              }
             }
-          },
-          create: {
-            propertyDefinitionId: definition.id,
-            value: property.optionValue,
-            label: property.optionLabel ?? property.optionValue,
-            color: property.optionColor
-          },
-          update: {
-            label: property.optionLabel ?? property.optionValue,
-            color: property.optionColor
-          }
-        }) : null;
+          })
+        });
+        if (!target) {
+          continue;
+        }
         await tx.noteProperty.create({
           data: {
             noteId: note.id,
-            propertyDefinitionId: definition.id,
-            optionId: option?.id ?? null,
+            propertyDefinitionId: target.propertyDefinitionId,
+            optionId: target.optionId,
             textValue: property.textValue,
             textValueNormalized: property.textValueNormalized,
             numberValue: property.numberValue,

package/server/dist/features/search/embedding-api-key-store.js

@@ -0,0 +1,57 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const MAX_EMBEDDING_API_KEY_LENGTH = 8192;
+const normalizeEmbeddingApiKey = (value) => {
+  const apiKey = value.trim();
+  if (apiKey.length > MAX_EMBEDDING_API_KEY_LENGTH) {
+    throw new Error("Embedding API key is too long.");
+  }
+  return apiKey || void 0;
+};
+const createEmbeddingApiKeyFingerprint = (apiKey) => {
+  if (!apiKey) {
+    return "";
+  }
+  return createHash("sha256").update(apiKey).digest("hex");
+};
+class FileEmbeddingApiKeyStore {
+  constructor(filePath) {
+    this.filePath = filePath;
+    try {
+      this.apiKey = normalizeEmbeddingApiKey(readFileSync(filePath, "utf8"));
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  filePath;
+  apiKey;
+  get() {
+    return this.apiKey;
+  }
+  set(value) {
+    const apiKey = value === void 0 ? void 0 : normalizeEmbeddingApiKey(value);
+    if (!apiKey) {
+      rmSync(this.filePath, { force: true });
+      this.apiKey = void 0;
+      return;
+    }
+    mkdirSync(path.dirname(this.filePath), { recursive: true });
+    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temporaryPath, apiKey, { encoding: "utf8", mode: 384, flag: "wx" });
+      renameSync(temporaryPath, this.filePath);
+      this.apiKey = apiKey;
+    } finally {
+      rmSync(temporaryPath, { force: true });
+    }
+  }
+}
+export {
+  FileEmbeddingApiKeyStore,
+  MAX_EMBEDDING_API_KEY_LENGTH,
+  createEmbeddingApiKeyFingerprint,
+  normalizeEmbeddingApiKey
+};

package/server/dist/features/search/embedding-client.js

@@ -0,0 +1,179 @@
+import { stripTrailingSlashes } from "./url-normalization.js";
+const DEFAULT_EMBEDDING_TIMEOUT_MS = 6e4;
+const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 1e4;
+const buildOpenAiCompatibleUrl = (baseUrl, resource) => {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(baseUrl);
+  } catch {
+    throw new Error("Embedding API URL must be a valid http or https URL.");
+  }
+  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+    throw new Error("Embedding API URL must use http or https.");
+  }
+  if (parsedUrl.username || parsedUrl.password) {
+    throw new Error("Embedding API URL must not contain credentials.");
+  }
+  const normalizedPath = stripTrailingSlashes(parsedUrl.pathname);
+  const normalizedPathLower = normalizedPath.toLowerCase();
+  const resourceSuffix = ["/embeddings", "/models"].find((suffix) => normalizedPathLower.endsWith(suffix));
+  const basePath = resourceSuffix ? normalizedPath.slice(0, -resourceSuffix.length) : normalizedPath;
+  parsedUrl.pathname = `${basePath || "/v1"}/${resource}`;
+  parsedUrl.search = "";
+  parsedUrl.hash = "";
+  return parsedUrl.toString();
+};
+const buildEmbeddingsUrl = (baseUrl) => buildOpenAiCompatibleUrl(baseUrl, "embeddings");
+const buildModelsUrl = (baseUrl) => buildOpenAiCompatibleUrl(baseUrl, "models");
+const validateEmbedding = (value, expectedIndex) => {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(`Embedding API returned an empty vector for input ${expectedIndex}.`);
+  }
+  const embedding = value.map((item) => {
+    if (typeof item !== "number" || !Number.isFinite(item)) {
+      throw new Error(`Embedding API returned an invalid vector value for input ${expectedIndex}.`);
+    }
+    return item;
+  });
+  return embedding;
+};
+const parseEmbeddingResponse = (payload, expectedCount) => {
+  if (!payload || typeof payload !== "object" || !("data" in payload) || !Array.isArray(payload.data)) {
+    throw new Error("Embedding API response does not contain a data array.");
+  }
+  const items = payload.data;
+  if (items.length !== expectedCount) {
+    throw new Error(`Embedding API returned ${items.length} vectors for ${expectedCount} inputs.`);
+  }
+  const orderedItems = [...items].sort((left, right) => {
+    const leftIndex = typeof left.index === "number" ? left.index : items.indexOf(left);
+    const rightIndex = typeof right.index === "number" ? right.index : items.indexOf(right);
+    return leftIndex - rightIndex;
+  });
+  const embeddings = orderedItems.map((item, index) => validateEmbedding(item.embedding, index));
+  const dimensions = embeddings[0]?.length;
+  if (!dimensions || embeddings.some((embedding) => embedding.length !== dimensions)) {
+    throw new Error("Embedding API returned vectors with inconsistent dimensions.");
+  }
+  return embeddings;
+};
+const redactSecret = (message, secret) => {
+  if (!secret || !message.includes(secret)) {
+    return message;
+  }
+  return message.split(secret).join("[redacted]");
+};
+const readApiErrorMessage = async (response, secret) => {
+  try {
+    const payload = await response.json();
+    const message = payload.error?.message ?? payload.message;
+    return typeof message === "string" && message.trim() ? redactSecret(message.trim(), secret) : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const looksLikeEmbeddingModel = (modelId) => /(^|[-_/])(embed|embedding|bge|e5|gte)([-_/.]|$)/i.test(modelId);
+const listOpenAiCompatibleEmbeddingModels = async (baseUrl, options = {}) => {
+  const endpoint = buildModelsUrl(baseUrl);
+  const fetchImpl = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS;
+  const response = await fetchImpl(endpoint, {
+    method: "GET",
+    headers: {
+      Accept: "application/json",
+      ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {}
+    },
+    redirect: "error",
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok) {
+    const apiMessage = await readApiErrorMessage(response, options.apiKey);
+    throw new Error(
+      apiMessage ? `Model discovery failed (${response.status}): ${apiMessage}` : `Model discovery failed with status ${response.status}.`
+    );
+  }
+  const payload = await response.json();
+  if (!Array.isArray(payload.data)) {
+    throw new Error("Model discovery response does not contain a data array.");
+  }
+  const modelIds = [
+    ...new Set(
+      payload.data.map((item) => {
+        if (!item || typeof item !== "object") return "";
+        const id = item.id;
+        return typeof id === "string" ? id.trim() : "";
+      }).filter(Boolean)
+    )
+  ];
+  if (modelIds.length === 0) {
+    throw new Error("The API returned no models.");
+  }
+  return modelIds.map((id) => ({ id, likelyEmbedding: looksLikeEmbeddingModel(id) })).sort((left, right) => {
+    if (left.likelyEmbedding !== right.likelyEmbedding) {
+      return left.likelyEmbedding ? -1 : 1;
+    }
+    return left.id.localeCompare(right.id);
+  });
+};
+const buildQueryInput = (query, instruction) => {
+  const normalizedInstruction = instruction?.trim();
+  if (!normalizedInstruction) {
+    return query;
+  }
+  return `Instruct: ${normalizedInstruction}
+Query: ${query}`;
+};
+const createOpenAiCompatibleEmbeddingClient = (config, options = {}) => {
+  const endpoint = buildEmbeddingsUrl(config.baseUrl);
+  const model = config.model.trim();
+  const fetchImpl = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_EMBEDDING_TIMEOUT_MS;
+  if (!model) {
+    throw new Error("Embedding model is required.");
+  }
+  const embed = async (inputs) => {
+    if (inputs.length === 0) {
+      return [];
+    }
+    const response = await fetchImpl(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+      },
+      body: JSON.stringify({
+        model,
+        input: inputs,
+        encoding_format: "float"
+      }),
+      redirect: "error",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) {
+      const apiMessage = await readApiErrorMessage(response, config.apiKey);
+      throw new Error(
+        apiMessage ? `Embedding API request failed (${response.status}): ${apiMessage}` : `Embedding API request failed with status ${response.status}.`
+      );
+    }
+    return parseEmbeddingResponse(await response.json(), inputs.length);
+  };
+  return {
+    embedDocuments: embed,
+    async embedQuery(query) {
+      const normalizedQuery = query.trim();
+      if (!normalizedQuery) {
+        throw new Error("Embedding query must not be empty.");
+      }
+      const [embedding] = await embed([buildQueryInput(normalizedQuery, config.queryInstruction)]);
+      return embedding;
+    }
+  };
+};
+const normalizeEmbeddingApiUrl = buildEmbeddingsUrl;
+const normalizeEmbeddingModelsUrl = buildModelsUrl;
+export {
+  createOpenAiCompatibleEmbeddingClient,
+  listOpenAiCompatibleEmbeddingModels,
+  normalizeEmbeddingApiUrl,
+  normalizeEmbeddingModelsUrl
+};

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

@@ -0,0 +1,6 @@
+import { searchResolvers } from "./resolver.js";
+import { searchTypeDefs } from "./type-defs.js";
+export {
+  searchResolvers,
+  searchTypeDefs
+};