@dudousxd/nestjs-agent-rag 0.10.2 → 0.11.0

package/dist/index.js

@@ -356,6 +356,106 @@ function cosineSimilarity(a, b) {
 }
 __name(cosineSimilarity, "cosineSimilarity");
 
+// src/pg-client.ts
+var ADAPTED = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent-rag/pg-client");
+function toPgClient(source) {
+  if (source[ADAPTED]) {
+    return source;
+  }
+  if (isDrizzle(source)) {
+    return toPgClient(source.$client);
+  }
+  if (typeof source.unsafe === "function") {
+    return fromPostgresJs(source);
+  }
+  return fromQueryable(source);
+}
+__name(toPgClient, "toPgClient");
+function isDrizzle(source) {
+  const client = source.$client;
+  return client !== null && client !== void 0 && typeof client === "object";
+}
+__name(isDrizzle, "isDrizzle");
+function mark(client) {
+  Object.defineProperty(client, ADAPTED, {
+    value: true
+  });
+  return client;
+}
+__name(mark, "mark");
+function rowsOf(result) {
+  if (Array.isArray(result)) {
+    return result;
+  }
+  const rows = result?.rows;
+  return Array.isArray(rows) ? rows : [];
+}
+__name(rowsOf, "rowsOf");
+function fromPostgresJs(sql) {
+  const client = {
+    query: /* @__PURE__ */ __name(async (text, params = []) => (
+      // postgres.js resolves a RowList (an Array subclass); copy it to a plain array.
+      [
+        ...rowsOf(await sql.unsafe(text, params))
+      ]
+    ), "query")
+  };
+  if (typeof sql.begin === "function") {
+    const begin = sql.begin.bind(sql);
+    client.transaction = (work) => Promise.resolve(begin((tx) => work(fromPostgresJs(tx))));
+  }
+  return mark(client);
+}
+__name(fromPostgresJs, "fromPostgresJs");
+function fromQueryable(source) {
+  const client = {
+    query: /* @__PURE__ */ __name(async (text, params) => rowsOf(await source.query(text, params)), "query")
+  };
+  if (typeof source.transaction === "function") {
+    const transaction = source.transaction.bind(source);
+    client.transaction = (work) => transaction((tx) => work(toPgClient(tx)));
+  } else if (isNodePgPool(source)) {
+    client.transaction = async (work) => {
+      const connection = await source.connect();
+      let broken = false;
+      try {
+        return await runInTransaction(connection, work, () => {
+          broken = true;
+        });
+      } finally {
+        connection.release(broken ? new Error("ROLLBACK failed") : void 0);
+      }
+    };
+  } else if (isNodePgClient(source)) {
+    client.transaction = (work) => runInTransaction(source, work);
+  }
+  return mark(client);
+}
+__name(fromQueryable, "fromQueryable");
+async function runInTransaction(connection, work, onRollbackFailed) {
+  const tx = mark({
+    query: /* @__PURE__ */ __name(async (text, params) => rowsOf(await connection.query(text, params)), "query")
+  });
+  await connection.query("BEGIN");
+  try {
+    const result = await work(tx);
+    await connection.query("COMMIT");
+    return result;
+  } catch (error) {
+    await connection.query("ROLLBACK").catch(() => onRollbackFailed?.());
+    throw error;
+  }
+}
+__name(runInTransaction, "runInTransaction");
+function isNodePgPool(source) {
+  return typeof source.connect === "function" && typeof source.totalCount === "number";
+}
+__name(isNodePgPool, "isNodePgPool");
+function isNodePgClient(source) {
+  return typeof source.release === "function" || typeof source.processID === "number" || source.connectionParameters !== void 0;
+}
+__name(isNodePgClient, "isNodePgClient");
+
 // src/pg-vector-store.ts
 var NUL_BYTE = String.fromCharCode(0);
 function stripNulBytes(value) {
@@ -384,11 +484,37 @@ var PgVectorStore = class {
   }
   client;
   table;
+  /** The single width (fixed-dimension table), or `undefined` for a mixed-dimension table. */
   dimensions;
+  /** The widths with a partial HNSW index, for a mixed-dimension table. */
+  indexedDimensions;
+  nullableEmbeddings;
+  iterativeScan;
+  efSearch;
+  upsertBatchSize;
+  iterativeScanSupport;
   constructor(client, options = {}) {
-    this.client = client;
+    this.client = toPgClient(client);
     this.table = options.table ?? "agent_rag_chunks";
-    this.dimensions = options.dimensions ?? 1536;
+    const dimensions = options.dimensions ?? 1536;
+    if (typeof dimensions === "number") {
+      this.dimensions = dimensions;
+      this.indexedDimensions = [];
+    } else {
+      for (const width of dimensions) {
+        if (!Number.isInteger(width) || width <= 0) {
+          throw new Error(`PgVectorStore: invalid embedding width ${String(width)}`);
+        }
+      }
+      this.dimensions = void 0;
+      this.indexedDimensions = [
+        ...new Set(dimensions)
+      ];
+    }
+    this.nullableEmbeddings = options.nullableEmbeddings ?? false;
+    this.iterativeScan = options.iterativeScan;
+    this.efSearch = options.efSearch;
+    this.upsertBatchSize = Math.max(1, Math.floor(options.upsertBatchSize ?? 100));
   }
   /** Telemetry self-description — the table is the namespace a retrieval was served from. */
   describeRetrieval() {
@@ -397,38 +523,77 @@ var PgVectorStore = class {
       collection: this.table
     };
   }
-  /** Idempotent DDL: the `vector` extension, the chunks table, and the cosine HNSW index. */
-  async ensureSchema() {
-    await this.client.query("CREATE EXTENSION IF NOT EXISTS vector");
-    await this.client.query(`CREATE TABLE IF NOT EXISTS ${this.table} (
+  /**
+  * The idempotent DDL {@link PgVectorStore.ensureSchema} runs, in order — for a migration instead
+  * of a boot-time side effect. On a populated table, run the index statements `CONCURRENTLY` there.
+  */
+  schemaStatements() {
+    const mixed = this.dimensions === void 0;
+    const column = mixed ? "vector" : `vector(${this.dimensions})`;
+    const statements = [
+      "CREATE EXTENSION IF NOT EXISTS vector",
+      `CREATE TABLE IF NOT EXISTS ${this.table} (
         id TEXT PRIMARY KEY,
         text TEXT NOT NULL,
         source TEXT,
         metadata JSONB,
-        embedding vector(${this.dimensions}) NOT NULL
-      )`);
-    await this.client.query(`CREATE INDEX IF NOT EXISTS ${this.table}_embedding_idx
+        embedding ${column}${this.nullableEmbeddings ? "" : " NOT NULL"}
+      )`
+    ];
+    if (mixed) {
+      for (const width of this.indexedDimensions) {
+        statements.push(`CREATE INDEX IF NOT EXISTS ${this.table}_embedding_${width}_idx
+        ON ${this.table} USING hnsw ((embedding::vector(${width})) vector_cosine_ops)
+        WHERE vector_dims(embedding) = ${width}`);
+      }
+    } else {
+      statements.push(`CREATE INDEX IF NOT EXISTS ${this.table}_embedding_idx
         ON ${this.table} USING hnsw (embedding vector_cosine_ops)`);
+    }
+    return statements;
   }
+  /** Idempotent DDL: the `vector` extension, the chunks table, and the cosine HNSW index(es). */
+  async ensureSchema() {
+    for (const statement of this.schemaStatements()) {
+      await this.client.query(statement);
+    }
+  }
+  /**
+  * Multi-row `INSERT … ON CONFLICT (id) DO UPDATE`, {@link PgVectorStoreOptions.upsertBatchSize}
+  * rows per statement. An empty `embedding` is written as `NULL` (see
+  * {@link PgVectorStoreOptions.nullableEmbeddings}).
+  */
   async upsert(records) {
+    const byId = /* @__PURE__ */ new Map();
     for (const record of records) {
       const id = stripNulBytes(record.id);
-      const text = stripNulBytes(record.text);
-      const source = record.source !== void 0 ? stripNulBytes(record.source) : void 0;
-      const metadata = record.metadata !== void 0 ? stripNulBytes(record.metadata) : void 0;
+      byId.delete(id);
+      byId.set(id, {
+        ...record,
+        id
+      });
+    }
+    const unique = [
+      ...byId.values()
+    ];
+    for (let start = 0; start < unique.length; start += this.upsertBatchSize) {
+      const batch = unique.slice(start, start + this.upsertBatchSize);
+      const params = [];
+      const rows = batch.map((record) => {
+        const text = stripNulBytes(record.text);
+        const source = record.source !== void 0 ? stripNulBytes(record.source) : void 0;
+        const metadata = record.metadata !== void 0 ? stripNulBytes(record.metadata) : void 0;
+        const base = params.length;
+        params.push(record.id, text, source ?? null, metadata !== void 0 ? JSON.stringify(metadata) : null, record.embedding.length > 0 ? toVectorLiteral(record.embedding) : null);
+        return `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}::jsonb, $${base + 5}::vector)`;
+      });
       await this.client.query(`INSERT INTO ${this.table} (id, text, source, metadata, embedding)
