@h-ai/vecdb 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/index.js

@@ -181,13 +181,17 @@ var ChromaConfigSchema = z.object({
     } catch {
       return false;
     }
-  }, { error: () => vecdbM("vecdb_chromaEndpointInvalid") }).optional(),
+  }, {
+    error: () => vecdbM("vecdb_chromaEndpointInvalid")
+  }).optional(),
   /** 主机（默认 localhost） */
   host: z.string().default("localhost"),
   /** 端口（默认 8000） */
   port: z.number().int().min(1).max(65535).default(8e3),
   /** 可选 Bearer token，发送 Authorization 请求头；用于采用此协议的自托管服务/网关，不是 Chroma Cloud 配置。空串表示未配置。 */
-  apiKey: z.string().regex(/^[\x21-\x7E]*$/, { error: () => vecdbM("vecdb_chromaTokenInvalid") }).optional(),
+  apiKey: z.string().regex(/^[\x21-\x7E]*$/, {
+    error: () => vecdbM("vecdb_chromaTokenInvalid")
+  }).optional(),
   /** 拉起本地服务的可执行命令（默认 'chroma'，可指定绝对路径） */
   serverCommand: z.string().default("chroma"),
   /** 拉起本地服务的就绪等待超时（毫秒，默认 30000） */
@@ -219,6 +223,13 @@ var VecdbErrorInfo = {
   SERIALIZATION_FAILED: "014:500"
 };
 var HaiVecdbError = core.error.buildHaiErrorsDef("vecdb", VecdbErrorInfo);
