@h-ai/vecdb 0.1.0-alpha9 → 1.0.0-beta.2

package/dist/index.js

@@ -1,5 +1,9 @@
 import { z } from 'zod';
-import { core, ok, err } from '@h-ai/core';
+import { core, err, ok } from '@h-ai/core';
+import process from 'process';
+import { spawn } from 'child_process';
+import { setTimeout as setTimeout$1 } from 'timers/promises';
+import { createRequire } from 'module';
 import { createHash } from 'crypto';
 
 // src/vecdb-config.ts
@@ -17,6 +21,11 @@ var en_US_default = {
   vecdb_connectionFailed: "Failed to connect to vector database: {error}",
   vecdb_collectionNotFound: "Collection not found: {name}",
   vecdb_collectionAlreadyExists: "Collection already exists: {name}",
+  vecdb_invalidCollectionSchema: "Collection has no valid persisted vector dimension or distance metric: {name}",
+  vecdb_atomicUpsertUnavailable: "LanceDB collection or driver lacks safe atomic merge primary-key support; no writes were performed. Rebuild the collection or use a supported driver",
+  vecdb_duplicateDocumentIds: "Vector document IDs must be unique within a batch; no writes were performed",
+  vecdb_jsonMetadataRequired: "LanceDB collection requires native JSON metadata; rebuild legacy string metadata collections before writing or filtering",
+  vecdb_invalidMetadataFilter: "LanceDB metadata filter must be a plain object of top-level string, finite number, boolean or null values; nested objects, arrays and undefined are unsupported",
   vecdb_dimensionMismatch: "Vector dimension mismatch: expected {expected}, actual {actual}",
   vecdb_insertFailed: "Failed to insert vectors: {error}",
   vecdb_deleteFailed: "Failed to delete vectors: {error}",
@@ -26,7 +35,43 @@ var en_US_default = {
   vecdb_serializationFailed: "Serialization/deserialization failed: {error}",
   vecdb_invalidDimension: "Invalid vector dimension: {dimension}, must be a positive integer",
   vecdb_configPathRequired: "Database storage path is required",
-  vecdb_configDatabaseRequired: "Database name is required"
+  vecdb_configDatabaseRequired: "Database name is required",
+  vecdb_sharedBackendRequired: "Production mode requires a shared backend; local files and memory backends are for development or explicit end-to-end tests.",
+  vecdb_chromaEndpointInvalid: "Chroma requires an HTTP(S) root endpoint without credentials, path prefix, query or fragment",
+  vecdb_chromaTokenInvalid: "Chroma Bearer token must contain only printable ASCII characters without whitespace"
+};
+
+// messages/ja-JP.json
+var ja_JP_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  vecdb_notInitialized: "\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u304C\u521D\u671F\u5316\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002\u5148\u306Bvecdb.init()\u3092\u547C\u3073\u51FA\u3057\u3066\u304F\u3060\u3055\u3044",
+  vecdb_initFailed: "\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u306E\u521D\u671F\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_closeFailed: "\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u306E\u7D42\u4E86\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_configError: "\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u8A2D\u5B9A\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_initInProgress: "\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u306E\u521D\u671F\u5316\u306F\u65E2\u306B\u5B9F\u884C\u4E2D\u3067\u3059",
+  vecdb_unsupportedType: "\u672A\u5BFE\u5FDC\u306E\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u306E\u7A2E\u985E\u3067\u3059: {type}",
+  vecdb_driverNotFound: "\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u306E\u30C9\u30E9\u30A4\u30D0\u30FC\u304C\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3055\u308C\u3066\u3044\u307E\u305B\u3093: {driver}\u3002pnpm add {driver}\u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044",
+  vecdb_connectionFailed: "\u30D9\u30AF\u30C8\u30EB\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u3078\u306E\u63A5\u7D9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_collectionNotFound: "\u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: {name}",
+  vecdb_collectionAlreadyExists: "\u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u306F\u65E2\u306B\u5B58\u5728\u3057\u307E\u3059: {name}",
+  vecdb_invalidCollectionSchema: "\u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u306B\u6709\u52B9\u306A\u6C38\u7D9A\u5316\u6E08\u307F\u306E\u30D9\u30AF\u30C8\u30EB\u6B21\u5143\u307E\u305F\u306F\u8DDD\u96E2\u30E1\u30C8\u30EA\u30C3\u30AF\u304C\u3042\u308A\u307E\u305B\u3093\uFF1A{name}",
+  vecdb_atomicUpsertUnavailable: "LanceDB \u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u307E\u305F\u306F\u30C9\u30E9\u30A4\u30D0\u30FC\u306B\u5B89\u5168\u306A\u4E3B\u30AD\u30FC\u306B\u3088\u308B\u30A2\u30C8\u30DF\u30C3\u30AF\u306A merge \u6A5F\u80FD\u304C\u3042\u308A\u307E\u305B\u3093\u3002\u66F8\u304D\u8FBC\u307F\u306F\u884C\u3063\u3066\u3044\u307E\u305B\u3093\u3002\u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u3092\u518D\u4F5C\u6210\u3059\u308B\u304B\u3001\u5BFE\u5FDC\u30C9\u30E9\u30A4\u30D0\u30FC\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044",
+  vecdb_duplicateDocumentIds: "\u540C\u4E00\u30D0\u30C3\u30C1\u306E\u30D9\u30AF\u30C8\u30EB\u6587\u66F8 ID \u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002\u66F8\u304D\u8FBC\u307F\u306F\u884C\u3063\u3066\u3044\u307E\u305B\u3093",
+  vecdb_jsonMetadataRequired: "LanceDB \u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u306B\u306F\u30CD\u30A4\u30C6\u30A3\u30D6 JSON \u30E1\u30BF\u30C7\u30FC\u30BF\u304C\u5FC5\u8981\u3067\u3059\u3002\u65E7\u5F62\u5F0F\u306E\u6587\u5B57\u5217\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u4F7F\u7528\u3059\u308B\u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u306F\u3001\u66F8\u304D\u8FBC\u307F\u3084\u30D5\u30A3\u30EB\u30BF\u30FC\u51E6\u7406\u306E\u524D\u306B\u518D\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044",
+  vecdb_invalidMetadataFilter: "LanceDB \u30E1\u30BF\u30C7\u30FC\u30BF\u30D5\u30A3\u30EB\u30BF\u30FC\u306F\u901A\u5E38\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3068\u3057\u3001\u6700\u4E0A\u4F4D\u306E\u5024\u306B\u306F\u6587\u5B57\u5217\u3001\u6709\u9650\u6570\u3001\u771F\u507D\u5024\u3001null \u306E\u307F\u6307\u5B9A\u3067\u304D\u307E\u3059\u3002\u5165\u308C\u5B50\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3001\u914D\u5217\u3001undefined \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
+  vecdb_dimensionMismatch: "\u30D9\u30AF\u30C8\u30EB\u306E\u6B21\u5143\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093: \u671F\u5F85\u5024{expected}\u3001\u5B9F\u969B\u306E\u5024{actual}",
+  vecdb_insertFailed: "\u30D9\u30AF\u30C8\u30EB\u306E\u633F\u5165\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_deleteFailed: "\u30D9\u30AF\u30C8\u30EB\u306E\u524A\u9664\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_updateFailed: "\u30D9\u30AF\u30C8\u30EB\u306E\u66F4\u65B0\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_queryFailed: "\u30D9\u30AF\u30C8\u30EB\u306E\u691C\u7D22\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_indexBuildFailed: "\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u306E\u69CB\u7BC9\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_serializationFailed: "\u30B7\u30EA\u30A2\u30E9\u30A4\u30BA\u307E\u305F\u306F\u30C7\u30B7\u30EA\u30A2\u30E9\u30A4\u30BA\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  vecdb_invalidDimension: "\u30D9\u30AF\u30C8\u30EB\u306E\u6B21\u5143\u304C\u7121\u52B9\u3067\u3059: {dimension}\u3002\u6B63\u306E\u6574\u6570\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
+  vecdb_configPathRequired: "\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u306E\u4FDD\u5B58\u30D1\u30B9\u306F\u5FC5\u9808\u3067\u3059",
+  vecdb_configDatabaseRequired: "\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u540D\u306F\u5FC5\u9808\u3067\u3059",
+  vecdb_sharedBackendRequired: "\u672C\u756A\u74B0\u5883\u306B\u306F\u5171\u6709\u30D0\u30C3\u30AF\u30A8\u30F3\u30C9\u304C\u5FC5\u8981\u3067\u3059\u3002\u30ED\u30FC\u30AB\u30EB\u30D5\u30A1\u30A4\u30EB\u3068\u30E1\u30E2\u30EA\u30FC\u30D0\u30C3\u30AF\u30A8\u30F3\u30C9\u306F\u958B\u767A\u74B0\u5883\u307E\u305F\u306F\u660E\u793A\u7684\u306A E2E \u30C6\u30B9\u30C8\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059\u3002",
+  vecdb_chromaEndpointInvalid: "Chroma \u306B\u306F HTTP(S) \u306E\u30EB\u30FC\u30C8\u30A8\u30F3\u30C9\u30DD\u30A4\u30F3\u30C8\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u8A8D\u8A3C\u60C5\u5831\u3001\u30D1\u30B9\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u3001\u30AF\u30A8\u30EA\u3001\u30D5\u30E9\u30B0\u30E1\u30F3\u30C8\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
+  vecdb_chromaTokenInvalid: "Chroma Bearer \u30C8\u30FC\u30AF\u30F3\u306B\u306F\u7A7A\u767D\u3092\u542B\u307E\u306A\u3044\u8868\u793A\u53EF\u80FD\u306A ASCII \u6587\u5B57\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059"
 };
 
 // messages/zh-CN.json