-         VALUES ($1, $2, $3, $4, $5)
+         VALUES ${rows.join(", ")}
          ON CONFLICT (id) DO UPDATE SET
            text = EXCLUDED.text,
            source = EXCLUDED.source,
            metadata = EXCLUDED.metadata,
-           embedding = EXCLUDED.embedding`, [
-        id,
-        text,
-        source ?? null,
-        metadata !== void 0 ? JSON.stringify(metadata) : null,
-        toVectorLiteral(record.embedding)
-      ]);
+           embedding = EXCLUDED.embedding`, params);
     }
   }
   async remove(documentId) {
@@ -464,11 +629,12 @@ var PgVectorStore = class {
     return rows.length;
   }
   async listDocuments(filter) {
-    const where = buildWhere(filter, 1);
+    const params = [];
+    const where = this.where(filter, params);
     const rows = await this.client.query(`SELECT DISTINCT ON (${DOCUMENT_ID_FROM_CHUNK}) ${DOCUMENT_ID_FROM_CHUNK} AS doc_id, metadata
        FROM ${this.table}
-       ${where.sql}
-       ORDER BY ${DOCUMENT_ID_FROM_CHUNK}`, where.params);
+       ${where}
+       ORDER BY ${DOCUMENT_ID_FROM_CHUNK}`, params);
     return rows.map((row) => ({
       id: row.doc_id,
       ...row.metadata !== null ? {
@@ -519,11 +685,12 @@ var PgVectorStore = class {
     if (filterMatchesNothing(filter)) {
       return [];
     }
-    const where = buildWhere(filter, 1);
+    const params = [];
+    const where = this.where(filter, params);
     const rows = await this.client.query(`SELECT DISTINCT ${DOCUMENT_ID_FROM_CHUNK} AS doc_id
        FROM ${this.table}
-       ${where.sql}
-       ORDER BY doc_id`, where.params);
+       ${where}
+       ORDER BY doc_id`, params);
     return rows.map((row) => row.doc_id);
   }
   /** N documents in one statement — the set-based form of {@link PgVectorStore.remove}. */