+function vectorScoreFromDistance(distance, metric) {
+  if (metric === "cosine")
+    return Math.max(0, Math.min(1, 1 - distance / 2));
+  if (metric === "dot")
+    return 1 / (1 + Math.exp(distance));
+  return 1 / (1 + Math.max(0, distance));
+}
 function stringifyOperationPayload(payload, maxLength) {
   if (maxLength <= 0) {
     return "";
@@ -253,13 +264,21 @@ function logVecdbOperation(ctx, category, operation, payload) {
 function errorMsgFromCode(def, errorStr) {
   switch (def) {
     case HaiVecdbError.DELETE_FAILED:
-      return vecdbM("vecdb_deleteFailed", { params: { error: errorStr } });
+      return vecdbM("vecdb_deleteFailed", {
+        params: { error: errorStr }
+      });
     case HaiVecdbError.INSERT_FAILED:
-      return vecdbM("vecdb_insertFailed", { params: { error: errorStr } });
+      return vecdbM("vecdb_insertFailed", {
+        params: { error: errorStr }
+      });
     case HaiVecdbError.UPDATE_FAILED:
-      return vecdbM("vecdb_updateFailed", { params: { error: errorStr } });
+      return vecdbM("vecdb_updateFailed", {
+        params: { error: errorStr }
+      });
     default:
-      return vecdbM("vecdb_queryFailed", { params: { error: errorStr } });
+      return vecdbM("vecdb_queryFailed", {
+        params: { error: errorStr }
+      });
   }
 }
 async function wrapOp(ctx, fn, errorDef, errorLabel, errorMeta) {
@@ -279,7 +298,11 @@ function createBaseCollectionOps(ctx, driver) {
       if (!Number.isInteger(options.dimension) || options.dimension <= 0) {
         return err(
           HaiVecdbError.DIMENSION_MISMATCH,
-          vecdbM("vecdb_invalidDimension", { params: { dimension: String(options.dimension) } })
+          vecdbM("vecdb_invalidDimension", {
+            params: {
+              dimension: String(options.dimension)
+            }
+          })
         );
       }
       logVecdbOperation(ctx, "write", "collection.create", { name, options });
@@ -416,9 +439,7 @@ function fromChromaSpace(space) {
   return "cosine";
 }
 function distanceToScore(distance, metric) {
-  if (metric === "cosine")
-    return Math.max(0, Math.min(1, 1 - distance));
-  return 1 / (1 + Math.max(0, distance));
+  return vectorScoreFromDistance(metric === "dot" ? distance - 1 : distance, metric);
 }
 function buildWhere(filter) {
   if (!filter)
@@ -426,7 +447,9 @@ function buildWhere(filter) {
   const entries = Object.entries(filter);
   if (entries.length === 0)
     return void 0;
-  const where = entries.length === 1 ? { [entries[0][0]]: entries[0][1] } : { $and: entries.map(([key, value]) => ({ [key]: value })) };
+  const where = entries.length === 1 ? { [entries[0][0]]: entries[0][1] } : {
+    $and: entries.map(([key, value]) => ({ [key]: value }))
+  };
   return where;
 }
 function createChromaProvider() {
@@ -445,19 +468,33 @@ function createChromaProvider() {
       if (!isChromaModule(mod)) {
         const error = new Error("chromadb driver module does not export ChromaClient");
         logger.error("Failed to load Chroma driver", { error: error.message });
-        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "chromadb" } }), error);
+        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", {
+          params: { driver: "chromadb" }
+        }), error);
       }
       return ok(mod);
     } catch (error) {
       if (isMissingModuleError(error)) {
-        logger.error("Failed to load Chroma driver", { error: error instanceof Error ? error.message : String(error) });
-        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "chromadb" } }), error);
+        logger.error("Failed to load Chroma driver", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", {
+          params: { driver: "chromadb" }
+        }), error);
       }
       throw error;
     }
   }
   async function startEmbeddedServer(chromaConfig) {
-    const args = ["run", "--path", chromaConfig.path ?? "./data/chroma", "--host", chromaConfig.host, "--port", String(chromaConfig.port)];
+    const args = [
+      "run",
+      "--path",
+      chromaConfig.path ?? "./data/chroma",
+      "--host",
+      chromaConfig.host,
+      "--port",
+      String(chromaConfig.port)
+    ];
     logger.info("Starting embedded Chroma server", { command: chromaConfig.serverCommand, host: chromaConfig.host, port: chromaConfig.port });
     spawnFailed = false;
     const proc = spawn(chromaConfig.serverCommand, args, { stdio: "ignore" });
@@ -536,7 +573,16 @@ function createChromaProvider() {
           logger.info("Chroma connection closed");
           return ok(void 0);
         } catch (cause) {
-          return err({ ...HaiVecdbError.CONNECTION_FAILED, message: vecdbM("vecdb_closeFailed", { params: { error: cause instanceof Error ? cause.message : String(cause) } }), cause, ext: { cleanupPending: true } });
+          return err({
+            ...HaiVecdbError.CONNECTION_FAILED,
+            message: vecdbM("vecdb_closeFailed", {
+              params: {
+                error: cause instanceof Error ? cause.message : String(cause)
+              }
+            }),
+            cause,
+            ext: { cleanupPending: true }
+          });
         }
       })().finally(() => {
         closing = null;
@@ -570,21 +616,36 @@ function createChromaProvider() {
       return null;
     return err(
       HaiVecdbError.DIMENSION_MISMATCH,
-      vecdbM("vecdb_dimensionMismatch", { params: { expected: String(expected), actual: String(actual) } })
+      vecdbM("vecdb_dimensionMismatch", {
+        params: {
+          expected: String(expected),
+          actual: String(actual)
+        }
+      })
     );
   }
-  const ctx = { isConnected: () => client !== null, logger, operationLog: () => config?.operationLog };
+  const ctx = {
+    isConnected: () => client !== null,
+    logger,
+    operationLog: () => config?.operationLog
+  };
   const collectionDriver = {
     async create(name, options) {
       logger.debug("Creating collection", { name, dimension: options.dimension, metric: options.metric });
       const existing = await client.listCollections();
       const exists = existing.some((item) => item.name === name);
-      if (exists)
-        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", { params: { name } }));
+      if (exists) {
+        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", {
+          params: { name }
+        }));
+      }
       const metric = options.metric ?? config?.metric ?? "cosine";
       await client.getOrCreateCollection({
         name,
-        metadata: { [SPACE_METADATA_KEY]: toChromaSpace(metric), [DIMENSION_METADATA_KEY]: options.dimension },
+        metadata: {
+          [SPACE_METADATA_KEY]: toChromaSpace(metric),
+          [DIMENSION_METADATA_KEY]: options.dimension
+        },
         embeddingFunction: NOOP_EMBEDDING_FUNCTION
       });
       logger.info("Collection created", { name, dimension: options.dimension, metric });
@@ -594,8 +655,11 @@ function createChromaProvider() {
       logger.debug("Dropping collection", { name });
       const existing = await client.listCollections();
       const exists = existing.some((item) => item.name === name);
-      if (!exists)
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      if (!exists) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", {
+          params: { name }
+        }));
+      }
       await client.deleteCollection({ name });
       logger.info("Collection dropped", { name });
       return ok(void 0);