@@ -42,6 +87,11 @@ var zh_CN_default = {
   vecdb_connectionFailed: "\u8FDE\u63A5\u5411\u91CF\u6570\u636E\u5E93\u5931\u8D25: {error}",
   vecdb_collectionNotFound: "\u96C6\u5408\u4E0D\u5B58\u5728: {name}",
   vecdb_collectionAlreadyExists: "\u96C6\u5408\u5DF2\u5B58\u5728: {name}",
+  vecdb_invalidCollectionSchema: "\u96C6\u5408\u7F3A\u5C11\u6709\u6548\u7684\u6301\u4E45\u5316\u5411\u91CF\u7EF4\u5EA6\u6216\u8DDD\u79BB\u5EA6\u91CF\u5B9A\u4E49: {name}",
+  vecdb_atomicUpsertUnavailable: "LanceDB \u96C6\u5408\u6216\u9A71\u52A8\u7F3A\u5C11\u5B89\u5168\u7684\u539F\u5B50 merge \u4E3B\u952E\u80FD\u529B\uFF0C\u672A\u6267\u884C\u5199\u5165\uFF0C\u8BF7\u91CD\u5EFA\u96C6\u5408\u6216\u4F7F\u7528\u53D7\u652F\u6301\u7684\u9A71\u52A8",
+  vecdb_duplicateDocumentIds: "\u540C\u4E00\u6279\u5411\u91CF\u6587\u6863\u7684 ID \u4E0D\u5F97\u91CD\u590D\uFF0C\u672A\u6267\u884C\u5199\u5165",
+  vecdb_jsonMetadataRequired: "LanceDB \u96C6\u5408\u987B\u4F7F\u7528\u539F\u751F JSON \u5143\u6570\u636E\uFF0C\u65E7\u5B57\u7B26\u4E32\u5143\u6570\u636E\u96C6\u5408\u9700\u91CD\u5EFA\u540E\u624D\u80FD\u5199\u5165\u6216\u8FC7\u6EE4",
+  vecdb_invalidMetadataFilter: "LanceDB \u5143\u6570\u636E\u8FC7\u6EE4\u987B\u4E3A\u666E\u901A\u5BF9\u8C61\uFF0C\u503C\u4EC5\u652F\u6301\u9876\u5C42\u5B57\u7B26\u4E32\u3001\u6709\u9650\u6570\u503C\u3001\u5E03\u5C14\u6216 null\uFF1B\u4E0D\u652F\u6301\u5D4C\u5957\u5BF9\u8C61\u3001\u6570\u7EC4\u548C undefined",
   vecdb_dimensionMismatch: "\u5411\u91CF\u7EF4\u5EA6\u4E0D\u5339\u914D: \u671F\u671B {expected}\uFF0C\u5B9E\u9645 {actual}",
   vecdb_insertFailed: "\u63D2\u5165\u5411\u91CF\u5931\u8D25: {error}",
   vecdb_deleteFailed: "\u5220\u9664\u5411\u91CF\u5931\u8D25: {error}",
@@ -51,24 +101,37 @@ var zh_CN_default = {
   vecdb_serializationFailed: "\u5E8F\u5217\u5316/\u53CD\u5E8F\u5217\u5316\u5931\u8D25: {error}",
   vecdb_invalidDimension: "\u65E0\u6548\u7684\u5411\u91CF\u7EF4\u5EA6: {dimension}\uFF0C\u5FC5\u987B\u4E3A\u6B63\u6574\u6570",
   vecdb_configPathRequired: "\u6570\u636E\u5E93\u5B58\u50A8\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A",
-  vecdb_configDatabaseRequired: "\u6570\u636E\u5E93\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"
+  vecdb_configDatabaseRequired: "\u6570\u636E\u5E93\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A",
+  vecdb_sharedBackendRequired: "\u751F\u4EA7\u6A21\u5F0F\u9700\u8981\u8DE8\u8282\u70B9\u5171\u4EAB\u540E\u7AEF\uFF1B\u672C\u673A\u6587\u4EF6\u6216\u5185\u5B58\u540E\u7AEF\u4EC5\u7528\u4E8E\u5F00\u53D1\u548C\u663E\u5F0F\u7AEF\u5230\u7AEF\u6D4B\u8BD5\u3002",
+  vecdb_chromaEndpointInvalid: "Chroma \u4EC5\u652F\u6301 HTTP(S) \u6839\u7AEF\u70B9\uFF0C\u4E0D\u5F97\u5305\u542B\u51ED\u636E\u3001\u8DEF\u5F84\u524D\u7F00\u3001query \u6216 fragment",
+  vecdb_chromaTokenInvalid: "Chroma Bearer token \u4EC5\u652F\u6301\u65E0\u7A7A\u767D\u7684\u53EF\u6253\u5370 ASCII \u5B57\u7B26"
 };
 
 // src/vecdb-i18n.ts
 var vecdbM = core.i18n.createMessageGetter({
   "zh-CN": zh_CN_default,
-  "en-US": en_US_default
+  "en-US": en_US_default,
+  "ja-JP": ja_JP_default
 });
 
 // src/vecdb-config.ts
-var VecdbTypeSchema = z.enum(["lancedb", "pgvector", "qdrant"]);
 var DistanceMetricSchema = z.enum(["cosine", "euclidean", "dot"]).default("cosine");
+var VecdbOperationLogConfigSchema = z.object({
+  read: z.boolean().default(false),
+  write: z.boolean().default(false),
+  maxLength: z.number().int().min(0).default(1e3),
+  level: z.enum(["info", "debug", "trace"]).default("debug")
+});
+var OperationLogConfigFieldSchema = {
+  operationLog: VecdbOperationLogConfigSchema.optional()
+};
 var LancedbConfigSchema = z.object({
   type: z.literal("lancedb"),
-  /** 数据库存储路径（本地目录） */
+  /** 持久化本地目录；独立节点的同名路径不会自动共享，分布式部署优先使用服务端后端。 */
   path: z.string().min(1, vecdbM("vecdb_configPathRequired")),
-  /** 距离度量（默认 cosine） */
-  metric: DistanceMetricSchema.optional()
+  /** 新建集合的默认距离度量；已有集合使用 Arrow schema 中的持久定义。 */
+  metric: DistanceMetricSchema.optional(),
+  ...OperationLogConfigFieldSchema
 });
 var PgvectorIndexTypeSchema = z.enum(["ivfflat", "hnsw"]).default("hnsw");
 var PgvectorConfigSchema = z.object({
@@ -90,7 +153,8 @@ var PgvectorConfigSchema = z.object({
   /** 距离度量（默认 cosine） */
   metric: DistanceMetricSchema.optional(),
   /** 表名前缀（默认 'vec_'） */
-  tablePrefix: z.string().default("vec_")
+  tablePrefix: z.string().default("vec_"),
+  ...OperationLogConfigFieldSchema
 });
 var QdrantConfigSchema = z.object({
   type: z.literal("qdrant"),
@@ -99,12 +163,41 @@ var QdrantConfigSchema = z.object({
   /** API Key（可选） */
   apiKey: z.string().optional(),
   /** 距离度量（默认 cosine） */
-  metric: DistanceMetricSchema.optional()
+  metric: DistanceMetricSchema.optional(),
+  ...OperationLogConfigFieldSchema
+});
+var ChromaConfigSchema = z.object({
+  type: z.literal("chroma"),
+  /** 本地持久化路径（嵌入式模式：提供且无 url 时自动拉起本地服务） */
+  path: z.string().optional(),
+  /** Chroma HTTP(S) 根端点；不可包含凭据、路径前缀、query 或 fragment；提供时优先于 host/port。 */
+  url: z.string().url().refine((value) => {
+    try {
+      const endpoint = new URL(value);
+      return ["http:", "https:"].includes(endpoint.protocol) && !endpoint.username && !endpoint.password && endpoint.pathname === "/" && !endpoint.search && !endpoint.hash;
+    } catch {
+      return false;
+    }
+  }, { 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(),
+  /** 拉起本地服务的可执行命令（默认 'chroma'，可指定绝对路径） */
+  serverCommand: z.string().default("chroma"),
+  /** 拉起本地服务的就绪等待超时（毫秒，默认 30000） */
+  startupTimeout: z.number().int().positive().default(3e4),
+  /** 距离度量（默认 cosine） */
+  metric: DistanceMetricSchema.optional(),
+  ...OperationLogConfigFieldSchema
 });
 var VecdbConfigSchema = z.discriminatedUnion("type", [
   LancedbConfigSchema,
   PgvectorConfigSchema,
-  QdrantConfigSchema
+  QdrantConfigSchema,
+  ChromaConfigSchema
 ]);
 var VecdbErrorInfo = {
   CONNECTION_FAILED: "001:500",
@@ -123,6 +216,37 @@ var VecdbErrorInfo = {
   SERIALIZATION_FAILED: "014:500"
 };
 var HaiVecdbError = core.error.buildHaiErrorsDef("vecdb", VecdbErrorInfo);
+function stringifyOperationPayload(payload, maxLength) {
+  if (maxLength <= 0) {
+    return "";
+  }
+  try {
+    const text = JSON.stringify(payload, (_key, value) => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      if (typeof value === "function") {
+        return "[Function]";
+      }
+      return value;
+    });
+    return text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
+  } catch {
+    const text = String(payload);
+    return text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
+  }
+}
+function logVecdbOperation(ctx, category, operation, payload) {
+  const config = ctx.operationLog?.();
+  if (!config?.[category]) {
+    return;
+  }
+  ctx.logger[config.level]("VecDB operation executed", {
+    category,
+    operation,
+    payload: stringifyOperationPayload(payload, config.maxLength)
+  });
+}
 function errorMsgFromCode(def, errorStr) {
   switch (def) {
     case HaiVecdbError.DELETE_FAILED:
@@ -155,6 +279,7 @@ function createBaseCollectionOps(ctx, driver) {
           vecdbM("vecdb_invalidDimension", { params: { dimension: String(options.dimension) } })
         );
       }
+      logVecdbOperation(ctx, "write", "collection.create", { name, options });
       return wrapOp(
         ctx,
         () => driver.create(name, options),
@@ -163,250 +288,715 @@ function createBaseCollectionOps(ctx, driver) {
         { name }
       );
     },
-    drop: (name) => wrapOp(
-      ctx,
-      () => driver.drop(name),
-      HaiVecdbError.DELETE_FAILED,
-      "Failed to drop collection",
-      { name }
-    ),
-    exists: (name) => wrapOp(
-      ctx,
-      () => driver.exists(name),
-      HaiVecdbError.QUERY_FAILED,
-      "Failed to check collection",
-      { name }
-    ),
-    info: (name) => wrapOp(
-      ctx,
-      () => driver.info(name),
-      HaiVecdbError.QUERY_FAILED,
-      "Failed to get collection info",
-      { name }
-    ),
-    list: () => wrapOp(
-      ctx,
-      () => driver.list(),
-      HaiVecdbError.QUERY_FAILED,
-      "Failed to list collections"
-    )
+    drop: (name) => {
+      logVecdbOperation(ctx, "write", "collection.drop", { name });
+      return wrapOp(
+        ctx,
+        () => driver.drop(name),
+        HaiVecdbError.DELETE_FAILED,
+        "Failed to drop collection",
+        { name }
+      );
+    },
+    exists: (name) => {
+      logVecdbOperation(ctx, "read", "collection.exists", { name });
+      return wrapOp(
+        ctx,
+        () => driver.exists(name),
+        HaiVecdbError.QUERY_FAILED,
+        "Failed to check collection",
+        { name }
+      );
+    },
+    info: (name) => {
+      logVecdbOperation(ctx, "read", "collection.info", { name });
+      return wrapOp(
+        ctx,
+        () => driver.info(name),
+        HaiVecdbError.QUERY_FAILED,
+        "Failed to get collection info",
+        { name }
+      );
+    },
+    list: () => {
+      logVecdbOperation(ctx, "read", "collection.list", {});
+      return wrapOp(
+        ctx,
+        () => driver.list(),
+        HaiVecdbError.QUERY_FAILED,
+        "Failed to list collections"
+      );
+    }
   };
 }
 function createBaseVectorOps(ctx, driver) {
   return {
-    insert: (collection, documents) => wrapOp(
-      ctx,
-      () => driver.insert(collection, documents),
-      HaiVecdbError.INSERT_FAILED,
-      "Failed to insert vectors",
-      { collection }
-    ),
-    upsert: (collection, documents) => wrapOp(
-      ctx,
-      () => driver.upsert(collection, documents),
-      HaiVecdbError.UPDATE_FAILED,
-      "Failed to upsert vectors",
-      { collection }
-    ),
-    delete: (collection, ids) => wrapOp(
-      ctx,
-      () => driver.delete(collection, ids),
-      HaiVecdbError.DELETE_FAILED,
-      "Failed to delete vectors",
-      { collection }
-    ),
-    search: (collection, vector, options) => wrapOp(
-      ctx,
-      () => driver.search(collection, vector, options),
-      HaiVecdbError.QUERY_FAILED,
-      "Failed to search vectors",
-      { collection }
-    ),
-    count: (collection) => wrapOp(
-      ctx,
-      () => driver.count(collection),
-      HaiVecdbError.QUERY_FAILED,
-      "Failed to count vectors",
-      { collection }
-    )
+    insert: (collection, documents) => {
+      logVecdbOperation(ctx, "write", "vector.insert", { collection, count: documents.length, documents });
+      return wrapOp(
+        ctx,
+        () => documents.length === 0 ? Promise.resolve(ok(void 0)) : driver.insert(collection, documents),
+        HaiVecdbError.INSERT_FAILED,
+        "Failed to insert vectors",
+        { collection }
+      );
+    },
+    upsert: (collection, documents) => {
+      logVecdbOperation(ctx, "write", "vector.upsert", { collection, count: documents.length, documents });
+      return wrapOp(
+        ctx,
+        () => documents.length === 0 ? Promise.resolve(ok(void 0)) : driver.upsert(collection, documents),
+        HaiVecdbError.UPDATE_FAILED,
+        "Failed to upsert vectors",
+        { collection }
+      );
+    },
+    delete: (collection, ids) => {
+      logVecdbOperation(ctx, "write", "vector.delete", { collection, count: ids.length, ids });
+      return wrapOp(
+        ctx,
+        () => ids.length === 0 ? Promise.resolve(ok(void 0)) : driver.delete(collection, ids),
+        HaiVecdbError.DELETE_FAILED,
+        "Failed to delete vectors",
+        { collection }
+      );
+    },
+    search: (collection, vector, options) => {
+      logVecdbOperation(ctx, "read", "vector.search", { collection, vector, options });
+      return wrapOp(
+        ctx,
+        () => driver.search(collection, vector, options),
+        HaiVecdbError.QUERY_FAILED,
+        "Failed to search vectors",
+        { collection }
+      );
+    },
+    count: (collection) => {
+      logVecdbOperation(ctx, "read", "vector.count", { collection });
+      return wrapOp(
+        ctx,
+        () => driver.count(collection),
+        HaiVecdbError.QUERY_FAILED,
+        "Failed to count vectors",
+        { collection }
+      );
+    }
   };
 }
 
-// src/providers/vecdb-provider-lancedb.ts
-var logger = core.logger.child({ module: "vecdb", scope: "lancedb" });
-function escapeLanceFilterValue(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "\\%").replace(/_/g, "\\_");
+// src/providers/vecdb-provider-chroma.ts
+var logger = core.logger.child({ module: "vecdb", scope: "chroma" });
+var DIMENSION_METADATA_KEY = "hai_dimension";
+var SPACE_METADATA_KEY = "hnsw:space";
+var HEARTBEAT_POLL_INTERVAL = 300;
+function isChromaModule(value) {
+  return typeof value === "object" && value !== null && typeof value.ChromaClient === "function";
 }
-function createLancedbProvider() {
-  let connection = null;
+var NOOP_EMBEDDING_FUNCTION = {
+  name: "hai-noop",
+  async generate() {
+    throw new Error("Chroma embedding function should not be called: vectors are provided explicitly");
+  }
+};
+function toChromaSpace(metric) {
+  if (metric === "euclidean")
+    return "l2";
+  if (metric === "dot")
+    return "ip";
+  return "cosine";
+}
+function fromChromaSpace(space) {
+  if (space === "l2")
+    return "euclidean";
+  if (space === "ip")
+    return "dot";
+  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));
+}
+function buildWhere(filter) {
+  if (!filter)
+    return void 0;
+  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 })) };
+  return where;
+}
+function createChromaProvider() {
+  let client = null;
   let config = null;
-  const collectionMetas = /* @__PURE__ */ new Map();
-  async function loadLancedb() {
+  let serverProcess = null;
+  let spawnFailed = false;
+  let closing = null;
+  function isMissingModuleError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("chromadb");
+  }
+  async function loadChromaModule() {
     try {
-      const mod = await import('@lancedb/lancedb');
+      const mod = await import('chromadb');
+      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 ok(mod);
     } catch (error) {
-      logger.error("Failed to load @lancedb/lancedb", { error });
-      return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "@lancedb/lancedb" } }), 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);
+      }
+      throw error;
     }
   }