@@ -547,81 +714,207 @@ var PgVectorStore = class {
     if (filterMatchesNothing(filter)) {
       return 0;
     }
-    const where = buildWhere(filter, 1);
-    const rows = await this.client.query(`DELETE FROM ${this.table} ${where.sql} RETURNING id`, where.params);
+    const params = [];
+    const where = this.where(filter, params);
+    const rows = await this.client.query(`DELETE FROM ${this.table} ${where} RETURNING id`, params);
     return rows.length;
   }
   async countChunks(filter) {
     if (filterMatchesNothing(filter)) {
       return 0;
     }
-    const where = buildWhere(filter, 1);
-    const rows = await this.client.query(`SELECT count(*)::int AS count FROM ${this.table} ${where.sql}`, where.params);
+    const params = [];
+    const where = this.where(filter, params);
+    const rows = await this.client.query(`SELECT count(*)::int AS count FROM ${this.table} ${where}`, params);
     return Number(rows[0]?.count ?? 0);
   }
+  /**
+  * Cosine similarity, nearest first. On a mixed-dimension table only vectors as wide as the query
+  * are compared (through that width's partial index when it has one); chunks without an embedding
+  * are never returned.
+  */
   async search(embedding, options) {
-    const vector = toVectorLiteral(embedding);
-    const where = buildWhere(options.filter, 3);
-    const rows = await this.client.query(`SELECT id, text, source, metadata, 1 - (embedding <=> $1::vector) AS score
+    if (embedding.length === 0) {
+      return [];
+    }
+    const params = [
+      toVectorLiteral(embedding),
+      options.topK
+    ];
+    const conditions = this.whereConditions(options.filter, params);
+    let vectorType = "vector";
+    if (this.dimensions === void 0) {
+      const width = embedding.length;
+      if (this.indexedDimensions.includes(width)) {
+        vectorType = `vector(${width})`;
+      }
+      conditions.push("embedding IS NOT NULL", `vector_dims(embedding) = ${width}`);
+    } else if (this.nullableEmbeddings) {
+      conditions.push("embedding IS NOT NULL");
+    }
+    const column = vectorType === "vector" ? "embedding" : `(embedding::${vectorType})`;
+    const sql = `SELECT id, text, source, metadata, 1 - (${column} <=> $1::${vectorType}) AS score
        FROM ${this.table}
-       ${where.sql}
-       ORDER BY embedding <=> $1::vector
-       LIMIT $2`, [
-      vector,
-      options.topK,
-      ...where.params
-    ]);
-    return rows.map((row) => ({
-      id: row.id,
-      text: row.text,
-      score: Number(row.score),
-      ...row.source !== null ? {
-        source: row.source
-      } : {},
-      ...row.metadata !== null ? {
-        metadata: row.metadata
-      } : {}
-    }));
+       ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""}
+       ORDER BY ${column} <=> $1::${vectorType}
+       LIMIT $2`;
+    const rows = await this.withSearchSettings((client) => client.query(sql, params));
+    return rows.map(toPassage);
+  }
+  /**
+  * The SQL conditions (ANDed) a metadata `filter` compiles to, appending their bindings to `params`
+  * (placeholders are numbered after what `params` already holds). Every statement that takes a
+  * filter goes through here, so a subclass that maps the filter onto its own columns — a tenant id,
+  * an access list — overrides this one method. Return `['false']` to deny.
+  */
+  whereConditions(filter, params) {
+    return buildWhere(filter, params);
+  }
+  where(filter, params) {
+    const conditions = this.whereConditions(filter, params);
+    return conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  }
+  /** Run a read with the configured HNSW settings `SET LOCAL` in one transaction, when possible. */
+  async withSearchSettings(read) {
+    const transaction = this.client.transaction?.bind(this.client);
+    if (transaction === void 0) {
+      return read(this.client);
+    }
+    const iterative = this.iterativeScan !== void 0 && await this.supportsIterativeScan();
+    if (!iterative && this.efSearch === void 0) {
+      return read(this.client);
+    }
+    return transaction(async (tx) => {
+      if (iterative) {
+        await tx.query(`SELECT set_config('hnsw.iterative_scan', $1, true)`, [
+          this.iterativeScan
+        ]);
+      }
+      if (this.efSearch !== void 0) {
+        await tx.query(`SELECT set_config('hnsw.ef_search', $1, true)`, [
+          String(this.efSearch)
+        ]);
+      }
+      return read(tx);
+    });
+  }
+  /** `hnsw.iterative_scan` exists from pgvector 0.8.0; setting it on an older one is an error. */
+  supportsIterativeScan() {
+    this.iterativeScanSupport ??= this.client.query(`SELECT extversion FROM pg_extension WHERE extname = 'vector'`).then((rows) => {
+      const [major = 0, minor = 0] = (rows[0]?.extversion ?? "0.0").split(".").map(Number);
+      return major > 0 || minor >= 8;
+    }).catch(() => false);
+    return this.iterativeScanSupport;
   }
 };