@@ -608,8 +672,11 @@ function createChromaProvider() {
     async info(name) {
       logger.debug("Getting collection info", { name });
       const existing = await client.listCollections();
-      if (!existing.some((item) => item.name === name))
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      if (!existing.some((item) => item.name === name)) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", {
+          params: { name }
+        }));
+      }
       const collection = await getCollection(name);
       const count = await collection.count();
       return ok({
@@ -679,7 +746,11 @@ function createChromaProvider() {
       if (validation)
         return validation;
       const metric = fromChromaSpace(target.metadata?.[SPACE_METADATA_KEY]);
-      const response = await target.query({ queryEmbeddings: [vector], nResults: topK, where: buildWhere(options?.filter) });
+      const response = await target.query({
+        queryEmbeddings: [vector],
+        nResults: topK,
+        where: buildWhere(options?.filter)
+      });
       const ids = response.ids[0] ?? [];
       const distances = response.distances?.[0] ?? [];
       const metadatas = response.metadatas?.[0] ?? [];
@@ -708,8 +779,11 @@ function createChromaProvider() {
   return {
     name: "chroma",
     async connect(cfg) {
-      if (cfg.type !== "chroma")
-        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
+      if (cfg.type !== "chroma") {
+        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", {
+          params: { type: cfg.type }
+        }));
+      }
       if (serverProcess || client || closing) {
         const cleaned = await closeResources();
         if (!cleaned.success)
@@ -727,7 +801,11 @@ function createChromaProvider() {
         if (embedded)
           await startEmbeddedServer(chromaConfig);
         const endpoint = chromaConfig.url ? new URL(chromaConfig.url) : void 0;
-        const clientParams = endpoint ? { host: endpoint.hostname, port: Number(endpoint.port || (endpoint.protocol === "https:" ? 443 : 80)), ssl: endpoint.protocol === "https:" } : { host: chromaConfig.host, port: chromaConfig.port, ssl: false };
+        const clientParams = endpoint ? {
+          host: endpoint.hostname,
+          port: Number(endpoint.port || (endpoint.protocol === "https:" ? 443 : 80)),
+          ssl: endpoint.protocol === "https:"
+        } : { host: chromaConfig.host, port: chromaConfig.port, ssl: false };
         if (chromaConfig.apiKey)
           clientParams.headers = { Authorization: `Bearer ${chromaConfig.apiKey}` };
         clientParams.fetchOptions = { signal: startupAbort.signal };
@@ -739,14 +817,28 @@ function createChromaProvider() {
           throw new Error("Chroma child exited before readiness was confirmed");
         client = chromaClient;
         config = chromaConfig;
-        logger.info("Chroma connected", { embedded, host: clientParams.host, port: clientParams.port, ssl: clientParams.ssl });
+        logger.info("Chroma connected", {
+          embedded,
+          host: clientParams.host,
+          port: clientParams.port,
+          ssl: clientParams.ssl
+        });
         return ok(void 0);
       } catch (error) {
         startupAbort.abort();
         const cleanup = await closeResources();
-        logger.error("Failed to connect to Chroma", { error: error instanceof Error ? error.message : String(error) });
-        const failure = err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", { params: { error: String(error) } }), error);
-        return !failure.success && !cleanup.success ? err({ ...failure.error, ext: { cleanupPending: true, cleanupError: cleanup.error } }) : failure;
+        logger.error("Failed to connect to Chroma", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        const failure = err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", {
+          params: {
+            error: String(error)
+          }
+        }), error);
+        return !failure.success && !cleanup.success ? err({
+          ...failure.error,
+          ext: { cleanupPending: true, cleanupError: cleanup.error }
+        }) : failure;
       } finally {
         clearTimeout(startupTimer);
       }
@@ -792,19 +884,26 @@ function createLancedbProvider() {
       return ok(mod);
     } catch (error) {
       logger2.error("Failed to load @lancedb/lancedb", { error });
-      return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "@lancedb/lancedb" } }), error);
+      return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", {
+        params: { driver: "@lancedb/lancedb" }
+      }), error);
     }
   }
   async function withCollection(name, action) {
-    if (!(await connection.tableNames()).includes(name))
-      return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+    if (!(await connection.tableNames()).includes(name)) {
+      return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", {
+        params: { name }
+      }));
+    }
     const table = await connection.openTable(name);
     try {
       const schema = await table.schema();
       const vectorType = schema.fields.find((field) => field.name === "vector")?.type;
       const metric = DistanceMetricSchema.safeParse(schema.metadata.get(COLLECTION_METRIC_KEY) ?? null);
       if (!vectorType || !("listSize" in vectorType) || typeof vectorType.listSize !== "number" || !Number.isInteger(vectorType.listSize) || vectorType.listSize <= 0 || !metric.success) {
-        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", { params: { name } }));
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", {
+          params: { name }
+        }));
       }
       const primaryKeys = schema.fields.filter((field) => field.metadata.has(PRIMARY_KEY_POSITION) || ["true", "1", "yes"].includes(field.metadata.get(PRIMARY_KEY_FLAG)?.toLowerCase() ?? ""));
       const idField = primaryKeys[0];
@@ -813,8 +912,15 @@ function createLancedbProvider() {
       if (!driver.success)
         return driver;
       const jsonMetadata = schema.fields.find((field) => field.name === "metadata")?.metadata.get("ARROW:extension:name") === "lance.json";
-      const inputSchema = jsonMetadata ? schema.assign([driver.data.makeJsonField("metadata", false)]) : void 0;
-      return await action(table, { dimension: vectorType.listSize, metric: metric.data, atomicWrites, inputSchema });
+      const inputSchema = jsonMetadata ? schema.assign([
+        driver.data.makeJsonField("metadata", false)
+      ]) : void 0;
+      return await action(table, {
+        dimension: vectorType.listSize,
+        metric: metric.data,
+        atomicWrites,
+        inputSchema
+      });
     } finally {
       table.close();
     }
@@ -823,7 +929,10 @@ function createLancedbProvider() {
     return err(
       HaiVecdbError.DIMENSION_MISMATCH,
       vecdbM("vecdb_dimensionMismatch", {
-        params: { expected: String(expected), actual: String(actual) }
+        params: {
+          expected: String(expected),
+          actual: String(actual)
+        }
       })
     );
   }
@@ -850,29 +959,49 @@ function createLancedbProvider() {
       return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_duplicateDocumentIds"));
     return null;
   }