-  async function openTable(name) {
-    if (!connection)
-      return null;
-    try {
-      const tableNames = await connection.tableNames();
-      if (tableNames.includes(name)) {
-        return await connection.openTable(name);
+  async function startEmbeddedServer(chromaConfig) {
+    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" });
+    proc.on("error", (error) => {
+      spawnFailed = proc.pid === void 0;
+      logger.error("Chroma server process error", { error: error.message });
+    });
+    serverProcess = proc;
+    await new Promise((resolve, reject) => {
+      proc.once("spawn", resolve);
+      proc.once("error", reject);
+    });
+  }
+  async function stopEmbeddedServer() {
+    const owned = serverProcess;
+    if (!owned)
+      return;
+    const hasExited = () => owned.exitCode !== null || owned.signalCode !== null || spawnFailed && owned.pid === void 0;
+    if (!hasExited()) {
+      const child = owned;
+      await new Promise((resolve, reject) => {
+        let timer;
+        let settled = false;
+        function cleanup() {
+          clearTimeout(timer);
+          child.removeListener("exit", exited);
+          child.removeListener("error", failed);
+        }
+        function exited() {
+          if (settled)
+            return;
+          settled = true;
+          cleanup();
+          resolve();
+        }
+        function failed(cause) {
+          if (settled)
+            return;
+          if (hasExited()) {
+            exited();
+            return;
+          }
+          settled = true;
+          cleanup();
+          reject(cause);
+        }
+        function signal(name) {
+          try {
+            if (!child.kill(name))
+              failed(new Error("Chroma child termination signal was rejected"));
+          } catch (cause) {
+            failed(cause instanceof Error ? cause : new Error(String(cause)));
+          }
+        }
+        child.once("exit", exited);
+        child.once("error", failed);
+        timer = setTimeout(() => {
+          timer = setTimeout(() => failed(new Error("Chroma child exit was not confirmed")), 1500);
+          signal("SIGKILL");
+        }, 1500);
+        if (hasExited())
+          exited();
+        else signal("SIGTERM");
+      });
+    }
+    if (serverProcess === owned)
+      serverProcess = null;
+  }
+  async function closeResources() {
+    if (!closing) {
+      client = null;
+      config = null;
+      closing = (async () => {
+        try {
+          await stopEmbeddedServer();
+          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 } });
+        }
+      })().finally(() => {
+        closing = null;
+      });
+    }
+    return await closing;
+  }
+  async function waitForHeartbeat(chromaClient, timeout) {
+    const deadline = Date.now() + timeout;
+    let lastError;
+    while (Date.now() < deadline) {
+      try {
+        await chromaClient.heartbeat();
+        return;
+      } catch (error) {
+        lastError = error;
+        await setTimeout$1(HEARTBEAT_POLL_INTERVAL);
       }
-      return null;
-    } catch {
-      return null;
     }
+    throw new Error(`Chroma heartbeat timed out after ${timeout}ms: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+  }
+  async function getCollection(name) {
+    return client.getCollection({ name, embeddingFunction: NOOP_EMBEDDING_FUNCTION });
+  }
+  function readDimension(collection) {
+    const value = collection.metadata?.[DIMENSION_METADATA_KEY];
+    return typeof value === "number" ? value : 0;
   }
-  const ctx = { isConnected: () => connection !== null, logger };
+  function validateDimension(expected, actual) {
+    if (expected === 0 || expected === actual)
+      return null;
+    return err(
+      HaiVecdbError.DIMENSION_MISMATCH,
+      vecdbM("vecdb_dimensionMismatch", { params: { expected: String(expected), actual: String(actual) } })
+    );
+  }
+  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 tableNames = await connection.tableNames();
-      if (tableNames.includes(name)) {
+      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 } }));
-      }
-      const dimension = options.dimension;
       const metric = options.metric ?? config?.metric ?? "cosine";
-      const initRecord = {
-        id: "__init__",
-        vector: Array.from({ length: dimension }, () => 0),
-        content: "",
-        metadata: "{}"
-      };
-      const table = await connection.createTable(name, [initRecord]);
-      await table.delete('id = "__init__"');
-      collectionMetas.set(name, { dimension, metric });
-      logger.info("Collection created", { name, dimension, metric });
+      await client.getOrCreateCollection({
+        name,
+        metadata: { [SPACE_METADATA_KEY]: toChromaSpace(metric), [DIMENSION_METADATA_KEY]: options.dimension },
+        embeddingFunction: NOOP_EMBEDDING_FUNCTION
+      });
+      logger.info("Collection created", { name, dimension: options.dimension, metric });
       return ok(void 0);
     },
     async drop(name) {
       logger.debug("Dropping collection", { name });
-      const tableNames = await connection.tableNames();
-      if (!tableNames.includes(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 } }));
-      }
-      await connection.dropTable(name);
-      collectionMetas.delete(name);
+      await client.deleteCollection({ name });
       logger.info("Collection dropped", { name });
       return ok(void 0);
     },
     async exists(name) {
       logger.debug("Checking collection exists", { name });
-      const tableNames = await connection.tableNames();
-      return ok(tableNames.includes(name));
+      const existing = await client.listCollections();
+      return ok(existing.some((item) => item.name === name));
     },
     async info(name) {
       logger.debug("Getting collection info", { name });
-      const table = await openTable(name);
-      if (!table) {
+      const existing = await client.listCollections();
+      if (!existing.some((item) => item.name === name))
         return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
-      }
-      const count = await table.countRows();
-      const meta = collectionMetas.get(name);
+      const collection = await getCollection(name);
+      const count = await collection.count();
       return ok({
         name,
-        dimension: meta?.dimension ?? 0,
-        metric: meta?.metric ?? config?.metric ?? "cosine",
+        dimension: readDimension(collection),
+        metric: fromChromaSpace(collection.metadata?.[SPACE_METADATA_KEY]),
         count
       });
     },
     async list() {
       logger.debug("Listing collections");
-      const tableNames = await connection.tableNames();
-      return ok(tableNames);
+      const existing = await client.listCollections();
+      return ok(existing.map((item) => item.name));
     }
   };
+  function toWriteParams(documents) {
+    return {
+      ids: documents.map((doc) => doc.id),
+      embeddings: documents.map((doc) => doc.vector),
+      documents: documents.map((doc) => doc.content ?? ""),
+      // 统一 API 的 metadata 更宽；SDK 在 add/upsert 中先执行 validateMetadata，再发送请求。
+      // 使用上游 Metadata 类型跨越此边界，避免复制其标量、数组及稀疏向量规则；原生拒绝会由 base 转为 HaiResult。
+      metadatas: documents.map((doc) => ({ ...doc.metadata, _content: doc.content ?? "" }))
+    };
+  }
   const vectorDriver = {
     async insert(collection, documents) {
       logger.debug("Inserting vectors", { collection, count: documents.length });
-      const table = await openTable(collection);
-      if (!table) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      const target = await getCollection(collection);
+      const expected = readDimension(target);
+      for (const doc of documents) {
+        const validation = validateDimension(expected, doc.vector.length);
+        if (validation)
+          return validation;
       }
-      const records = documents.map((doc) => ({
-        id: doc.id,
-        vector: doc.vector,
-        content: doc.content ?? "",
-        metadata: JSON.stringify(doc.metadata ?? {})
-      }));
-      await table.add(records);
+      await target.add(toWriteParams(documents));
       logger.info("Vectors inserted", { collection, count: documents.length });
       return ok(void 0);
     },
     async upsert(collection, documents) {
       logger.debug("Upserting vectors", { collection, count: documents.length });
-      const table = await openTable(collection);
-      if (!table) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      const target = await getCollection(collection);
+      const expected = readDimension(target);
+      for (const doc of documents) {
+        const validation = validateDimension(expected, doc.vector.length);
+        if (validation)
+          return validation;
       }
-      const records = documents.map((doc) => ({
-        id: doc.id,
-        vector: doc.vector,
-        content: doc.content ?? "",
-        metadata: JSON.stringify(doc.metadata ?? {})
-      }));
-      const ids = documents.map((d) => `"${escapeLanceFilterValue(d.id)}"`).join(", ");
-      await table.delete(`id IN (${ids})`);
-      await table.add(records);
+      await target.upsert(toWriteParams(documents));
       logger.info("Vectors upserted", { collection, count: documents.length });
       return ok(void 0);
     },
     async delete(collection, ids) {
       logger.debug("Deleting vectors", { collection, count: ids.length });
-      const table = await openTable(collection);
-      if (!table) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
-      }
-      const idList = ids.map((id) => `"${escapeLanceFilterValue(id)}"`).join(", ");
-      await table.delete(`id IN (${idList})`);
+      const target = await getCollection(collection);
+      await target.delete({ ids });
       logger.info("Vectors deleted", { collection, count: ids.length });
       return ok(void 0);
     },
     async search(collection, vector, options) {
-      logger.debug("Searching vectors", { collection, topK: options?.topK, hasFilter: !!options?.filter });
-      const table = await openTable(collection);
-      if (!table) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
-      }
       const topK = options?.topK ?? 10;
       const minScore = options?.minScore ?? 0;
-      let query = table.search(vector).limit(topK);
-      if (options?.filter) {
-        const filterParts = [];
-        for (const [key, value] of Object.entries(options.filter)) {
-          filterParts.push(`metadata LIKE '%"${escapeLanceFilterValue(key)}":"${escapeLanceFilterValue(String(value))}"%'`);
-        }
-        if (filterParts.length > 0) {
-          query = query.where(filterParts.join(" AND "));
-        }
-      }
-      const results = await query.toArray();
-      const searchResults = results.map((row) => {
-        const distance = row._distance ?? 0;
-        const score = 1 / (1 + distance);
-        return {
-          id: row.id,
+      logger.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
+      const target = await getCollection(collection);
+      const expected = readDimension(target);
+      const validation = validateDimension(expected, vector.length);
+      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 ids = response.ids[0] ?? [];
+      const distances = response.distances?.[0] ?? [];
+      const metadatas = response.metadatas?.[0] ?? [];
+      const results = [];
+      for (let i = 0; i < ids.length; i++) {
+        const score = distanceToScore(distances[i] ?? 0, metric);
+        if (score < minScore)
+          continue;
+        const metadata = metadatas[i] ?? {};
+        const { _content, ...rest } = metadata;
+        results.push({
+          id: ids[i],
           score,
-          content: row.content || void 0,
-          metadata: row.metadata ? JSON.parse(row.metadata) : void 0
-        };
-      }).filter((r) => r.score >= minScore);
-      return ok(searchResults);
+          content: typeof _content === "string" && _content.length > 0 ? _content : void 0,
+          metadata: Object.keys(rest).length > 0 ? rest : void 0
+        });
+      }
+      return ok(results);
     },
     async count(collection) {
       logger.debug("Counting vectors", { collection });
-      const table = await openTable(collection);
-      if (!table) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      const target = await getCollection(collection);
+      return ok(await target.count());
+    }
+  };
+  return {
+    name: "chroma",
+    async connect(cfg) {
+      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)
+          return cleaned;
+      }
+      const chromaConfig = cfg;
+      const embedded = !!chromaConfig.path && !chromaConfig.url;
+      const loadResult = await loadChromaModule();
+      if (!loadResult.success)
+        return loadResult;
+      const startupAbort = new AbortController();
+      const startupTimeout = embedded ? chromaConfig.startupTimeout : 5e3;
+      const startupTimer = setTimeout(() => startupAbort.abort(), startupTimeout);
+      try {
+        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 };
+        if (chromaConfig.apiKey)
+          clientParams.headers = { Authorization: `Bearer ${chromaConfig.apiKey}` };
+        clientParams.fetchOptions = { signal: startupAbort.signal };
+        const chromaClient = new loadResult.data.ChromaClient(clientParams);
+        await waitForHeartbeat(chromaClient, startupTimeout);
+        await chromaClient.countCollections();
+        startupAbort.signal.throwIfAborted();
+        if (embedded && (spawnFailed || !serverProcess || serverProcess.exitCode !== null || serverProcess.signalCode !== null))
+          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 });
+        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;
+      } finally {
+        clearTimeout(startupTimer);
+      }
+    },
+    async close() {
+      return await closeResources();
+    },
+    isConnected() {
+      return client !== null;
+    },
+    collection: createBaseCollectionOps(ctx, collectionDriver),
+    vector: createBaseVectorOps(ctx, vectorDriver)
+  };
+}
+var require2 = createRequire(import.meta.url);
+var logger2 = core.logger.child({ module: "vecdb", scope: "lancedb" });
+var COLLECTION_METRIC_KEY = "hai.vecdb.metric";
+var PRIMARY_KEY_FLAG = "lance-schema:unenforced-primary-key";
+var PRIMARY_KEY_POSITION = "lance-schema:unenforced-primary-key:position";
+function escapeLanceSqlValue(value) {
+  return value.replace(/'/g, "''");
+}
+function buildMetadataPredicate(filter) {
+  if (typeof filter !== "object" || filter === null || Array.isArray(filter) || ![Object.prototype, null].includes(Object.getPrototypeOf(filter)) || Reflect.ownKeys(filter).some((key) => typeof key !== "string")) {
+    return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidMetadataFilter"));
+  }
+  const predicates = [];
+  for (const [key, value] of Object.entries(filter)) {
+    if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value))) {
+      return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidMetadataFilter"));
+    }
+    const extracted = `json_extract(json_get(metadata, '${escapeLanceSqlValue(key)}'), '$')`;
+    predicates.push(typeof value === "number" ? `TRY_CAST(${extracted} AS DOUBLE) = CAST(${value} AS DOUBLE)` : `${extracted} = '${escapeLanceSqlValue(JSON.stringify(value))}'`);
+  }
+  return ok(predicates.join(" AND "));
+}
+function createLancedbProvider() {
+  let connection = null;
+  let config = null;
+  function loadLancedb() {
+    try {
+      const mod = require2("@lancedb/lancedb");
+      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);
+    }
+  }
+  async function withCollection(name, action) {
+    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 } }));
+      }
+      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];
+      const atomicWrites = primaryKeys.length === 1 && idField.name === "id" && !idField.nullable && ["true", "1", "yes"].includes(idField.metadata.get(PRIMARY_KEY_FLAG)?.toLowerCase() ?? "") && idField.metadata.get(PRIMARY_KEY_POSITION) === "1" && typeof table.mergeInsert === "function";
+      const driver = loadLancedb();
+      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 });
+    } finally {
+      table.close();
+    }
+  }
+  function createDimensionMismatchResult(expected, actual) {
+    return err(
+      HaiVecdbError.DIMENSION_MISMATCH,
+      vecdbM("vecdb_dimensionMismatch", {
+        params: { expected: String(expected), actual: String(actual) }
+      })
+    );
+  }
+  function validateVectorDimension(expected, vector) {
+    if (vector.length === expected) {
+      return null;
+    }
+    return createDimensionMismatchResult(expected, vector.length);
+  }
+  function validateDocumentsDimension(expected, documents) {
+    for (const document of documents) {
+      if (document.vector.length !== expected) {
+        return createDimensionMismatchResult(expected, document.vector.length);
       }
-      const count = await table.countRows();
-      return ok(count);
+    }
+    return null;
+  }
+  function validateAtomicWrite(meta, documents) {
+    if (!meta.inputSchema)
+      return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_jsonMetadataRequired"));
+    if (!meta.atomicWrites)
+      return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_atomicUpsertUnavailable"));
+    if (new Set(documents.map((document) => document.id)).size !== documents.length)
+      return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_duplicateDocumentIds"));
+    return null;
+  }
+  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 } }));
+      }
+      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 } }));
+      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 table = await connection.createEmptyTable(name, schema);
+      table.close();
+      logger2.info("Collection created", { name, dimension, metric });
+      return ok(void 0);
+    },
+    async drop(name) {
+      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 } }));
+      }
+      await connection.dropTable(name);
+      logger2.info("Collection dropped", { name });
+      return ok(void 0);
+    },
+    async exists(name) {
+      logger2.debug("Checking collection exists", { name });
+      const tableNames = await connection.tableNames();
+      return ok(tableNames.includes(name));
+    },
+    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() }));
+    },
+    async list() {
+      logger2.debug("Listing collections");
+      const tableNames = await connection.tableNames();
+      return ok(tableNames);
+    }
+  };
+  const vectorDriver = {
+    async insert(collection, documents) {
+      logger2.debug("Inserting vectors", { collection, count: documents.length });
+      return withCollection(collection, async (table, meta) => {
+        const atomicValidation = validateAtomicWrite(meta, documents);
+        if (atomicValidation)
+          return atomicValidation;
+        const dimensionValidation = validateDocumentsDimension(meta.dimension, documents);
+        if (dimensionValidation) {
+          return dimensionValidation;
+        }
+        const records = documents.map((doc) => ({
+          id: doc.id,
+          vector: doc.vector,
+          content: doc.content ?? "",
+          metadata: JSON.stringify(doc.metadata ?? {})
+        }));
+        const driver = loadLancedb();
+        if (!driver.success)
+          return driver;
+        await table.mergeInsert("id").whenNotMatchedInsertAll().execute(driver.data.makeArrowTable(records, { schema: meta.inputSchema }));
+        logger2.info("Vectors inserted", { collection, count: documents.length });
+        return ok(void 0);
+      });
+    },
+    async upsert(collection, documents) {
+      logger2.debug("Upserting vectors", { collection, count: documents.length });
+      return withCollection(collection, async (table, meta) => {
+        const atomicValidation = validateAtomicWrite(meta, documents);
+        if (atomicValidation)
+          return atomicValidation;
+        const dimensionValidation = validateDocumentsDimension(meta.dimension, documents);
+        if (dimensionValidation) {
+          return dimensionValidation;
+        }
+        const records = documents.map((doc) => ({
+          id: doc.id,
+          vector: doc.vector,
+          content: doc.content ?? "",
+          metadata: JSON.stringify(doc.metadata ?? {})
+        }));
+        const driver = loadLancedb();
+        if (!driver.success)
+          return driver;
+        await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(driver.data.makeArrowTable(records, { schema: meta.inputSchema }));
+        logger2.info("Vectors upserted", { collection, count: documents.length });
+        return ok(void 0);
+      });
+    },
+    async delete(collection, ids) {
+      logger2.debug("Deleting vectors", { collection, count: ids.length });
+      return withCollection(collection, async (table) => {
+        const idList = ids.map((id) => `'${escapeLanceSqlValue(id)}'`).join(", ");
+        await table.delete(`id IN (${idList})`);
+        logger2.info("Vectors deleted", { collection, count: ids.length });
+        return ok(void 0);
+      });
+    },
+    async search(collection, vector, options) {
+      logger2.debug("Searching vectors", { collection, topK: options?.topK, hasFilter: !!options?.filter });
+      return withCollection(collection, async (table, meta) => {
+        const dimensionValidation = validateVectorDimension(meta.dimension, vector);
+        if (dimensionValidation) {
+          return dimensionValidation;
+        }
+        const topK = options?.topK ?? 10;
+        const minScore = options?.minScore ?? 0;
+        let query = table.vectorSearch(vector).distanceType(meta.metric === "euclidean" ? "l2" : meta.metric).limit(topK);
+        if (options?.filter !== void 0) {
+          if (!meta.inputSchema)
+            return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_jsonMetadataRequired"));
+          const predicate = buildMetadataPredicate(options.filter);
+          if (!predicate.success)
+            return predicate;
+          if (predicate.data)
+            query = query.where(predicate.data);
+        }
+        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));
+          return {
+            id: row.id,
+            score,
+            content: row.content || void 0,
+            metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+          };
+        }).filter((r) => r.score >= minScore);
+        return ok(searchResults);
+      });
+    },
+    async count(collection) {
+      logger2.debug("Counting vectors", { collection });
+      return withCollection(collection, async (table) => {
+        const count = await table.countRows();
+        return ok(count);
+      });
     }
   };
   return {
@@ -416,42 +1006,28 @@ function createLancedbProvider() {
         return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
       }
       const lanceConfig = cfg;
-      const loadResult = await loadLancedb();
+      const loadResult = loadLancedb();
       if (!loadResult.success)
         return loadResult;
       const lancedb = loadResult.data;
       try {
-        connection = await lancedb.connect(lanceConfig.path);
+        connection = await lancedb.connect(lanceConfig.path, { readConsistencyInterval: 0 });
         config = lanceConfig;
-        const tableNames = await connection.tableNames();
-        await Promise.allSettled(tableNames.map(async (name) => {
-          try {
-            const table = await connection.openTable(name);
-            const count = await table.countRows();
-            if (count === 0)
-              return;
-            const rows = await table.search(Array.from({ length: 1 }).fill(0)).limit(1).toArray();
-            if (rows.length > 0 && rows[0].vector) {
-              collectionMetas.set(name, {
-                dimension: rows[0].vector.length,
-                metric: lanceConfig.metric ?? "cosine"
-              });
-            }
-          } catch {
-          }
-        }));
-        logger.info("LanceDB connected", { path: lanceConfig.path });
+        logger2.info("LanceDB connected", { path: lanceConfig.path });
         return ok(void 0);
       } catch (error) {
-        logger.error("Failed to connect to LanceDB", { error });
+        connection?.close();
+        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);
       }
     },
     async close() {
+      connection?.close();
       connection = null;
       config = null;
-      collectionMetas.clear();
-      logger.info("LanceDB connection closed");
+      logger2.info("LanceDB connection closed");
       return ok(void 0);
     },
     isConnected() {
@@ -461,7 +1037,14 @@ function createLancedbProvider() {
     vector: createBaseVectorOps(ctx, vectorDriver)
   };
 }
-var logger2 = core.logger.child({ module: "vecdb", scope: "pgvector" });
+var logger3 = core.logger.child({ module: "vecdb", scope: "pgvector" });
+function isPgModule(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const maybeModule = value;
+  return typeof maybeModule.Pool === "function";
+}
 function createPgvectorProvider() {
   let pool = null;
   let config = null;
@@ -484,7 +1067,7 @@ function createPgvectorProvider() {
         return "<=>";
     }
   }
-  function distanceToScore(distance) {
+  function distanceToScore2(distance) {
     const metric = config?.metric ?? "cosine";
     switch (metric) {
       case "cosine":
@@ -497,14 +1080,70 @@ function createPgvectorProvider() {
         return 1 / (1 + distance);
     }
   }
-  const ctx = { isConnected: () => pool !== null, logger: logger2 };
+  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 loadPg() {
+    try {
+      const mod = await import('pg');
+      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 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);
+      }
+      throw error;
+    }
+  }
+  async function getCollectionDimension(name) {
+    const table = tableName(name);
+    const existsResult = await pool.query(
+      `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
+      [table]
+    );
+    if (!existsResult.rows[0].exists) {
+      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)]);
+    return ok(dimResult.rows.length > 0 ? Number(dimResult.rows[0].atttypmod) : 0);
+  }
+  function validateVectorDimension(expected, actual) {
+    if (expected === actual) {
+      return null;
+    }
+    return err(
+      HaiVecdbError.DIMENSION_MISMATCH,
+      vecdbM("vecdb_dimensionMismatch", {
+        params: { expected: String(expected), actual: String(actual) }
+      })
+    );
+  }
+  function validateDocumentsDimension(expected, documents) {
+    for (const document of documents) {
+      const validation = validateVectorDimension(expected, document.vector.length);
+      if (validation) {
+        return validation;
+      }
+    }
+    return null;
+  }
+  const ctx = { isConnected: () => pool !== null, logger: logger3, operationLog: () => config?.operationLog };
   const collectionDriver = {
     async create(name, options) {
       const table = tableName(name);
       const dimension = options.dimension;
       const metric = options.metric ?? config?.metric ?? "cosine";
       const indexType = config?.indexType ?? "hnsw";
-      logger2.debug("Creating collection", { name, dimension, metric, indexType });
+      logger3.debug("Creating collection", { name, dimension, metric, indexType });
       const checkResult = await pool.query(
         `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
         [table]
@@ -535,12 +1174,12 @@ function createPgvectorProvider() {
           WITH (lists = 100)
         `);
       }
-      logger2.info("Collection created", { name, dimension, metric, indexType });
+      logger3.info("Collection created", { name, dimension, metric, indexType });
       return ok(void 0);
     },
     async drop(name) {
       const table = tableName(name);
-      logger2.debug("Dropping collection", { name });
+      logger3.debug("Dropping collection", { name });
       const checkResult = await pool.query(
         `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
         [table]
@@ -549,11 +1188,11 @@ function createPgvectorProvider() {
         return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
       }
       await pool.query(`DROP TABLE ${quoteIdent(table)}`);
-      logger2.info("Collection dropped", { name });
+      logger3.info("Collection dropped", { name });
       return ok(void 0);
     },
     async exists(name) {
-      logger2.debug("Checking collection exists", { name });
+      logger3.debug("Checking collection exists", { name });
       const result = await pool.query(
         `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
         [tableName(name)]
@@ -561,32 +1200,24 @@ function createPgvectorProvider() {
       return ok(result.rows[0].exists);
     },
     async info(name) {
+      logger3.debug("Getting collection info", { name });
       const table = tableName(name);
-      logger2.debug("Getting collection info", { name });
-      const existsResult = await pool.query(
-        `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
-        [table]
-      );
-      if (!existsResult.rows[0].exists) {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      const dimensionResult = await getCollectionDimension(name);
+      if (!dimensionResult.success) {
+        return dimensionResult;
       }
       const countResult = await pool.query(`SELECT COUNT(*) as count FROM ${quoteIdent(table)}`);
       const count = Number.parseInt(String(countResult.rows[0].count), 10);
-      const dimResult = await pool.query(`
-        SELECT atttypmod FROM pg_attribute
-        WHERE attrelid = $1::regclass AND attname = 'vector'
-      `, [quoteIdent(table)]);
-      const dimension = dimResult.rows.length > 0 ? Number(dimResult.rows[0].atttypmod) : 0;
       return ok({
         name,
-        dimension,
+        dimension: dimensionResult.data,
         metric: config?.metric ?? "cosine",
         count
       });
     },
     async list() {
       const prefix = config?.tablePrefix ?? "vec_";
-      logger2.debug("Listing collections");
+      logger3.debug("Listing collections");
       const result = await pool.query(
         `SELECT table_name FROM information_schema.tables WHERE table_name LIKE $1 AND table_schema = 'public'`,
         [`${prefix}%`]
@@ -600,7 +1231,15 @@ function createPgvectorProvider() {
   const vectorDriver = {
     async insert(collection, documents) {
       const table = tableName(collection);
-      logger2.debug("Inserting vectors", { collection, count: documents.length });
+      logger3.debug("Inserting vectors", { collection, count: documents.length });
+      const dimensionResult = await getCollectionDimension(collection);
+      if (!dimensionResult.success) {
+        return dimensionResult;
+      }
+      const dimensionValidation = validateDocumentsDimension(dimensionResult.data, documents);
+      if (dimensionValidation) {
+        return dimensionValidation;
+      }
       const qi = quoteIdent(table);
       const values = [];
       const params = [];
@@ -614,12 +1253,20 @@ function createPgvectorProvider() {
         `INSERT INTO ${qi} (id, vector, content, metadata) VALUES ${values.join(", ")}`,
         params
       );
-      logger2.info("Vectors inserted", { collection, count: documents.length });
+      logger3.info("Vectors inserted", { collection, count: documents.length });
       return ok(void 0);
     },
     async upsert(collection, documents) {
       const table = tableName(collection);
-      logger2.debug("Upserting vectors", { collection, count: documents.length });
+      logger3.debug("Upserting vectors", { collection, count: documents.length });
+      const dimensionResult = await getCollectionDimension(collection);
+      if (!dimensionResult.success) {
+        return dimensionResult;
+      }
+      const dimensionValidation = validateDocumentsDimension(dimensionResult.data, documents);
+      if (dimensionValidation) {
+        return dimensionValidation;
+      }
       const qi = quoteIdent(table);
       const values = [];
       const params = [];
@@ -637,15 +1284,15 @@ function createPgvectorProvider() {
            metadata = EXCLUDED.metadata`,
         params
       );
-      logger2.info("Vectors upserted", { collection, count: documents.length });
+      logger3.info("Vectors upserted", { collection, count: documents.length });
       return ok(void 0);
     },
     async delete(collection, ids) {
       const table = tableName(collection);
-      logger2.debug("Deleting vectors", { collection, count: ids.length });
+      logger3.debug("Deleting vectors", { collection, count: ids.length });
       const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
       await pool.query(`DELETE FROM ${quoteIdent(table)} WHERE id IN (${placeholders})`, ids);
-      logger2.info("Vectors deleted", { collection, count: ids.length });
+      logger3.info("Vectors deleted", { collection, count: ids.length });
       return ok(void 0);
     },
     async search(collection, vector, options) {
@@ -653,7 +1300,15 @@ function createPgvectorProvider() {
       const topK = options?.topK ?? 10;
       const minScore = options?.minScore ?? 0;
       const op = distanceOp();
-      logger2.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
+      logger3.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
+      const dimensionResult = await getCollectionDimension(collection);
+      if (!dimensionResult.success) {
+        return dimensionResult;
+      }
+      const dimensionValidation = validateVectorDimension(dimensionResult.data, vector.length);
+      if (dimensionValidation) {
+        return dimensionValidation;
+      }
       const vectorStr = `[${vector.join(",")}]`;
       let filterSQL = "";
       const filterParams = [vectorStr, topK];
@@ -678,7 +1333,7 @@ function createPgvectorProvider() {
         filterParams
       );
       const searchResults = result.rows.map((row) => {
-        const score = distanceToScore(row.distance);
+        const score = distanceToScore2(row.distance);
         return {
           id: row.id,
           score,
@@ -690,7 +1345,7 @@ function createPgvectorProvider() {
     },
     async count(collection) {
       const table = tableName(collection);
-      logger2.debug("Counting vectors", { collection });
+      logger3.debug("Counting vectors", { collection });
       const result = await pool.query(`SELECT COUNT(*) as count FROM ${quoteIdent(table)}`);
       return ok(Number.parseInt(String(result.rows[0].count), 10));
     }
@@ -703,7 +1358,11 @@ function createPgvectorProvider() {
       }
       const pgConfig = cfg;
       try {
-        const { Pool } = await import('pg');
+        const loadResult = await loadPg();
+        if (!loadResult.success) {
+          return loadResult;
+        }
+        const { Pool } = loadResult.data;
         const poolConfig = pgConfig.url ? { connectionString: pgConfig.url } : {
           host: pgConfig.host,
           port: pgConfig.port,
@@ -714,10 +1373,10 @@ function createPgvectorProvider() {
         pool = new Pool(poolConfig);
         await pool.query("CREATE EXTENSION IF NOT EXISTS vector");
         config = pgConfig;
-        logger2.info("pgvector connected", { host: pgConfig.host, database: pgConfig.database });
+        logger3.info("pgvector connected", { host: pgConfig.host, database: pgConfig.database });
         return ok(void 0);
       } catch (error) {
-        logger2.error("Failed to connect to pgvector", { error: error instanceof Error ? error.message : String(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);
       }
     },
@@ -728,10 +1387,10 @@ function createPgvectorProvider() {
         }
         pool = null;
         config = null;
-        logger2.info("pgvector connection closed");
+        logger3.info("pgvector connection closed");
         return ok(void 0);
       } catch (error) {
-        logger2.error("Failed to close pgvector connection", { error: error instanceof Error ? error.message : String(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);
       }
     },
@@ -742,19 +1401,14 @@ function createPgvectorProvider() {
     vector: createBaseVectorOps(ctx, vectorDriver)
   };
 }
-function sanitizeUrl(url) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.username)
-      parsed.username = "***";
-    if (parsed.password)
-      parsed.password = "***";
-    return parsed.toString();
-  } catch {
-    return "(invalid url)";
+var logger4 = core.logger.child({ module: "vecdb", scope: "qdrant" });
+function isQdrantModule(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
+  const maybeModule = value;
+  return typeof maybeModule.QdrantClient === "function";
 }
-var logger3 = 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)}`;
@@ -767,17 +1421,77 @@ function toQdrantDistance(metric) {
       return "Euclid";
     case "dot":
       return "Dot";
-    default:
-      return "Cosine";
   }
 }
 function createQdrantProvider() {
   let client = null;
   let config = null;
-  const ctx = { isConnected: () => client !== null, logger: logger3 };
+  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;
+  }
+  async function getCollectionInfo(name) {
+    try {
+      return ok(await client.getCollection(name));
+    } catch (error) {
+      if (isQdrantNotFoundError(error)) {
+        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)
+      return void 0;
+    if (!("distance" in vectors))
+      return void 0;
+    const metric = vectors.distance === "Cosine" ? "cosine" : vectors.distance === "Euclid" ? "euclidean" : vectors.distance === "Dot" ? "dot" : void 0;
+    return metric ? { dimension: vectors.size, metric } : void 0;
+  }
+  async function getCollectionDimension(name) {
+    const infoResult = await getCollectionInfo(name);
+    if (!infoResult.success) {
+      return infoResult;
+    }
+    const definition = readVectorDefinition(infoResult.data);
+    return definition ? ok(definition.dimension) : err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", { params: { name } }));
+  }
+  function validateVectorDimension(expected, actual) {
+    if (expected === actual) {
+      return null;
+    }
+    return err(
+      HaiVecdbError.DIMENSION_MISMATCH,
+      vecdbM("vecdb_dimensionMismatch", {
+        params: { expected: String(expected), actual: String(actual) }
+      })
+    );
+  }
+  const ctx = { isConnected: () => client !== null, logger: logger4, operationLog: () => config?.operationLog };
   const collectionDriver = {
     async create(name, options) {
-      logger3.debug("Creating collection", { name, dimension: options.dimension, metric: options.metric });
+      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) {
@@ -790,50 +1504,49 @@ function createQdrantProvider() {
           distance: toQdrantDistance(metric)
         }
       });
-      logger3.info("Collection created", { name, dimension: options.dimension, metric });
+      logger4.info("Collection created", { name, dimension: options.dimension, metric });
       return ok(void 0);
     },
     async drop(name) {
-      logger3.debug("Dropping collection", { name });
-      try {
-        await client.getCollection(name);
-      } catch {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      logger4.debug("Dropping collection", { name });
+      const infoResult = await getCollectionInfo(name);
+      if (!infoResult.success) {
+        return infoResult;
       }
       await client.deleteCollection(name);
-      logger3.info("Collection dropped", { name });
+      logger4.info("Collection dropped", { name });
       return ok(void 0);
     },
     async exists(name) {
-      logger3.debug("Checking collection exists", { name });
+      logger4.debug("Checking collection exists", { name });
       try {
         await client.getCollection(name);
         return ok(true);
-      } catch {
-        return ok(false);
+      } catch (error) {
+        if (isQdrantNotFoundError(error)) {
+          return ok(false);
+        }
+        throw error;
       }
     },
     async info(name) {
-      logger3.debug("Getting collection info", { name });
-      let collectionInfo;
-      try {
-        collectionInfo = await client.getCollection(name);
-      } catch {
-        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      logger4.debug("Getting collection info", { name });
+      const infoResult = await getCollectionInfo(name);
+      if (!infoResult.success) {
+        return infoResult;
       }
-      const vectorsConfig = collectionInfo.config?.params?.vectors;
-      const dimension = vectorsConfig?.size ?? 0;
-      const qdrantDistance = vectorsConfig?.distance ?? "Cosine";
-      const metric = qdrantDistance === "Euclid" ? "euclidean" : qdrantDistance === "Dot" ? "dot" : "cosine";
+      const collectionInfo = infoResult.data;
+      const definition = readVectorDefinition(collectionInfo);
+      if (!definition)
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_invalidCollectionSchema", { params: { name } }));
       return ok({
         name,
-        dimension,
-        metric,
+        ...definition,
         count: collectionInfo.points_count ?? 0
       });
     },
     async list() {
-      logger3.debug("Listing collections");
+      logger4.debug("Listing collections");
       const collections = await client.getCollections();
       const names = collections.collections.map((c) => c.name);
       return ok(names);
@@ -841,7 +1554,17 @@ function createQdrantProvider() {
   };
   const vectorDriver = {
     async insert(collection, documents) {
-      logger3.debug("Inserting vectors", { collection, count: documents.length });
+      logger4.debug("Inserting vectors", { collection, count: documents.length });
+      const dimensionResult = await getCollectionDimension(collection);
+      if (!dimensionResult.success) {
+        return dimensionResult;
+      }
+      for (const document of documents) {
+        const validation = validateVectorDimension(dimensionResult.data, document.vector.length);
+        if (validation) {
+          return validation;
+        }
+      }
       const points = documents.map((doc) => ({
         id: hashToUuid(doc.id),
         vector: doc.vector,
@@ -851,12 +1574,22 @@ function createQdrantProvider() {
           _content: doc.content ?? ""
         }
       }));
-      await client.upsert(collection, { points });
-      logger3.info("Vectors inserted", { collection, count: documents.length });
+      await client.upsert(collection, { points, wait: true });
+      logger4.info("Vectors inserted", { collection, count: documents.length });
       return ok(void 0);
     },
     async upsert(collection, documents) {
-      logger3.debug("Upserting vectors", { collection, count: documents.length });
+      logger4.debug("Upserting vectors", { collection, count: documents.length });
+      const dimensionResult = await getCollectionDimension(collection);
+      if (!dimensionResult.success) {
+        return dimensionResult;
+      }
+      for (const document of documents) {
+        const validation = validateVectorDimension(dimensionResult.data, document.vector.length);
+        if (validation) {
+          return validation;
+        }
+      }
       const points = documents.map((doc) => ({
         id: hashToUuid(doc.id),
         vector: doc.vector,
@@ -866,21 +1599,29 @@ function createQdrantProvider() {
           _content: doc.content ?? ""
         }
       }));
-      await client.upsert(collection, { points });
-      logger3.info("Vectors upserted", { collection, count: documents.length });
+      await client.upsert(collection, { points, wait: true });
+      logger4.info("Vectors upserted", { collection, count: documents.length });
       return ok(void 0);
     },
     async delete(collection, ids) {
-      logger3.debug("Deleting vectors", { collection, count: ids.length });
+      logger4.debug("Deleting vectors", { collection, count: ids.length });
       const uuids = ids.map(hashToUuid);
-      await client.delete(collection, { points: uuids });
-      logger3.info("Vectors deleted", { collection, count: ids.length });
+      await client.delete(collection, { points: uuids, wait: true });
+      logger4.info("Vectors deleted", { collection, count: ids.length });
       return ok(void 0);
     },
     async search(collection, vector, options) {
       const topK = options?.topK ?? 10;
       const minScore = options?.minScore ?? 0;
-      logger3.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
+      logger4.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
+      const dimensionResult = await getCollectionDimension(collection);
+      if (!dimensionResult.success) {
+        return dimensionResult;
+      }
+      const dimensionValidation = validateVectorDimension(dimensionResult.data, vector.length);
+      if (dimensionValidation) {
+        return dimensionValidation;
+      }
       let filter;
       if (options?.filter && Object.keys(options.filter).length > 0) {
         const mustConditions = Object.entries(options.filter).map(([key, value]) => ({
@@ -889,29 +1630,29 @@ function createQdrantProvider() {
         }));
         filter = { must: mustConditions };
       }
-      const searchResult = await client.search(collection, {
-        vector,
+      const searchResult = await client.query(collection, {
+        query: vector,
         limit: topK,
         score_threshold: minScore > 0 ? minScore : void 0,
         filter,
         with_payload: true
       });
-      const results = searchResult.map((point) => {
+      const results = searchResult.points.map((point) => {
         const payload = point.payload ?? {};
         const { _id, _content, ...metadata } = payload;
         return {
-          id: _id ?? "",
+          id: typeof _id === "string" ? _id : "",
           score: point.score,
-          content: _content || void 0,
+          content: typeof _content === "string" && _content.length > 0 ? _content : void 0,
           metadata: Object.keys(metadata).length > 0 ? metadata : void 0
         };
       });
       return ok(results);
     },
     async count(collection) {
-      logger3.debug("Counting vectors", { collection });
-      const info = await client.getCollection(collection);
-      return ok(info.points_count ?? 0);
+      logger4.debug("Counting vectors", { collection });
+      const count = await client.count(collection, { exact: true });
+      return ok(count.count);
     }
   };
   return {
@@ -922,7 +1663,11 @@ function createQdrantProvider() {
       }
       const qdrantConfig = cfg;
       try {
-        const { QdrantClient: QdrantClientClass } = await import('@qdrant/js-client-rest');
+        const loadResult = await loadQdrantClient();
+        if (!loadResult.success) {
+          return loadResult;
+        }
+        const { QdrantClient: QdrantClientClass } = loadResult.data;
         const qdrantClient = new QdrantClientClass({
           url: qdrantConfig.url,
           apiKey: qdrantConfig.apiKey
@@ -930,17 +1675,17 @@ function createQdrantProvider() {
         await qdrantClient.getCollections();
         client = qdrantClient;
         config = qdrantConfig;
-        logger3.info("Qdrant connected", { url: sanitizeUrl(qdrantConfig.url) });
+        logger4.info("Qdrant connected", { url: core.sanitize.sanitizeUrl(qdrantConfig.url) });
         return ok(void 0);
       } catch (error) {
-        logger3.error("Failed to connect to Qdrant", { error: error instanceof Error ? error.message : String(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);
       }
     },
     async close() {
       client = null;
       config = null;
-      logger3.info("Qdrant connection closed");
+      logger4.info("Qdrant connection closed");
       return ok(void 0);
     },
     isConnected() {
@@ -952,10 +1697,42 @@ function createQdrantProvider() {
 }
 
 // src/vecdb-main.ts
-var logger4 = core.logger.child({ module: "vecdb", scope: "main" });
+var logger5 = core.logger.child({ module: "vecdb", scope: "main" });
 var currentProvider = null;
 var currentConfig = null;
 var initInProgress = false;
+var pendingProvider = null;
+var initCompletion = null;
+var closingPromise = null;
+async function closeOwnedProvider() {
+  if (currentProvider) {
+    pendingProvider = currentProvider;
+    currentProvider = null;
+  }
+  currentConfig = null;
+  if (!pendingProvider)
+    return ok(void 0);
+  try {
+    const result = await pendingProvider.close();
+    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 } });
+  }
+}
+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 } });
+  const ext = { ...result.error.ext };
+  delete ext.cleanupPending;
+  delete ext.cleanupError;
+  return err({ ...result.error, ext: Object.keys(ext).length ? ext : void 0 });
+}
 function createProvider(config) {
   switch (config.type) {
     case "lancedb":
@@ -964,6 +1741,8 @@ function createProvider(config) {
       return createPgvectorProvider();
     case "qdrant":
       return createQdrantProvider();
+    case "chroma":
+      return createChromaProvider();
   }
 }
 var notInitialized = core.module.createNotInitializedKit(
@@ -972,6 +1751,20 @@ var notInitialized = core.module.createNotInitializedKit(
 );
 var notInitializedCollection = notInitialized.proxy();
 var notInitializedVector = notInitialized.proxy();
+var collectionOps = {
+  create: (name, options) => currentProvider && !closingPromise ? currentProvider.collection.create(name, options) : notInitializedCollection.create(name, options),
+  drop: (name) => currentProvider && !closingPromise ? currentProvider.collection.drop(name) : notInitializedCollection.drop(name),
+  exists: (name) => currentProvider && !closingPromise ? currentProvider.collection.exists(name) : notInitializedCollection.exists(name),
+  info: (name) => currentProvider && !closingPromise ? currentProvider.collection.info(name) : notInitializedCollection.info(name),
+  list: () => currentProvider && !closingPromise ? currentProvider.collection.list() : notInitializedCollection.list()
+};
+var vectorOps = {
+  insert: (collection, documents) => currentProvider && !closingPromise ? currentProvider.vector.insert(collection, documents) : notInitializedVector.insert(collection, documents),
+  upsert: (collection, documents) => currentProvider && !closingPromise ? currentProvider.vector.upsert(collection, documents) : notInitializedVector.upsert(collection, documents),
+  delete: (collection, ids) => currentProvider && !closingPromise ? currentProvider.vector.delete(collection, ids) : notInitializedVector.delete(collection, ids),
+  search: (collection, vector, options) => currentProvider && !closingPromise ? currentProvider.vector.search(collection, vector, options) : notInitializedVector.search(collection, vector, options),
+  count: (collection) => currentProvider && !closingPromise ? currentProvider.vector.count(collection) : notInitializedVector.count(collection)
+};
 var vecdb = {
   /**
    * 初始化向量数据库连接
@@ -980,43 +1773,52 @@ var vecdb = {
    * @returns 初始化结果，失败时包含错误信息
    */
   async init(config) {
-    if (initInProgress) {
-      logger4.warn("Vecdb init already in progress, skipping concurrent call");
+    if (initInProgress || closingPromise) {
+      logger5.warn("Vecdb init already in progress, skipping concurrent call");
       return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_initInProgress"));
     }
     initInProgress = true;
+    let resolveInit;
+    initCompletion = new Promise((resolve) => {
+      resolveInit = resolve;
+    });
     try {
-      if (currentProvider) {
-        logger4.warn("Vecdb module is already initialized, reinitializing");
-        await vecdb.close();
-      }
-      logger4.info("Initializing vecdb module");
+      const cleanup = await closeOwnedProvider();
+      if (!cleanup.success)
+        return cleanup;
+      logger5.info("Initializing vecdb module");
       const parseResult = VecdbConfigSchema.safeParse(config);
       if (!parseResult.success) {
-        logger4.error("Vecdb config validation failed", { error: parseResult.error.message });
+        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);
       }
       const parsed = parseResult.data;
+      if (core.module.requiresSharedState(process.env) && (parsed.type === "lancedb" || parsed.type === "chroma" && !!parsed.path && !parsed.url))
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_sharedBackendRequired"));
       try {
         const provider = createProvider(parsed);
+        pendingProvider = provider;
         const connectResult = await provider.connect(parsed);
         if (!connectResult.success) {
-          logger4.error("Vecdb module initialization failed", {
+          logger5.error("Vecdb module initialization failed", {
             code: connectResult.error.code,
             message: connectResult.error.message
           });
-          return connectResult;
+          return await failInitialization(connectResult);
         }
+        pendingProvider = null;
         currentProvider = provider;
         currentConfig = parsed;
-        logger4.info("Vecdb module initialized", { type: parsed.type });
+        logger5.info("Vecdb module initialized", { type: parsed.type });
         return ok(void 0);
       } catch (error) {
-        logger4.error("Vecdb module initialization failed", { error });
-        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_initFailed", { params: { error: error instanceof Error ? error.message : String(error) } }), 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));
       }
     } finally {
       initInProgress = false;
+      initCompletion = null;
+      resolveInit();
     }
   },
   /**
@@ -1025,7 +1827,7 @@ var vecdb = {
    * 未初始化时返回占位对象（所有调用返回 NOT_INITIALIZED）。
    */
   get collection() {
-    return currentProvider?.collection ?? notInitializedCollection;
+    return collectionOps;
   },
   /**
    * 获取向量操作接口
@@ -1033,15 +1835,44 @@ var vecdb = {
    * 未初始化时返回占位对象（所有调用返回 NOT_INITIALIZED）。
    */
   get vector() {
-    return currentProvider?.vector ?? notInitializedVector;
+    return vectorOps;
   },
-  /** 获取当前配置（未初始化时为 null） */
+  /** 获取当前脱敏配置快照（未初始化时为 null） */
   get config() {
-    return currentConfig;
+    return currentConfig && !closingPromise ? core.sanitize.sanitizeSensitiveFields(currentConfig) : null;
+  },
+  /** 获取底层后端的原始连接信息（含凭证，未初始化时为 null；仅供同进程内集成使用） */
+  get rawConnection() {
+    if (!currentConfig || closingPromise)
+      return null;
+    if (currentConfig.type === "qdrant")
+      return { type: "qdrant", url: currentConfig.url, apiKey: currentConfig.apiKey };
+    if (currentConfig.type === "pgvector") {
+      return {
+        type: "pgvector",
+        connectionString: currentConfig.url,
+        host: currentConfig.host,
+        port: currentConfig.port,
+        database: currentConfig.database,
+        user: currentConfig.user,
+        password: currentConfig.password
+      };
+    }
+    if (currentConfig.type === "chroma") {
+      return {
+        type: "chroma",
+        url: currentConfig.url,
+        host: currentConfig.host,
+        port: currentConfig.port,
+        apiKey: currentConfig.apiKey,
+        path: currentConfig.path
+      };
+    }
+    return { type: currentConfig.type, path: currentConfig.path };
   },
   /** 检查是否已初始化 */
   get isInitialized() {
-    return currentProvider !== null && currentProvider.isConnected();
+    return currentProvider !== null && !closingPromise && currentProvider.isConnected();
   },
   /**
    * 关闭向量数据库连接
@@ -1049,30 +1880,19 @@ var vecdb = {
    * 多次调用安全，未初始化时直接返回。
    */
   async close() {
-    if (!currentProvider) {
-      currentConfig = null;
-      logger4.info("Vecdb module already closed, skipping");
-      return ok(void 0);
-    }
-    logger4.info("Closing vecdb module");
-    try {
-      const closeResult = await currentProvider.close();
-      if (!closeResult.success) {
-        logger4.error("Vecdb module close failed", { code: closeResult.error.code, message: closeResult.error.message });
-        return closeResult;
-      }
-      logger4.info("Vecdb module closed");
-      return ok(void 0);
-    } catch (error) {
-      logger4.error("Vecdb module close failed", { error });
-      return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_closeFailed", { params: { error: error instanceof Error ? error.message : String(error) } }), error);
-    } finally {
-      currentProvider = null;
-      currentConfig = null;
+    if (!closingPromise) {
+      closingPromise = (async () => {
+        if (initCompletion)
+          await initCompletion;
+        return closeOwnedProvider();
+      })().finally(() => {
+        closingPromise = null;
+      });
     }
+    return await closingPromise;
   }
 };
 
-export { DistanceMetricSchema, HaiVecdbError, LancedbConfigSchema, PgvectorConfigSchema, PgvectorIndexTypeSchema, QdrantConfigSchema, VecdbConfigSchema, VecdbTypeSchema, vecdb };
+export { DistanceMetricSchema, HaiVecdbError, VecdbConfigSchema, VecdbOperationLogConfigSchema, vecdb };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map