-function buildWhere(filter, startIndex) {
+var PgLexicalVectorStore = class extends PgVectorStore {
+  static {
+    __name(this, "PgLexicalVectorStore");
+  }
+  tsConfig;
+  tsColumn;
+  anyTermFallback;
+  constructor(client, options = {}) {
+    super(client, options);
+    const config = options.fullText?.config ?? "simple";
+    if (!SQL_IDENTIFIER.test(config)) {
+      throw new Error(`PgLexicalVectorStore: invalid text search configuration "${config}"`);
+    }
+    const column = options.fullText?.column;
+    if (column !== void 0 && !SQL_IDENTIFIER.test(column)) {
+      throw new Error(`PgLexicalVectorStore: invalid tsvector column "${column}"`);
+    }
+    this.tsConfig = config;
+    this.tsColumn = column;
+    this.anyTermFallback = options.fullText?.anyTermFallback ?? true;
+  }
+  schemaStatements() {
+    const statements = super.schemaStatements();
+    if (this.tsColumn === void 0) {
+      statements.push(`CREATE INDEX IF NOT EXISTS ${this.table}_text_tsv_idx
+        ON ${this.table} USING gin (${this.tsvector()})`);
+    }
+    return statements;
+  }
+  async searchText(query, options) {
+    if (filterMatchesNothing(options.filter) || query.trim() === "") {
+      return [];
+    }
+    const all = await this.runTextSearch(`websearch_to_tsquery('${this.tsConfig}', $1)`, query, options);
+    if (all.length > 0 || !this.anyTermFallback) {
+      return all;
+    }
+    const terms = [
+      ...new Set(query.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [])
+    ].slice(0, 24);
+    if (terms.length < 2) {
+      return all;
+    }
+    return this.runTextSearch(`to_tsquery('${this.tsConfig}', $1)`, terms.map((term) => `'${term}'`).join(" | "), options);
+  }
+  async runTextSearch(tsquery, query, options) {
+    const params = [
+      query,
+      options.topK
+    ];
+    const conditions = [
+      `${this.tsvector()} @@ ${tsquery}`,
+      ...this.whereConditions(options.filter, params)
+    ];
+    const rows = await this.client.query(`SELECT id, text, source, metadata, ts_rank_cd(${this.tsvector()}, ${tsquery}) AS score
+       FROM ${this.table}
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY score DESC, id
+       LIMIT $2`, params);
+    return rows.map(toPassage);
+  }
+  /** Must be character-for-character the index expression, or the planner won't use the index. */
+  tsvector() {
+    return this.tsColumn ?? `to_tsvector('${this.tsConfig}'::regconfig, text)`;
+  }
+};
+var SQL_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+function toPassage(row) {
+  return {
+    id: row.id,
+    text: row.text,
+    score: Number(row.score),
+    ...row.source !== null ? {
+      source: row.source
+    } : {},
+    ...row.metadata !== null ? {
+      metadata: row.metadata
+    } : {}
+  };
+}
+__name(toPassage, "toPassage");
+function buildWhere(filter, params) {
   if (filter === void 0 || Object.keys(filter).length === 0) {
-    return {
-      sql: "",
-      params: []
-    };
+    return [];
   }
   const stripped = stripNulBytes(filter);
   const clauses = [];
-  const params = [];
   const scalar = {};
-  let index = startIndex;
   for (const [key, value] of Object.entries(stripped)) {
     if (Array.isArray(value)) {
       if (value.length === 0) {
         clauses.push("false");
         continue;
       }
-      const keyParam = `$${index}`;
       params.push(key);
-      index += 1;
-      const arrParam = `$${index}`;
+      const keyParam = `$${params.length}`;
       params.push(value.map(String));
-      index += 1;
+      const arrParam = `$${params.length}`;
       clauses.push(`(CASE WHEN jsonb_typeof(metadata->${keyParam}) = 'array' THEN metadata->${keyParam} ELSE jsonb_build_array(metadata->${keyParam}) END) ?| ${arrParam}::text[]`);
     } else {
       scalar[key] = value;
     }
   }
   if (Object.keys(scalar).length > 0) {
-    clauses.push(`metadata @> $${index}::jsonb`);
     params.push(JSON.stringify(scalar));
-    index += 1;
+    clauses.push(`metadata @> $${params.length}::jsonb`);
   }
-  return {
-    sql: `WHERE ${clauses.join(" AND ")}`,
-    params
-  };
+  return clauses;
 }
 __name(buildWhere, "buildWhere");
 var DOCUMENT_ID_FROM_CHUNK = "regexp_replace(id, '#[0-9]+$', '')";
@@ -1431,7 +1724,7 @@ function parseSearchReply(reply, prefix, scoreSource = "vector") {
           attrs[toStr(rawFields[field])] = toStr(rawFields[field + 1]);
         }
         const inlineScore = scoreSource === "lexical" ? toStr(reply[index + 1]) : void 0;
-        passages.push(toPassage(toStr(reply[index]), attrs, prefix, scoreSource, inlineScore));
+        passages.push(toPassage2(toStr(reply[index]), attrs, prefix, scoreSource, inlineScore));
       }
     }
     return passages;