-  const ctx = { isConnected: () => connection !== null, logger: logger2, operationLog: () => config?.operationLog };
+  const ctx = {
+    isConnected: () => connection !== null,
+    logger: logger2,
+    operationLog: () => config?.operationLog
+  };
   const collectionDriver = {
     async create(name, options) {
       logger2.debug("Creating collection", { name, dimension: options.dimension, metric: options.metric });
       const tableNames = await connection.tableNames();
       if (tableNames.includes(name)) {
-        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", { params: { name } }));
+        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", {
+          params: { name }
+        }));
       }
       const dimension = options.dimension;
       const parsedMetric = DistanceMetricSchema.safeParse(options.metric ?? config?.metric);
-      if (!parsedMetric.success)
-        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", { params: { name } }));
+      if (!parsedMetric.success) {
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", {
+          params: { name }
+        }));
+      }
       const metric = parsedMetric.data;
       const driver = loadLancedb();
       if (!driver.success)
         return driver;
-      const inferred = driver.data.makeArrowTable([{
-        id: "",
-        vector: Array.from({ length: dimension }).fill(0),
-        content: "",
-        metadata: "{}"
-      }], {}, /* @__PURE__ */ new Map([[COLLECTION_METRIC_KEY, metric]])).schema;
-      const schema = inferred.assign(inferred.fields.map((field) => field.name === "id" ? field.clone({ nullable: false, metadata: new Map([...field.metadata, [PRIMARY_KEY_FLAG, "true"], [PRIMARY_KEY_POSITION, "1"]]) }) : field.name === "metadata" ? driver.data.makeJsonField("metadata", false) : field));
+      const inferred = driver.data.makeArrowTable([
+        {
+          id: "",
+          vector: Array.from({ length: dimension }).fill(0),
+          content: "",
+          metadata: "{}"
+        }
+      ], {}, /* @__PURE__ */ new Map([
+        [COLLECTION_METRIC_KEY, metric]
+      ])).schema;
+      const schema = inferred.assign(inferred.fields.map((field) => field.name === "id" ? field.clone({
+        nullable: false,
+        metadata: new Map([
+          ...field.metadata,
+          [PRIMARY_KEY_FLAG, "true"],
+          [PRIMARY_KEY_POSITION, "1"]
+        ])
+      }) : field.name === "metadata" ? driver.data.makeJsonField("metadata", false) : field));
       const table = await connection.createEmptyTable(name, schema);
       table.close();
       logger2.info("Collection created", { name, dimension, metric });
@@ -882,7 +1011,9 @@ function createLancedbProvider() {
       logger2.debug("Dropping collection", { name });
       const tableNames = await connection.tableNames();
       if (!tableNames.includes(name)) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", {
+          params: { name }
+        }));
       }
       await connection.dropTable(name);
       logger2.info("Collection dropped", { name });
@@ -895,7 +1026,12 @@ function createLancedbProvider() {
     },
     async info(name) {
       logger2.debug("Getting collection info", { name });
-      return withCollection(name, async (table, meta) => ok({ name, dimension: meta.dimension, metric: meta.metric, count: await table.countRows() }));
+      return withCollection(name, async (table, meta) => ok({
+        name,
+        dimension: meta.dimension,
+        metric: meta.metric,
+        count: await table.countRows()
+      }));
     },
     async list() {
       logger2.debug("Listing collections");
@@ -983,7 +1119,7 @@ function createLancedbProvider() {
         const results = await query.toArray();
         const searchResults = results.map((row) => {
           const distance = row._distance ?? 0;
-          const score = meta.metric === "cosine" ? Math.max(0, Math.min(1, 1 - distance / 2)) : meta.metric === "dot" ? 1 / (1 + Math.exp(distance - 1)) : 1 / (1 + Math.max(0, distance));
+          const score = vectorScoreFromDistance(meta.metric === "dot" ? distance - 1 : distance, meta.metric);
           return {
             id: row.id,
             score,
@@ -1006,7 +1142,9 @@ function createLancedbProvider() {
     name: "lancedb",
     async connect(cfg) {
       if (cfg.type !== "lancedb") {
-        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
+        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", {
+          params: { type: cfg.type }
+        }));
       }
       const lanceConfig = cfg;
       const loadResult = loadLancedb();
@@ -1023,7 +1161,11 @@ function createLancedbProvider() {
         connection = null;
         config = null;
         logger2.error("Failed to connect to LanceDB", { error });
-        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", { params: { error: String(error) } }), error);
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", {
+          params: {
+            error: String(error)
+          }
+        }), error);
       }
     },
     async close() {
@@ -1070,16 +1212,7 @@ function createPgvectorProvider() {
     }
   }
   function distanceToScore2(distance, metric) {
-    switch (metric) {
-      case "cosine":
-        return 1 - distance / 2;
-      case "euclidean":
-        return 1 / (1 + distance);
-      case "dot":
-        return -distance;
-      default:
-        return 1 / (1 + distance);
-    }
+    return vectorScoreFromDistance(distance, metric);
   }
   function isMissingModuleError(error, packageName) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1091,13 +1224,19 @@ function createPgvectorProvider() {
       if (!isPgModule(mod)) {
         const error = new Error("pg driver module does not export Pool");
         logger3.error("Failed to load pg driver", { error: error.message });
-        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "pg" } }), error);
+        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", {
+          params: { driver: "pg" }
+        }), error);
       }
       return ok(mod);
     } catch (error) {
       if (isMissingModuleError(error, "pg")) {
-        logger3.error("Failed to load pg driver", { error: error instanceof Error ? error.message : String(error) });
-        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "pg" } }), error);
+        logger3.error("Failed to load pg driver", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", {
+          params: { driver: "pg" }
+        }), error);
       }
       throw error;
     }
