@delali/narsil 0.1.6 → 0.1.7

package/dist/embeddings/openai.mjs

@@ -0,0 +1,248 @@
+import { NarsilError, ErrorCodes } from '../chunk-R2C2EQGO.mjs';
+
+// src/embeddings/openai.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503]);
+var MAX_BACKOFF_MS = 3e4;
+var BASE_BACKOFF_MS = 1e3;
+var MAX_JITTER_MS = 1e3;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_INPUTS_PER_REQUEST = 2048;
+function isRetryableStatus(status) {
+  return RETRYABLE_STATUS_CODES.has(status);
+}
+function computeBackoffMs(attempt, retryAfterSeconds) {
+  if (retryAfterSeconds !== null && retryAfterSeconds > 0) {
+    return Math.min(retryAfterSeconds * 1e3, MAX_BACKOFF_MS);
+  }
+  const exponential = Math.min(BASE_BACKOFF_MS * 2 ** attempt, MAX_BACKOFF_MS);
+  const jitter = Math.random() * MAX_JITTER_MS;
+  return exponential + jitter;
+}
+function parseRetryAfterHeader(headers) {
+  const raw = headers.get("retry-after");
+  if (raw === null) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds > 0) return seconds;
+  return null;
+}
+async function resolveApiKey(apiKey) {
+  const resolved = typeof apiKey === "function" ? await apiKey() : apiKey;
+  if (typeof resolved !== "string" || resolved.trim().length === 0) {
+    throw new NarsilError(
+      ErrorCodes.EMBEDDING_CONFIG_INVALID,
+      "OpenAI embedding adapter apiKey resolved to an empty or non-string value"
+    );
+  }
+  return resolved;
+}
+function buildSignal(callerSignal, timeoutMs) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (callerSignal === void 0) return timeoutSignal;
+  return AbortSignal.any([callerSignal, timeoutSignal]);
+}
+async function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function parseEmbeddingItems(data) {
+  if (!Array.isArray(data)) {
+    throw new NarsilError(ErrorCodes.EMBEDDING_FAILED, 'OpenAI response missing "data" array');
+  }
+  const items = [];
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
+    if (item === void 0 || item === null || typeof item !== "object") {
+      throw new NarsilError(ErrorCodes.EMBEDDING_FAILED, `OpenAI response item at position ${i} is not an object`);
+    }
+    if (typeof item.index !== "number") {
+      throw new NarsilError(
+        ErrorCodes.EMBEDDING_FAILED,
+        `OpenAI response item at position ${i} missing numeric "index"`
+      );
+    }
+    if (!Array.isArray(item.embedding)) {
+      throw new NarsilError(
+        ErrorCodes.EMBEDDING_FAILED,
+        `OpenAI response item at position ${i} missing "embedding" array`
+      );
+    }
+    items.push({ index: item.index, embedding: item.embedding });
+  }
+  return items;
+}
+async function parseErrorBody(response) {
+  try {
+    const body = await response.json();
+    const errorType = body?.error?.type ?? "unknown";
+    const errorMessage = body?.error?.message ?? `HTTP ${response.status}`;
+    return { type: errorType, message: errorMessage };
+  } catch {
+    return { type: "unknown", message: `HTTP ${response.status}` };
+  }
+}
+async function executeWithRetry(url, requestBody, apiKey, maxRetries, signal) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: requestBody,
+        signal
+      });
+    } catch (err) {
+      if (err instanceof DOMException || err instanceof Error && err.name === "AbortError") {
+        throw err;
+      }
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < maxRetries) {
+        await sleep(computeBackoffMs(attempt, null), signal);
+        continue;
+      }
+      throw new NarsilError(
+        ErrorCodes.EMBEDDING_FAILED,
+        `OpenAI request failed after ${maxRetries + 1} attempts: network error`,
+        {
+          cause: lastError.message
+        }
+      );
+    }
+    if (response.ok) {
+      let parsed;
+      try {
+        parsed = await response.json();
+      } catch {
+        throw new NarsilError(ErrorCodes.EMBEDDING_FAILED, "OpenAI returned invalid JSON in response body");
+      }
+      if (parsed === null || typeof parsed !== "object") {
+        throw new NarsilError(ErrorCodes.EMBEDDING_FAILED, "OpenAI returned non-object JSON response");
+      }
+      return parsed;
+    }
+    const retryAfter = parseRetryAfterHeader(response.headers);
+    const errorInfo = await parseErrorBody(response);
+    if (!isRetryableStatus(response.status) || attempt >= maxRetries) {
+      throw new NarsilError(
+        ErrorCodes.EMBEDDING_FAILED,
+        `OpenAI API error (${response.status}): [${errorInfo.type}] ${errorInfo.message}`,
+        { status: response.status, errorType: errorInfo.type }
+      );
+    }
+    lastError = new Error(`HTTP ${response.status}: ${errorInfo.type}`);
+    await sleep(computeBackoffMs(attempt, retryAfter), signal);
+  }
+  throw new NarsilError(ErrorCodes.EMBEDDING_FAILED, "OpenAI request failed: exhausted all retries", {
+    cause: lastError?.message
+  });
+}
+function createOpenAIEmbedding(config) {
+  if (!config.baseUrl || config.baseUrl.trim().length === 0) {
+    throw new NarsilError(ErrorCodes.EMBEDDING_CONFIG_INVALID, "OpenAI embedding adapter requires a non-empty baseUrl");
+  }
+  if (!config.model || config.model.trim().length === 0) {
+    throw new NarsilError(ErrorCodes.EMBEDDING_CONFIG_INVALID, "OpenAI embedding adapter requires a non-empty model");
+  }
+  if (!Number.isInteger(config.dimensions) || config.dimensions < 1) {
+    throw new NarsilError(
+      ErrorCodes.EMBEDDING_CONFIG_INVALID,
+      "OpenAI embedding adapter requires dimensions to be a positive integer"
+    );
+  }
+  if (config.timeout !== void 0 && (!Number.isFinite(config.timeout) || config.timeout <= 0)) {
+    throw new NarsilError(
+      ErrorCodes.EMBEDDING_CONFIG_INVALID,
+      "OpenAI embedding adapter timeout must be a positive number"
+    );
+  }
+  if (config.maxRetries !== void 0 && (!Number.isInteger(config.maxRetries) || config.maxRetries < 0)) {
+    throw new NarsilError(
+      ErrorCodes.EMBEDDING_CONFIG_INVALID,
+      "OpenAI embedding adapter maxRetries must be a non-negative integer"
+    );
+  }
+  if (typeof config.apiKey === "string" && config.apiKey.trim().length === 0) {
+    throw new NarsilError(ErrorCodes.EMBEDDING_CONFIG_INVALID, "OpenAI embedding adapter requires a non-empty apiKey");
+  }
+  if (typeof config.apiKey !== "string" && typeof config.apiKey !== "function") {
+    throw new NarsilError(
+      ErrorCodes.EMBEDDING_CONFIG_INVALID,
+      "OpenAI embedding adapter apiKey must be a string or a function returning a string"
+    );
+  }
+  const url = `${config.baseUrl.replace(/\/+$/, "")}/embeddings`;
+  const model = config.model;
+  const dimensionCount = config.dimensions;
+  const timeoutMs = config.timeout ?? DEFAULT_TIMEOUT_MS;
+  const maxRetries = config.maxRetries ?? 3;
+  return {
+    get dimensions() {
+      return dimensionCount;
+    },
+    async embed(input, _purpose, signal) {
+      const apiKey = await resolveApiKey(config.apiKey);
+      const body = JSON.stringify({ input: [input], model, dimensions: dimensionCount });
+      const combinedSignal = buildSignal(signal, timeoutMs);
+      const result = await executeWithRetry(url, body, apiKey, maxRetries, combinedSignal);
+      const items = parseEmbeddingItems(result.data);
+      if (items.length === 0) {
+        throw new NarsilError(
+          ErrorCodes.EMBEDDING_FAILED,
+          "OpenAI returned empty data array for single embedding request"
+        );
+      }
+      return new Float32Array(items[0].embedding);
+    },
+    async embedBatch(inputs, _purpose, signal) {
+      if (inputs.length === 0) return [];
+      const apiKey = await resolveApiKey(config.apiKey);
+      const combinedSignal = buildSignal(signal, timeoutMs);
+      const executeChunk = async (chunk) => {
+        const body = JSON.stringify({ input: chunk, model, dimensions: dimensionCount });
+        const result = await executeWithRetry(url, body, apiKey, maxRetries, combinedSignal);
+        const items = parseEmbeddingItems(result.data);
+        if (items.length !== chunk.length) {
+          throw new NarsilError(
+            ErrorCodes.EMBEDDING_FAILED,
+            `OpenAI returned ${items.length} embeddings for ${chunk.length} inputs`,
+            { expected: chunk.length, actual: items.length }
+          );
+        }
+        const sorted = items.slice().sort((a, b) => a.index - b.index);
+        return sorted.map((item) => new Float32Array(item.embedding));
+      };
+      if (inputs.length <= MAX_INPUTS_PER_REQUEST) {
+        return executeChunk(inputs);
+      }
+      const results = [];
+      for (let start = 0; start < inputs.length; start += MAX_INPUTS_PER_REQUEST) {
+        const chunk = inputs.slice(start, start + MAX_INPUTS_PER_REQUEST);
+        const chunkResults = await executeChunk(chunk);
+        for (const vec of chunkResults) {
+          results.push(vec);
+        }
+      }
+      return results;
+    },
+    async shutdown() {
+    }
+  };
+}
+
+export { createOpenAIEmbedding };