@@ -1439,7 +1732,7 @@ function parseSearchReply(reply, prefix, scoreSource = "vector") {
   if (typeof reply === "object" && reply !== null && "results" in reply) {
     const results = reply.results;
     if (Array.isArray(results)) {
-      return results.map((result) => toPassage(readId(result), readAttributes(result), prefix, scoreSource, scoreSource === "lexical" ? readScore(result) : void 0));
+      return results.map((result) => toPassage2(readId(result), readAttributes(result), prefix, scoreSource, scoreSource === "lexical" ? readScore(result) : void 0));
     }
   }
   return [];
@@ -1472,7 +1765,7 @@ function readAttributes(result) {
   return attrs;
 }
 __name(readAttributes, "readAttributes");
-function toPassage(rawId, attrs, prefix, scoreSource = "vector", inlineScore) {
+function toPassage2(rawId, attrs, prefix, scoreSource = "vector", inlineScore) {
   const score = scoreSource === "lexical" ? Number(inlineScore ?? "0") : 1 - Number(attrs.vector_score ?? "1");
   const source = attrs.source;
   return {
@@ -1485,7 +1778,7 @@ function toPassage(rawId, attrs, prefix, scoreSource = "vector", inlineScore) {
     ...parseMetadata(attrs.metadata_json)
   };
 }
-__name(toPassage, "toPassage");
+__name(toPassage2, "toPassage");
 function parseMetadata(raw) {
   if (raw === void 0) {
     return {};
@@ -1878,7 +2171,7 @@ async function ingestDocuments(documents, options) {
 __name(ingestDocuments, "ingestDocuments");
 
 // src/retrieval-telemetry.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage } from "async_hooks";
 import { channelName, emit, getChannel } from "@dudousxd/nestjs-diagnostics";
 var RAG_DIAGNOSTIC_LIB = "rag";
 var RAG_RETRIEVAL_EVENT = "retrieval";
@@ -2030,13 +2323,180 @@ function createRetrievalTool(retriever, options = {}) {
   };
 }
 __name(createRetrievalTool, "createRetrievalTool");
+
+// src/openai-embeddings.ts
+var HttpModelError = class extends Error {
+  static {
+    __name(this, "HttpModelError");
+  }
+  status;
+  constructor(status, message) {
+    super(message), this.status = status;
+    this.name = "HttpModelError";
+  }
+};
+function openAiEmbeddings(options) {
+  const url = `${(options.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "")}/embeddings`;
+  const batchSize = Math.max(1, Math.floor(options.batchSize ?? 64));
+  const maxInputChars = options.maxInputChars ?? 24e3;
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  const doFetch = options.fetch ?? fetch;
+  return {
+    async embed(texts) {
+      const vectors = [];
+      for (let start = 0; start < texts.length; start += batchSize) {
+        const input = texts.slice(start, start + batchSize).map((text) => (text.length > maxInputChars ? text.slice(0, maxInputChars) : text) || " ");
+        const response = await doFetch(url, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...options.apiKey ? {
+              authorization: `Bearer ${options.apiKey}`
+            } : {},
+            ...options.headers
+          },
+          body: JSON.stringify({
+            model: options.model,
+            input,
+            ...options.dimensions !== void 0 ? {
+              dimensions: options.dimensions
+            } : {}
+          }),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        const body = await response.text();
+        if (!response.ok) {
+          throw new HttpModelError(response.status, `Embeddings request failed (${response.status}): ${errorMessageOf(body)}`);
+        }
+        const json = parseJson(body);
+        const items = [
+          ...json?.data ?? []
+        ].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+        if (items.length !== input.length || !items.every((item) => Array.isArray(item.embedding))) {
+          throw new HttpModelError(502, `Embeddings returned ${items.length} vectors for ${input.length} inputs`);
+        }
+        for (const item of items) {
+          vectors.push(item.embedding);
+        }
+        const tokens = json?.usage?.total_tokens ?? json?.usage?.prompt_tokens;
+        if (typeof tokens === "number" && Number.isFinite(tokens)) {
+          options.onUsage?.(tokens);
+        }
+      }
+      return vectors;
+    }
+  };
+}
+__name(openAiEmbeddings, "openAiEmbeddings");
+function parseJson(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+__name(parseJson, "parseJson");
+function errorMessageOf(body) {
+  const json = parseJson(body);
+  const message = typeof json?.error === "string" ? json.error : json?.error?.message ?? json?.message ?? void 0;
+  return typeof message === "string" ? message : body.slice(0, 300);
+}
+__name(errorMessageOf, "errorMessageOf");
+
+// src/http-reranker.ts
+var HttpReranker = class {
+  static {
+    __name(this, "HttpReranker");
+  }
+  options;
+  format;
+  doFetch;
+  constructor(options) {
+    this.options = options;
+    this.format = options.format ?? "auto";
+    this.doFetch = options.fetch ?? fetch;
+  }
+  async rerank(query, passages, options = {}) {
+    if (passages.length === 0) {
+      return [];
+    }
+    const topK = options.topK ?? passages.length;
+    const documents = passages.map((passage) => passage.text);
+    const response = await this.doFetch(this.options.url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...this.options.apiKey ? {
+          authorization: `Bearer ${this.options.apiKey}`
+        } : {},
+        ...this.options.headers
+      },
+      body: JSON.stringify({
+        ...this.options.model !== void 0 ? {
+          model: this.options.model
+        } : {},
+        query,
+        ...this.format !== "tei" ? {
+          documents,
+          top_n: topK
+        } : {},
+        ...this.format !== "cohere" ? {
+          texts: documents
+        } : {}
+      }),
+      signal: AbortSignal.timeout(this.options.timeoutMs ?? 3e4)
+    });
+    const body = await response.text();
+    if (!response.ok) {
+      throw new HttpModelError(response.status, `Rerank request failed (${response.status}): ${errorMessageOf(body)}`);
+    }
+    const items = itemsOf(body);
+    if (items === void 0) {
+      throw new HttpModelError(502, "Rerank response has no results");
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const reranked = [];
+    for (const item of items) {
+      const index = item.index;
+      const passage = typeof index === "number" ? passages[index] : void 0;
+      if (passage === void 0 || seen.has(index)) {
+        continue;
+      }
+      seen.add(index);
+      reranked.push({
+        ...passage,
+        score: Number(item.relevance_score ?? item.score ?? 0)
+      });
+    }
+    reranked.sort((a, b) => b.score - a.score);
+    return reranked.slice(0, topK);
+  }
+};
+function itemsOf(body) {
+  let json;
+  try {
+    json = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (Array.isArray(json)) {
+    return json;
+  }
+  const wrapped = json;
+  const items = wrapped?.results ?? wrapped?.data;
+  return Array.isArray(items) ? items : void 0;
+}
+__name(itemsOf, "itemsOf");
 export {
   EmbeddingRetriever,
   FilteredRetriever,
+  HttpModelError,
+  HttpReranker,
   HybridRetriever,
   KeywordRetriever,
   LexicalRetriever,
   MemoryVectorStore,
+  PgLexicalVectorStore,
   PgVectorStore,
   RAG_DIAGNOSTIC_LIB,
   RAG_RETRIEVAL_CHANNEL,
@@ -2059,6 +2519,8 @@ export {
   ingestChunks,
   ingestDocuments,
   instrumentRetriever,
-  isLexicalVectorStore
+  isLexicalVectorStore,
+  openAiEmbeddings,
+  toPgClient
 };
 //# sourceMappingURL=index.js.map