@@ -1109,19 +1248,25 @@ function createPgvectorProvider() {
       [table]
     );
     if (!existsResult.rows[0].exists) {
-      return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", {
+        params: { name }
+      }));
     }
     const dimResult = await pool.query(`
       SELECT atttypmod FROM pg_attribute
       WHERE attrelid = $1::regclass AND attname = 'vector'
-    `, [quoteIdent(table)]);
+    `, [
+      quoteIdent(table)
+    ]);
     return ok(dimResult.rows.length > 0 ? Number(dimResult.rows[0].atttypmod) : 0);
   }
   async function getCollectionMetric(name) {
     const result = await pool.query(`SELECT col_description(a.attrelid, a.attnum) AS definition,
       (SELECT opc.opcname FROM pg_index i JOIN pg_opclass opc ON opc.oid = ANY(i.indclass)
        WHERE i.indrelid = a.attrelid AND opc.opcname IN ('vector_cosine_ops', 'vector_l2_ops', 'vector_ip_ops') LIMIT 1) AS operator
-      FROM pg_attribute a WHERE a.attrelid = $1::regclass AND a.attname = 'vector'`, [quoteIdent(tableName(name))]);
+      FROM pg_attribute a WHERE a.attrelid = $1::regclass AND a.attname = 'vector'`, [
+      quoteIdent(tableName(name))
+    ]);
     const row = result.rows[0];
     const stored = typeof row?.definition === "string" && row.definition.startsWith("hai.vecdb.metric=") ? row.definition.slice("hai.vecdb.metric=".length) : void 0;
     const inherited = row?.operator === "vector_cosine_ops" ? "cosine" : row?.operator === "vector_l2_ops" ? "euclidean" : row?.operator === "vector_ip_ops" ? "dot" : void 0;
@@ -1138,7 +1283,10 @@ function createPgvectorProvider() {
     return err(
       HaiVecdbError.DIMENSION_MISMATCH,
       vecdbM("vecdb_dimensionMismatch", {
-        params: { expected: String(expected), actual: String(actual) }
+        params: {
+          expected: String(expected),
+          actual: String(actual)
+        }
       })
     );
   }
@@ -1151,7 +1299,11 @@ function createPgvectorProvider() {
     }
     return null;
   }
-  const ctx = { isConnected: () => pool !== null, logger: logger3, operationLog: () => config?.operationLog };
+  const ctx = {
+    isConnected: () => pool !== null,
+    logger: logger3,
+    operationLog: () => config?.operationLog
+  };
   const collectionDriver = {
     async create(name, options) {
       const table = tableName(name);
@@ -1164,7 +1316,9 @@ function createPgvectorProvider() {
         [table]
       );
       if (checkResult.rows[0].exists) {
-        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", { params: { name } }));
+        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", {
+          params: { name }
+        }));
       }
       const qi = quoteIdent(table);
       await pool.query(`
@@ -1201,7 +1355,9 @@ function createPgvectorProvider() {
         [table]
       );
       if (!checkResult.rows[0].exists) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", {
+          params: { name }
+        }));
       }
       await pool.query(`DROP TABLE ${quoteIdent(table)}`);
       logger3.info("Collection dropped", { name });
@@ -1211,7 +1367,9 @@ function createPgvectorProvider() {
       logger3.debug("Checking collection exists", { name });
       const result = await pool.query(
         `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
-        [tableName(name)]
+        [
+          tableName(name)
+        ]
       );
       return ok(result.rows[0].exists);
     },
@@ -1376,7 +1534,9 @@ function createPgvectorProvider() {
     name: "pgvector",
     async connect(cfg) {
       if (cfg.type !== "pgvector") {
-        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
+        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", {
+          params: { type: cfg.type }
+        }));
       }
       const pgConfig = cfg;
       try {
@@ -1398,8 +1558,14 @@ function createPgvectorProvider() {
         logger3.info("pgvector connected", { host: pgConfig.host, database: pgConfig.database });
         return ok(void 0);
       } catch (error) {
-        logger3.error("Failed to connect to pgvector", { error: error instanceof Error ? error.message : String(error) });
-        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", { params: { error: error instanceof Error ? error.message : String(error) } }), error);
+        logger3.error("Failed to connect to pgvector", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", {
+          params: {
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }), error);
       }
     },
     async close() {
@@ -1412,8 +1578,14 @@ function createPgvectorProvider() {
         logger3.info("pgvector connection closed");
         return ok(void 0);
       } catch (error) {
-        logger3.error("Failed to close pgvector connection", { error: error instanceof Error ? error.message : String(error) });
-        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_closeFailed", { params: { error: String(error) } }), error);
+        logger3.error("Failed to close pgvector connection", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_closeFailed", {
+          params: {
+            error: String(error)
+          }
+        }), error);
       }
     },
     isConnected() {
@@ -1423,14 +1595,152 @@ function createPgvectorProvider() {
     vector: createBaseVectorOps(ctx, vectorDriver)
   };
 }
