libsql-search 0.6.0 → 0.7.1

package/dist/index.esm.js

@@ -3,6 +3,7 @@ import { join, extname, relative, dirname } from 'path';
 import matter from 'gray-matter';
 
 const OPENAI_DEFAULT_DIMENSIONS = 768;
+const OPENAI_COMPATIBLE_DEFAULT_BATCH_SIZE = 32;
 const LOCAL_DIMENSIONS = 384;
 const DEFAULT_MAX_LENGTH = 8e3;
 const DEFAULT_TIMEOUT_MS = 3e4;
@@ -109,6 +110,7 @@ function resolveProviderName(provider) {
     case "openai":
     case "mistral":
     case "cloudflare":
+    case "openai-compatible":
       return provider ?? "local";
     default:
       throw new Error(`Unknown embedding provider: ${String(provider)}`);
@@ -133,6 +135,13 @@ function getOptionalTrimmedCredential(value) {
   const trimmed = value?.trim();
   return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
 }
+function getRequiredTrimmedString(value, optionName) {
+  const trimmed = getOptionalTrimmedCredential(value);
+  if (!trimmed) {
+    throw new Error(`Invalid ${optionName}: expected a non-empty string`);
+  }
+  return trimmed;
+}
 function hasOwnProperty(value, property) {
   return Object.prototype.hasOwnProperty.call(value, property);
 }
@@ -293,7 +302,27 @@ async function embedSequentially(provider, operation, texts, signal, embedOne) {
   }
   return results;
 }
-function createProviderMetadata(provider, dimensions) {
+function normalizeOpenAICompatibleEmbeddingsUrl(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new Error("Invalid baseUrl: expected an absolute http or https URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Invalid baseUrl: expected an absolute http or https URL");
+  }
+  if (url.username || url.password) {
+    throw new Error("Invalid baseUrl: URL credentials are not allowed");
+  }
+  if (url.search || url.hash) {
+    throw new Error("Invalid baseUrl: query strings and fragments are not allowed");
+  }
+  const path = url.pathname.replace(/\/+$/, "");
+  url.pathname = path.endsWith("/embeddings") ? path : `${path}/embeddings`;
+  return url.toString();
+}
+function createProviderMetadata(provider, dimensions, model) {
   switch (provider) {
     case "local":
       return Object.freeze({
@@ -330,6 +359,13 @@ function createProviderMetadata(provider, dimensions) {
         dimensions: CLOUDFLARE_DIMENSIONS,
         batch: Object.freeze({ mode: "native" })
       });
+    case "openai-compatible":
+      return Object.freeze({
+        name: "openai-compatible",
+        model: getRequiredTrimmedString(model, "model"),
+        dimensions,
+        batch: Object.freeze({ mode: "native" })
+      });
   }
 }
 function getEffectiveDimensions(provider, dimensions) {
@@ -370,6 +406,12 @@ function getEffectiveDimensions(provider, dimensions) {
     }
     return CLOUDFLARE_DIMENSIONS;
   }
+  if (provider === "openai-compatible") {
+    if (dimensions === void 0) {
+      throw new Error("Invalid dimensions: expected a positive integer");
+    }
+    return getPositiveInteger(dimensions, "dimensions");
+  }
   return getPositiveInteger(dimensions ?? OPENAI_DEFAULT_DIMENSIONS, "dimensions");
 }
 function assertBatchSize(metadata, count) {
@@ -380,6 +422,13 @@ function assertBatchSize(metadata, count) {
     );
   }
 }