-var logger4 = core.logger.child({ module: "vecdb", scope: "qdrant" });
-function isQdrantModule(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
+var MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+var pointSchema = z.object({
+  id: z.union([
+    z.string(),
+    z.number()
+  ]),
+  score: z.number().optional(),
+  payload: z.record(z.string(), z.unknown()).nullable().optional(),
+  vector: z.array(z.number()).optional()
+});
+var collectionSchema = z.object({
+  config: z.object({
+    params: z.object({
+      vectors: z.unknown()
+    })
+  }),
+  points_count: z.number().nullable().optional()
+});
+var QdrantHttpError = class extends Error {
+  constructor(status) {
+    super(`Qdrant HTTP request failed (${status})`);
+    this.status = status;
   }
-  const maybeModule = value;
-  return typeof maybeModule.QdrantClient === "function";
-}
+  status;
+};
+var QdrantRestClient = class {
+  constructor(url, apiKey) {
+    this.apiKey = apiKey;
+    this.base = new URL(url);
+    if (!["http:", "https:"].includes(this.base.protocol) || this.base.username || this.base.password)
+      throw new Error("Qdrant URL must use HTTP(S) without embedded credentials");
+  }
+  apiKey;
+  base;
+  async perform(path, method, schema, body) {
+    const url = new URL(this.base);
+    const [pathname, query] = path.split("?");
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${pathname}`;
+    for (const [key, value] of new URLSearchParams(query)) url.searchParams.set(key, value);
+    const response = await fetch(url, {
+      method,
+      redirect: "error",
+      signal: AbortSignal.timeout(3e4),
+      headers: {
+        "content-type": "application/json",
+        ...this.apiKey ? { "api-key": this.apiKey } : {}
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new QdrantHttpError(response.status);
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+      throw new Error("Qdrant response body is missing");
+    let size = 0;
+    const chunks = [];
+    try {
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done)
+          break;
+        size += chunk.value.byteLength;
+        if (size > MAX_RESPONSE_BYTES)
+          throw new Error("Qdrant response exceeds 16 MiB");
+        chunks.push(chunk.value);
+      }
+    } finally {
+      await reader.cancel().catch(() => void 0);
+      reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    let bodyJson;
+    try {
+      bodyJson = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      throw new Error("Qdrant returned invalid JSON");
+    }
+    const envelope = z.object({
+      status: z.literal("ok"),
+      result: schema
+    }).safeParse(bodyJson);
+    if (!envelope.success)
+      throw new Error("Qdrant returned an invalid response");
+    return envelope.data.result;
+  }
+  async request(path, method, schema, body) {
+    try {
+      return await this.perform(path, method, schema, body);
+    } catch (error) {
+      if (error instanceof QdrantHttpError)
+        throw error;
+      core.logger.child({ module: "vecdb", scope: "qdrant-http" }).error("Qdrant HTTP transport failed", {
+        error: core.sanitize.sanitizeSensitiveFields(error)
+      });
+      throw new Error("Qdrant request failed");
+    }
+  }
+  getCollections() {
+    return this.request("/collections", "GET", z.object({
+      collections: z.array(z.object({
+        name: z.string()
+      }))
+    }));
+  }
+  getCollection(name) {
+    return this.request(`/collections/${encodeURIComponent(name)}`, "GET", collectionSchema);
+  }
+  createCollection(name, options) {
+    return this.request(`/collections/${encodeURIComponent(name)}`, "PUT", z.boolean(), options);
+  }
+  deleteCollection(name) {
+    return this.request(`/collections/${encodeURIComponent(name)}`, "DELETE", z.boolean());
+  }
+  upsert(name, options) {
+    return this.request(`/collections/${encodeURIComponent(name)}/points?wait=${options.wait}`, "PUT", z.object({
+      status: z.literal("completed")
+    }), { points: options.points });
+  }
+  delete(name, options) {
+    return this.request(`/collections/${encodeURIComponent(name)}/points/delete?wait=${options.wait}`, "POST", z.object({
+      status: z.literal("completed")
+    }), { points: options.points });
+  }
+  query(name, options) {
+    return this.request(`/collections/${encodeURIComponent(name)}/points/query`, "POST", z.object({
+      points: z.array(pointSchema.extend({
+        score: z.number()
+      }))
+    }), options);
+  }
+  count(name, options) {
+    return this.request(`/collections/${encodeURIComponent(name)}/points/count`, "POST", z.object({
+      count: z.number()
+    }), options);
+  }
+};
+
+// src/providers/vecdb-provider-qdrant.ts
+var logger4 = core.logger.child({ module: "vecdb", scope: "qdrant" });
 function hashToUuid(id) {
   const hash = createHash("sha256").update(id).digest("hex");
   return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
@@ -1448,27 +1758,6 @@ function toQdrantDistance(metric) {
 function createQdrantProvider() {
   let client = null;
   let config = null;
-  function isMissingModuleError(error, packageName) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes(`'${packageName}'`) || message.includes(`"${packageName}"`) || message.includes(packageName);
-  }
-  async function loadQdrantClient() {
-    try {
-      const mod = await import('@qdrant/js-client-rest');
-      if (!isQdrantModule(mod)) {
-        const error = new Error("@qdrant/js-client-rest driver module does not export QdrantClient");
-        logger4.error("Failed to load Qdrant driver", { error: error.message });
-        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "@qdrant/js-client-rest" } }), error);
-      }
-      return ok(mod);
-    } catch (error) {
-      if (isMissingModuleError(error, "@qdrant/js-client-rest")) {
-        logger4.error("Failed to load Qdrant driver", { error: error instanceof Error ? error.message : String(error) });
-        return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "@qdrant/js-client-rest" } }), error);
-      }
-      throw error;
-    }
-  }
   function isQdrantNotFoundError(error) {
     return typeof error === "object" && error !== null && "status" in error && error.status === 404;
   }
@@ -1477,14 +1766,16 @@ function createQdrantProvider() {
       return ok(await client.getCollection(name));
     } catch (error) {
       if (isQdrantNotFoundError(error)) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", {
+          params: { name }
+        }));
       }
       throw error;
     }
   }
   function readVectorDefinition(info) {
     const vectors = info.config.params.vectors;
-    if (!vectors || !("size" in vectors) || typeof vectors.size !== "number" || !Number.isSafeInteger(vectors.size) || vectors.size <= 0)
+    if (!vectors || typeof vectors !== "object" || !("size" in vectors) || typeof vectors.size !== "number" || !Number.isSafeInteger(vectors.size) || vectors.size <= 0)
       return void 0;
     if (!("distance" in vectors))
       return void 0;
@@ -1497,7 +1788,9 @@ function createQdrantProvider() {
       return infoResult;
     }
     const definition = readVectorDefinition(infoResult.data);
-    return definition ? ok(definition.dimension) : err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", { params: { name } }));
+    return definition ? ok(definition.dimension) : err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", {
+      params: { name }
+    }));
   }
   function validateVectorDimension(expected, actual) {
     if (expected === actual) {
@@ -1506,18 +1799,27 @@ function createQdrantProvider() {
     return err(
       HaiVecdbError.DIMENSION_MISMATCH,
       vecdbM("vecdb_dimensionMismatch", {
-        params: { expected: String(expected), actual: String(actual) }
+        params: {
+          expected: String(expected),
+          actual: String(actual)
+        }
       })
     );
   }
-  const ctx = { isConnected: () => client !== null, logger: logger4, operationLog: () => config?.operationLog };
+  const ctx = {
+    isConnected: () => client !== null,
+    logger: logger4,
+    operationLog: () => config?.operationLog
+  };
   const collectionDriver = {
     async create(name, options) {
       logger4.debug("Creating collection", { name, dimension: options.dimension, metric: options.metric });
       const collections = await client.getCollections();
       const exists = collections.collections.some((c) => c.name === name);
       if (exists) {
-        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", { params: { name } }));
+        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", {
+          params: { name }
+        }));
       }
       const metric = options.metric ?? config?.metric ?? "cosine";
       await client.createCollection(name, {
@@ -1559,8 +1861,11 @@ function createQdrantProvider() {
       }
       const collectionInfo = infoResult.data;
       const definition = readVectorDefinition(collectionInfo);
-      if (!definition)
-        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", { params: { name } }));
+      if (!definition) {
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", {
+          params: { name }
+        }));
+      }
       return ok({
         name,
         ...definition,
@@ -1636,11 +1941,16 @@ function createQdrantProvider() {
       const topK = options?.topK ?? 10;
       const minScore = options?.minScore ?? 0;
       logger4.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
-      const dimensionResult = await getCollectionDimension(collection);
-      if (!dimensionResult.success) {
-        return dimensionResult;
+      const collectionInfo = await getCollectionInfo(collection);
+      if (!collectionInfo.success)
+        return collectionInfo;
+      const definition = readVectorDefinition(collectionInfo.data);
+      if (!definition) {
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", {
+          params: { name: collection }
+        }));
       }
-      const dimensionValidation = validateVectorDimension(dimensionResult.data, vector.length);
+      const dimensionValidation = validateVectorDimension(definition.dimension, vector.length);
       if (dimensionValidation) {
         return dimensionValidation;
       }
@@ -1655,7 +1965,6 @@ function createQdrantProvider() {
       const searchResult = await client.query(collection, {
         query: vector,
         limit: topK,
-        score_threshold: minScore > 0 ? minScore : void 0,
         filter,
         with_payload: true
       });
@@ -1664,11 +1973,12 @@ function createQdrantProvider() {
         const { _id, _content, ...metadata } = payload;
         return {
           id: typeof _id === "string" ? _id : "",
-          score: point.score,
+          // Qdrant 余弦/内积返回相似值，欧氏返回距离；统一后再应用公开阈值。
+          score: vectorScoreFromDistance(definition.metric === "cosine" ? 1 - point.score : definition.metric === "dot" ? -point.score : point.score, definition.metric),
           content: typeof _content === "string" && _content.length > 0 ? _content : void 0,
           metadata: Object.keys(metadata).length > 0 ? metadata : void 0
         };
-      });
+      }).filter((point) => point.score >= minScore);
       return ok(results);
     },
     async count(collection) {
@@ -1681,27 +1991,27 @@ function createQdrantProvider() {
     name: "qdrant",
     async connect(cfg) {
       if (cfg.type !== "qdrant") {
-        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
+        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", {
+          params: { type: cfg.type }
+        }));
       }
       const qdrantConfig = cfg;
       try {
-        const loadResult = await loadQdrantClient();
-        if (!loadResult.success) {
-          return loadResult;
-        }
-        const { QdrantClient: QdrantClientClass } = loadResult.data;
-        const qdrantClient = new QdrantClientClass({
-          url: qdrantConfig.url,
-          apiKey: qdrantConfig.apiKey
-        });
+        const qdrantClient = new QdrantRestClient(qdrantConfig.url, qdrantConfig.apiKey);
         await qdrantClient.getCollections();
         client = qdrantClient;
         config = qdrantConfig;
-        logger4.info("Qdrant connected", { url: core.sanitize.sanitizeUrl(qdrantConfig.url) });
+        logger4.info("Qdrant connected", {
+          url: core.sanitize.sanitizeUrl(qdrantConfig.url)
+        });
         return ok(void 0);
       } catch (error) {
-        logger4.error("Failed to connect to Qdrant", { error: error instanceof Error ? error.message : String(error) });
-        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", { params: { error: String(error) } }), error);
+        logger4.error("Failed to connect to Qdrant", {
+          error: core.sanitize.sanitizeSensitiveFields(error)
+        });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", {
+          params: { error: "Qdrant connection failed" }
+        }));
       }
     },
     async close() {
@@ -1736,24 +2046,44 @@ async function closeOwnedProvider() {
     return ok(void 0);
   try {
     const result = await pendingProvider.close();
-    if (!result.success)
-      return err({ ...result.error, ext: { ...result.error.ext, cleanupPending: true } });
+    if (!result.success) {
+      return err({
+        ...result.error,
+        ext: { ...result.error.ext, cleanupPending: true }
+      });
+    }
     pendingProvider = null;
     return result;
   } catch (cause) {
-    return err({ ...HaiVecdbError.CONNECTION_FAILED, message: vecdbM("vecdb_closeFailed", { params: { error: cause instanceof Error ? cause.message : String(cause) } }), cause, ext: { cleanupPending: true } });
+    return err({
+      ...HaiVecdbError.CONNECTION_FAILED,
+      message: vecdbM("vecdb_closeFailed", {
+        params: {
+          error: cause instanceof Error ? cause.message : String(cause)
+        }
+      }),
+      cause,
+      ext: { cleanupPending: true }
+    });
   }
 }
 async function failInitialization(result) {
   const cleanup = await closeOwnedProvider();
   if (result.success)
     return result;
-  if (!cleanup.success)
-    return err({ ...result.error, ext: { ...result.error.ext, cleanupPending: true, cleanupError: cleanup.error } });
+  if (!cleanup.success) {
+    return err({
+      ...result.error,
+      ext: { ...result.error.ext, cleanupPending: true, cleanupError: cleanup.error }
+    });
+  }
   const ext = { ...result.error.ext };
   delete ext.cleanupPending;
   delete ext.cleanupError;
-  return err({ ...result.error, ext: Object.keys(ext).length ? ext : void 0 });
+  return err({
+    ...result.error,
+    ext: Object.keys(ext).length ? ext : void 0
+  });
 }
 function createProvider(config) {
   switch (config.type) {
@@ -1812,7 +2142,9 @@ var vecdb = {
       const parseResult = VecdbConfigSchema.safeParse(config);
       if (!parseResult.success) {
         logger5.error("Vecdb config validation failed", { error: parseResult.error.message });
-        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_configError", { params: { error: parseResult.error.message } }), parseResult.error);
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_configError", {
+          params: { error: parseResult.error.message }
+        }), parseResult.error);
       }
       const parsed = parseResult.data;
       if (core.module.requiresSharedState(process.env) && (parsed.type === "lancedb" || parsed.type === "chroma" && !!parsed.path && !parsed.url))
@@ -1835,7 +2167,11 @@ var vecdb = {
         return ok(void 0);
       } catch (error) {
         logger5.error("Vecdb module initialization failed", { error });
-        return await failInitialization(err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_initFailed", { params: { error: error instanceof Error ? error.message : String(error) } }), error));
+        return await failInitialization(err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_initFailed", {
+          params: {
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }), error));
       }
     } finally {
       initInProgress = false;