+function chunkTexts(texts, batchSize) {
+  const chunks = [];
+  for (let index = 0; index < texts.length; index += batchSize) {
+    chunks.push(texts.slice(index, index + batchSize));
+  }
+  return chunks;
+}
 function createEmbeddingBatchResult(metadata, intent, embeddings) {
   return Object.freeze({
     embeddings,
@@ -480,18 +529,23 @@ async function requestOpenAICompatibleEmbeddings(request) {
   if (request.encodingFormat !== void 0) {
     body.encoding_format = request.encodingFormat;
   }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (request.apiKey !== void 0) {
+    headers.Authorization = `Bearer ${request.apiKey}`;
+  }
   const response = await fetch(request.endpoint, {
     method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${request.apiKey}`
-    },
+    headers,
     signal: request.signal,
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    ...request.redirect ? { redirect: request.redirect } : {}
   });
   if (!response.ok) {
-    const requestId = getSafeResponseHeader(response, "x-request-id");
-    const context = requestId ? ` status ${response.status}, request ${requestId}` : ` status ${response.status}`;
+    const statusHeader = request.statusHeader ?? { name: "x-request-id", label: "request" };
+    const statusHeaderValue = getSafeResponseHeader(response, statusHeader.name);
+    const context = statusHeaderValue ? ` status ${response.status}, ${statusHeader.label} ${statusHeaderValue}` : ` status ${response.status}`;
     throw new Error(context);
   }
   const data = await response.json();
@@ -515,13 +569,13 @@ async function requestOpenAICompatibleEmbeddings(request) {
     return parsed;
   });
 }
-class OpenAIEmbeddingProvider {
+class OpenAICompatibleEmbeddingProvider {
   metadata;
-  #apiKey;
   #timeoutMs;
-  constructor(metadata, apiKey, timeoutMs) {
+  #profile;
+  constructor(metadata, profile, timeoutMs) {
     this.metadata = metadata;
-    this.#apiKey = apiKey;
+    this.#profile = profile;
     this.#timeoutMs = timeoutMs;
   }
   async embed(texts, options = {}) {
@@ -531,131 +585,44 @@ class OpenAIEmbeddingProvider {
     }
     assertBatchSize(this.metadata, texts.length);
     const items = await withTimeout(
-      "openai",
-      "API request",
-      this.#timeoutMs,
-      async (signal) => requestOpenAICompatibleEmbeddings({
-        responseLabel: "OpenAI",
-        endpoint: OPENAI_EMBEDDINGS_URL,
-        apiKey: this.#apiKey,
-        model: this.metadata.model,
-        texts,
-        signal,
-        dimensions: this.metadata.dimensions
-      }),
-      options.signal,
-      [this.#apiKey]
-    );
-    return createEmbeddingBatchResult(
-      this.metadata,
-      intent,
-      validateEmbeddingBatch(items, texts.length, this.metadata.dimensions, "openai")
-    );
-  }
-}
-class MistralEmbeddingProvider {
-  metadata;
-  #apiKey;
-  #timeoutMs;
-  constructor(metadata, apiKey, timeoutMs) {
-    this.metadata = metadata;
-    this.#apiKey = apiKey;
-    this.#timeoutMs = timeoutMs;
-  }
-  async embed(texts, options = {}) {
-    const intent = resolveIntent(options.intent);
-    if (texts.length === 0) {
-      return createEmbeddingBatchResult(this.metadata, intent, []);
-    }
-    assertBatchSize(this.metadata, texts.length);
-    const items = await withTimeout(
-      "mistral",
-      "API request",
-      this.#timeoutMs,
-      async (signal) => requestOpenAICompatibleEmbeddings({
-        responseLabel: "Mistral",
-        endpoint: MISTRAL_EMBEDDINGS_URL,
-        apiKey: this.#apiKey,
-        model: this.metadata.model,
-        texts,
-        signal,
-        encodingFormat: "float",
-        requireIndex: true
-      }),
-      options.signal,
-      [this.#apiKey]
-    );
-    return createEmbeddingBatchResult(
-      this.metadata,
-      intent,
-      validateEmbeddingBatch(items, texts.length, this.metadata.dimensions, "mistral")
-    );
-  }
-}
-class CloudflareEmbeddingProvider {
-  metadata;
-  #accountId;
-  #apiToken;
-  #timeoutMs;
-  constructor(metadata, accountId, apiToken, timeoutMs) {
-    this.metadata = metadata;
-    this.#accountId = accountId;
-    this.#apiToken = apiToken;
-    this.#timeoutMs = timeoutMs;
-  }
-  async embed(texts, options = {}) {
-    const intent = resolveIntent(options.intent);
-    if (texts.length === 0) {
-      return createEmbeddingBatchResult(this.metadata, intent, []);
-    }
-    assertBatchSize(this.metadata, texts.length);
-    const endpoint = createCloudflareEmbeddingsUrl(this.#accountId);
-    const items = await withTimeout(
-      "cloudflare",
+      this.#profile.provider,
       "API request",
       this.#timeoutMs,
       async (signal) => {
-        const response = await fetch(endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${this.#apiToken}`
-          },
-          signal,
-          body: JSON.stringify({
-            model: this.metadata.model,
-            input: texts
-          })
-        });
-        if (!response.ok) {
-          const cfRay = getSafeResponseHeader(response, "cf-ray");
-          const context = cfRay ? ` status ${response.status}, cf-ray ${cfRay}` : ` status ${response.status}`;
-          throw new Error(context);
-        }
-        const data = await response.json();
-        if (!Array.isArray(data.data)) {
-          throw new Error("Cloudflare response did not include a data array");
+        const batches = this.#profile.batchSize === void 0 ? [texts] : chunkTexts(texts, this.#profile.batchSize);
+        const results = [];
+        for (const batch of batches) {
+          throwIfAborted(this.#profile.provider, "API request", signal);
+          const batchItems = await requestOpenAICompatibleEmbeddings({
+            responseLabel: this.#profile.responseLabel,
+            endpoint: this.#profile.endpoint,
+            ...this.#profile.apiKey !== void 0 ? { apiKey: this.#profile.apiKey } : {},
+            model: this.#profile.model,
+            texts: batch,
+            signal,
+            ...this.#profile.includeDimensions ? { dimensions: this.#profile.dimensions } : {},
+            ...this.#profile.encodingFormat ? { encodingFormat: this.#profile.encodingFormat } : {},
+            ...this.#profile.requireIndex !== void 0 ? { requireIndex: this.#profile.requireIndex } : {},
+            ...this.#profile.redirect ? { redirect: this.#profile.redirect } : {},
+            ...this.#profile.statusHeader ? { statusHeader: this.#profile.statusHeader } : {}
+          });
+          results.push(...validateEmbeddingBatch(
+            batchItems,
+            batch.length,
+            this.metadata.dimensions,
+            this.#profile.provider
+          ));
+          throwIfAborted(this.#profile.provider, "API request", signal);
         }
-        return data.data.map((item) => {
-          const typed = item;
-          const embedding = typed.embedding;
-          if (!Array.isArray(embedding)) {
-            throw new Error("Cloudflare response item did not include an embedding array");
-          }
-          const parsed = { embedding };
-          if (hasOwnProperty(typed, "index")) {
-            parsed.index = typed.index;
-          }
-          return parsed;
-        });
+        return results;
       },
       options.signal,
-      [this.#apiToken, this.#accountId, encodeURIComponent(this.#accountId)]
+      this.#profile.exactSecrets ?? []
     );
     return createEmbeddingBatchResult(
       this.metadata,
       intent,
-      validateEmbeddingBatch(items, texts.length, this.metadata.dimensions, "cloudflare")
+      validateEmbeddingBatch(items, texts.length, this.metadata.dimensions, this.#profile.provider)
     );
   }
 }
@@ -680,7 +647,16 @@ function createEmbeddingProvider(options = {}) {
       if (!key) {
         throw new Error("OPENAI_API_KEY is required for OpenAI embeddings");
       }
-      return new OpenAIEmbeddingProvider(metadata, key, timeoutMs);
+      return new OpenAICompatibleEmbeddingProvider(metadata, {
+        provider: "openai",
+        responseLabel: "OpenAI",
+        endpoint: OPENAI_EMBEDDINGS_URL,
+        apiKey: key,
+        model: metadata.model,
+        dimensions: metadata.dimensions,
+        includeDimensions: true,
+        exactSecrets: [key]
+      }, timeoutMs);
     }
     case "mistral": {
       const key = getOptionalTrimmedCredential(
@@ -689,7 +665,17 @@ function createEmbeddingProvider(options = {}) {
       if (!key) {
         throw new Error("MISTRAL_API_KEY is required for Mistral embeddings");
       }
-      return new MistralEmbeddingProvider(metadata, key, timeoutMs);
+      return new OpenAICompatibleEmbeddingProvider(metadata, {
+        provider: "mistral",
+        responseLabel: "Mistral",
+        endpoint: MISTRAL_EMBEDDINGS_URL,
+        apiKey: key,
+        model: metadata.model,
+        dimensions: metadata.dimensions,
+        encodingFormat: "float",
+        requireIndex: true,
+        exactSecrets: [key]
+      }, timeoutMs);
     }
     case "cloudflare": {
       const accountId = getOptionalTrimmedCredential(
@@ -704,13 +690,56 @@ function createEmbeddingProvider(options = {}) {
       if (!apiToken) {
         throw new Error("CLOUDFLARE_API_TOKEN is required for Cloudflare embeddings");
       }
-      return new CloudflareEmbeddingProvider(metadata, accountId, apiToken, timeoutMs);
+      const endpoint = createCloudflareEmbeddingsUrl(accountId);
+      return new OpenAICompatibleEmbeddingProvider(metadata, {
+        provider: "cloudflare",
+        responseLabel: "Cloudflare",
+        endpoint,
+        apiKey: apiToken,
+        model: metadata.model,
+        dimensions: metadata.dimensions,
+        statusHeader: { name: "cf-ray", label: "cf-ray" },
+        exactSecrets: [apiToken, accountId, encodeURIComponent(accountId), endpoint]
+      }, timeoutMs);
+    }
+    case "openai-compatible": {
+      const baseUrl = getRequiredTrimmedString(options.baseUrl, "baseUrl");
+      const endpoint = normalizeOpenAICompatibleEmbeddingsUrl(baseUrl);
+      const apiKey = getOptionalTrimmedCredential(options.apiKey);
+      const batchSize = getPositiveInteger(
+        options.batchSize ?? OPENAI_COMPATIBLE_DEFAULT_BATCH_SIZE,
+        "batchSize"
+      );
+      return new OpenAICompatibleEmbeddingProvider(metadata, {
+        provider: "openai-compatible",
+        responseLabel: "OpenAI-compatible",
+        endpoint,
+        ...apiKey ? { apiKey } : {},
+        model: metadata.model,
+        dimensions: metadata.dimensions,
+        includeDimensions: true,
+        encodingFormat: "float",
+        requireIndex: true,
+        redirect: "error",
+        batchSize,
+        exactSecrets: [
+          ...apiKey ? [apiKey] : [],
+          baseUrl,
+          endpoint
+        ]
+      }, timeoutMs);
     }
   }
 }
 function getEmbeddingProviderMetadata(options = {}) {
   const provider = resolveProviderName(options.provider);
-  return createProviderMetadata(provider, getEffectiveDimensions(provider, options.dimensions));
+  if (provider === "openai-compatible") {
+    normalizeOpenAICompatibleEmbeddingsUrl(getRequiredTrimmedString(options.baseUrl, "baseUrl"));
+    if (options.batchSize !== void 0) {
+      getPositiveInteger(options.batchSize, "batchSize");
+    }
+  }
+  return createProviderMetadata(provider, getEffectiveDimensions(provider, options.dimensions), options.model);
 }
 async function generateEmbeddings(texts, options = {}) {
   const maxLength = getPositiveInteger(options.maxLength ?? DEFAULT_MAX_LENGTH, "maxLength");