ydb-qdrant 8.1.0 → 9.0.3

package/dist/utils/requestIdentity.js

@@ -0,0 +1,52 @@
+import { AnonymousIdentityError, deriveAnonymousUserUid, deriveUserUidFromApiKey, sanitizeUserUid, } from "./tenant.js";
+export function isAnonymousIdentityError(err) {
+    return err instanceof AnonymousIdentityError;
+}
+function sanitizeTenantId(tenantId) {
+    const raw = (tenantId ?? "default").toString();
+    const cleaned = raw.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_");
+    const lowered = cleaned.toLowerCase().replace(/^_+/, "");
+    return lowered.length > 0 ? lowered : "default";
+}
+export function getRequestApiKey(req) {
+    const apiKey = req.header("api-key")?.trim();
+    return apiKey && apiKey.length > 0 ? apiKey : undefined;
+}
+export function getRequestClientIp(req) {
+    const reqIp = typeof req.ip === "string" && req.ip.trim().length > 0
+        ? req.ip.trim()
+        : undefined;
+    if (reqIp) {
+        return reqIp;
+    }
+    const remoteAddress = req.socket.remoteAddress;
+    return typeof remoteAddress === "string" && remoteAddress.trim().length > 0
+        ? remoteAddress.trim()
+        : undefined;
+}
+export function resolveRequestUserUid(req) {
+    const apiKey = getRequestApiKey(req);
+    if (apiKey) {
+        return deriveUserUidFromApiKey(apiKey);
+    }
+    return deriveAnonymousUserUid({
+        clientIp: getRequestClientIp(req),
+        userAgent: req.header("User-Agent") ?? undefined,
+    });
+}
+export function resolveRequestNamespaceUserUid(req) {
+    const baseUserUid = resolveRequestUserUid(req);
+    const tenantId = sanitizeTenantId(req.header("X-Tenant-Id") ?? undefined);
+    return sanitizeUserUid(`${baseUserUid}_${tenantId}`);
+}
+export function resolveRequestSigningKey(req, userUid) {
+    const apiKey = getRequestApiKey(req);
+    if (apiKey) {
+        return apiKey;
+    }
+    const fallbackUserUid = userUid?.trim();
+    if (fallbackUserUid) {
+        return fallbackUserUid;
+    }
+    return resolveRequestUserUid(req);
+}

package/dist/utils/retry.d.ts

@@ -1,8 +1,10 @@
 export interface RetryOptions {
     maxRetries?: number;
     baseDelayMs?: number;
+    maxBackoffMs?: number;
     isTransient?: (error: unknown) => boolean;
     context?: Record<string, unknown>;
 }
 export declare function isTransientYdbError(error: unknown): boolean;
+export declare function isTransientYdbErrorInAcquiredSession(error: unknown): boolean;
 export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/utils/retry.js

@@ -1,25 +1,68 @@
 import { logger } from "../logging/logger.js";
 const DEFAULT_MAX_RETRIES = 6;
 const DEFAULT_BASE_DELAY_MS = 250;
-export function isTransientYdbError(error) {
+const UNDETERMINED_OPERATION_UNKNOWN_RE = /Undetermined \(code 400170\)|State of operation is unknown|Failed to d(?:eliver|eviler) message|issueCode["']?\s*:\s*2026/i;
+const SESSION_RECREATION_ERROR_RE = /BadSession \(code 400100\)|Session is under shutdown|SessionBusy|SESSION_BUSY/i;
+const SESSION_EXPIRED_ERROR_RE = /SessionExpired|SESSION_EXPIRED/i;
+const SESSION_POOL_CONTENTION_RE = /SESSION_POOL_EMPTY|No session became available within timeout/i;
+const SAME_SESSION_TRANSIENT_YDB_ERROR_RE = /Aborted|Unavailable \(code 400050\)|schema version mismatch|Table metadata loading|Failed to load metadata|overloaded|is in process of split|wrong shard state|Rejecting data TxId/i;
+const TIMEOUT_ERROR_RE = /Timeout \(code 400090\)/i;
+function normalizeMaxBackoffMs(value) {
+    if (value === undefined) {
+        return Number.POSITIVE_INFINITY;
+    }
+    if (!Number.isFinite(value) || value < 0) {
+        return Number.POSITIVE_INFINITY;
+    }
+    return value;
+}
+function getErrorMessageAndIssuesText(error) {
     const msg = error instanceof Error ? error.message : String(error);
-    if (/Aborted|schema version mismatch|Table metadata loading|Failed to load metadata|overloaded|is in process of split|wrong shard state|Rejecting data TxId/i.test(msg)) {
-        return true;
+    if (typeof error !== "object" || error === null) {
+        return { msg };
     }
-    if (typeof error === "object" && error !== null) {
-        const issues = error.issues;
-        if (issues !== undefined) {
-            const issuesText = typeof issues === "string" ? issues : JSON.stringify(issues);
-            if (/overloaded|is in process of split|wrong shard state|Rejecting data TxId/i.test(issuesText)) {
-                return true;
-            }
+    const issues = error.issues;
+    if (issues === undefined) {
+        return { msg };
+    }
+    return {
+        msg,
+        issuesText: typeof issues === "string" ? issues : JSON.stringify(issues),
+    };
+}
+function matchesPatternSet(error, patterns) {
+    const { msg, issuesText } = getErrorMessageAndIssuesText(error);
+    for (const pattern of patterns) {
+        if (pattern.test(msg)) {
+            return true;
+        }
+        if (issuesText !== undefined && pattern.test(issuesText)) {
+            return true;
         }
     }
     return false;
 }
+export function isTransientYdbError(error) {
+    return matchesPatternSet(error, [
+        UNDETERMINED_OPERATION_UNKNOWN_RE,
+        SESSION_RECREATION_ERROR_RE,
+        SESSION_EXPIRED_ERROR_RE,
+        SESSION_POOL_CONTENTION_RE,
+        SAME_SESSION_TRANSIENT_YDB_ERROR_RE,
+        TIMEOUT_ERROR_RE,
+    ]);
+}
+export function isTransientYdbErrorInAcquiredSession(error) {
+    return matchesPatternSet(error, [
+        UNDETERMINED_OPERATION_UNKNOWN_RE,
+        SAME_SESSION_TRANSIENT_YDB_ERROR_RE,
+        TIMEOUT_ERROR_RE,
+    ]);
+}
 export async function withRetry(fn, options = {}) {
     const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
     const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    const maxBackoffMs = normalizeMaxBackoffMs(options.maxBackoffMs);
     const isTransient = options.isTransient ?? isTransientYdbError;
     const context = options.context ?? {};
     let attempt = 0;
@@ -31,7 +74,8 @@ export async function withRetry(fn, options = {}) {
             if (!isTransient(e) || attempt >= maxRetries) {
                 throw e;
             }
-            const backoffMs = Math.floor(baseDelayMs * Math.pow(2, attempt) + Math.random() * 100);
+            const computedBackoffMs = Math.floor(baseDelayMs * Math.pow(2, attempt) + Math.random() * 100);
+            const backoffMs = Math.min(computedBackoffMs, maxBackoffMs);
             logger.warn({
                 ...context,
                 attempt,

package/dist/utils/tenant.d.ts

@@ -1,7 +1,13 @@
-export declare function hashApiKey(apiKey: string | undefined): string | undefined;
+export declare class AnonymousIdentityError extends Error {
+    constructor();
+}
 export declare function normalizeUserAgent(userAgent: string | undefined): string | undefined;
-export declare function sanitizeCollectionName(name: string, apiKeyHash?: string, userAgentNormalized?: string): string;
-export declare function sanitizeTenantId(tenantId: string | undefined): string;
-export declare function tableNameFor(sanitizedTenant: string, sanitizedCollection: string): string;
-export declare function metaKeyFor(sanitizedTenant: string, sanitizedCollection: string): string;
-export declare function uidFor(sanitizedTenant: string, sanitizedCollection: string): string;
+export declare function sanitizeCollectionName(name: string, _userAgentNormalized?: string): string;
+export declare function sanitizeUserUid(userUid: string): string;
+export declare function deriveUserUidFromApiKey(apiKey: string): string;
+export declare function deriveAnonymousUserUid(args: {
+    clientIp?: string;
+    userAgent?: string;
+}): string;
+export declare function metaKeyFor(sanitizedUserUid: string, sanitizedCollection: string): string;
+export declare function uidFor(sanitizedUserUid: string, sanitizedCollection: string): string;

package/dist/utils/tenant.js

@@ -1,9 +1,15 @@
-import { createHash } from "crypto";
-export function hashApiKey(apiKey) {
-    if (!apiKey || apiKey.trim() === "")
-        return undefined;
-    const hash = createHash("sha256").update(apiKey).digest("hex");
-    return hash.slice(0, 8);
+import { createHash } from "node:crypto";
+const API_KEY_UID_PREFIX = "ak";
+const ANONYMOUS_UID_PREFIX = "anon";
+const UID_HASH_LENGTH = 16;
+export class AnonymousIdentityError extends Error {
+    constructor() {
+        super("Anonymous requests require api-key or identifiable client metadata.");
+        this.name = "AnonymousIdentityError";
+    }
+}
+function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, UID_HASH_LENGTH);
 }
 export function normalizeUserAgent(userAgent) {
     if (!userAgent || userAgent.trim() === "")
@@ -22,39 +28,42 @@ export function normalizeUserAgent(userAgent) {
     }
     if (lowered.length === 0)
         return undefined;
-    const hash = createHash("sha256").update(userAgent).digest("hex");
-    const shortHash = hash.slice(0, 8);
-    return `${lowered}_${shortHash}`;
+    return lowered;
 }
-export function sanitizeCollectionName(name, apiKeyHash, userAgentNormalized) {
+export function sanitizeCollectionName(name, _userAgentNormalized) {
+    void _userAgentNormalized;
     const cleaned = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_");
     const lowered = cleaned.toLowerCase().replace(/^_+/, "");
-    const base = lowered.length > 0 ? lowered : "collection";
-    const hasApiKey = apiKeyHash !== undefined && apiKeyHash.trim().length > 0;
-    const hasUserAgent = userAgentNormalized !== undefined && userAgentNormalized.trim().length > 0;
-    if (hasApiKey && hasUserAgent) {
-        return `${base}_${apiKeyHash}_${userAgentNormalized}`;
-    }
-    else if (hasApiKey) {
-        return `${base}_${apiKeyHash}`;
-    }
-    else if (hasUserAgent) {
-        return `${base}_${userAgentNormalized}`;
-    }
-    return base;
+    return lowered.length > 0 ? lowered : "collection";
 }
-export function sanitizeTenantId(tenantId) {
-    const raw = (tenantId ?? "default").toString();
+export function sanitizeUserUid(userUid) {
+    const raw = userUid.toString();
     const cleaned = raw.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_");
     const lowered = cleaned.toLowerCase().replace(/^_+/, "");
-    return lowered.length > 0 ? lowered : "default";
+    return lowered.length > 0 ? lowered : "anonymous";
+}
+export function deriveUserUidFromApiKey(apiKey) {
+    const normalizedApiKey = apiKey.trim();
+    if (normalizedApiKey.length === 0) {
+        throw new Error("deriveUserUidFromApiKey: apiKey is empty");
+    }
+    return sanitizeUserUid(`${API_KEY_UID_PREFIX}_${shortHash(normalizedApiKey)}`);
 }
-export function tableNameFor(sanitizedTenant, sanitizedCollection) {
-    return `qdr_${sanitizedTenant}__${sanitizedCollection}`;
+export function deriveAnonymousUserUid(args) {
+    const normalizedUserAgent = normalizeUserAgent(args.userAgent);
+    const normalizedClientIp = args.clientIp?.trim();
+    if (!normalizedClientIp && !normalizedUserAgent) {
+        throw new AnonymousIdentityError();
+    }
+    const identitySeed = [
+        normalizedClientIp || "unknown_ip",
+        normalizedUserAgent || "unknown_ua",
+    ].join("|");
+    return sanitizeUserUid(`${ANONYMOUS_UID_PREFIX}_${shortHash(identitySeed)}`);
 }
-export function metaKeyFor(sanitizedTenant, sanitizedCollection) {
-    return `${sanitizedTenant}/${sanitizedCollection}`;
+export function metaKeyFor(sanitizedUserUid, sanitizedCollection) {
+    return `${sanitizedUserUid}/${sanitizedCollection}`;
 }
-export function uidFor(sanitizedTenant, sanitizedCollection) {
-    return tableNameFor(sanitizedTenant, sanitizedCollection);
+export function uidFor(sanitizedUserUid, sanitizedCollection) {
+    return metaKeyFor(sanitizedUserUid, sanitizedCollection);
 }

package/dist/utils/vectorBinary.d.ts

@@ -1,2 +1 @@
 export declare function vectorToFloatBinary(vector: number[]): Buffer;
-export declare function vectorToBitBinary(vector: number[]): Buffer;

package/dist/utils/vectorBinary.js

@@ -19,101 +19,3 @@ export function vectorToFloatBinary(vector) {
     buffer.writeUInt8(1, vector.length * 4);
     return buffer;
 }
-export function vectorToBitBinary(vector) {
-    // Mirrors YDB's TKnnBitVectorSerializer (Knn::ToBinaryStringBit) layout:
-    // - Packed bits as integers written in native endianness
-    // - Then 1 byte: count of unused bits in the last data byte
-    // - Then 1 byte: format marker (10 = BitVector)
-    //
-    // Source: https://raw.githubusercontent.com/ydb-platform/ydb/0b506f56e399e0b4e6a6a4267799da68a3164bf7/ydb/library/yql/udfs/common/knn/knn-serializer.h
-    const bitLen = vector.length;
-    const dataByteLen = Math.ceil(bitLen / 8);
-    const totalLen = dataByteLen + 2; // +1 unused-bit-count +1 format marker
-    const buffer = Buffer.alloc(totalLen);
-    let offset = 0;
-    const writeU64 = (v) => {
-        if (IS_LITTLE_ENDIAN) {
-            buffer.writeBigUInt64LE(v, offset);
-        }
-        else {
-            buffer.writeBigUInt64BE(v, offset);
-        }
-        offset += 8;
-    };
-    const writeU32 = (v) => {
-        if (IS_LITTLE_ENDIAN) {
-            buffer.writeUInt32LE(v, offset);
-        }
-        else {
-            buffer.writeUInt32BE(v, offset);
-        }
-        offset += 4;
-    };
-    const writeU16 = (v) => {
-        if (IS_LITTLE_ENDIAN) {
-            buffer.writeUInt16LE(v, offset);
-        }
-        else {
-            buffer.writeUInt16BE(v, offset);
-        }
-        offset += 2;
-    };
-    const writeU8 = (v) => {
-        buffer.writeUInt8(v, offset);
-        offset += 1;
-    };
-    let accumulator = 0n;
-    let filledBits = 0;
-    for (let i = 0; i < vector.length; i += 1) {
-        const value = vector[i];
-        if (!Number.isFinite(value)) {
-            throw new Error(`Non-finite value in vector at index ${i}: ${value}`);
-        }
-        if (value > 0) {
-            accumulator |= 1n;
-        }
-        filledBits += 1;
-        if (filledBits === 64) {
-            writeU64(accumulator);
-            accumulator = 0n;
-            filledBits = 0;
-        }
-        accumulator <<= 1n;
-    }
-    accumulator >>= 1n;
-    filledBits += 7;
-    const tailWriteIf = (bits) => {
-        if (filledBits < bits) {
-            return;
-        }
-        if (bits === 64) {
-            writeU64(accumulator & 0xffffffffffffffffn);
-            filledBits -= 64;
-            return;
-        }
-        if (bits === 32) {
-            writeU32(Number(accumulator & 0xffffffffn));
-            accumulator >>= 32n;
-            filledBits -= 32;
-            return;
-        }
-        if (bits === 16) {
-            writeU16(Number(accumulator & 0xffffn));
-            accumulator >>= 16n;
-            filledBits -= 16;
-            return;
-        }
-        writeU8(Number(accumulator & 0xffn));
-        accumulator >>= 8n;
-        filledBits -= 8;
-    };
-    tailWriteIf(64);
-    tailWriteIf(32);
-    tailWriteIf(16);
-    tailWriteIf(8);
-    // After tail writes, we must have < 8 "filledBits" left.
-    const unusedBitsInLastByte = 7 - filledBits;
-    writeU8(unusedBitsInLastByte);
-    writeU8(10);
-    return buffer;
-}

package/dist/utils/ydbErrors.d.ts

@@ -0,0 +1 @@
+export declare function isOutOfBufferMemoryYdbError(error: unknown): boolean;

package/dist/utils/ydbErrors.js

@@ -0,0 +1,14 @@
+export function isOutOfBufferMemoryYdbError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (/Out of buffer memory/i.test(msg)) {
+        return true;
+    }
+    if (typeof error === "object" && error !== null && "issues" in error) {
+        const issues = error.issues;
+        if (issues !== undefined) {
+            const issuesText = typeof issues === "string" ? issues : JSON.stringify(issues);
+            return /Out of buffer memory/i.test(issuesText);
+        }
+    }
+    return false;
+}

package/dist/ydb/bootstrapMetaTable.js

@@ -1,3 +1,4 @@
+import { basename } from "node:path";
 import { Column, TableDescription, Types, destroyDriver, readyOrThrow, withSession, } from "./client.js";
 function isTableNotFoundError(err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -30,7 +31,7 @@ export async function bootstrapMetaTable() {
                 throw err;
             }
             const td = new TableDescription()
-                .withColumns(new Column("collection", Types.UTF8), new Column("table_name", Types.UTF8), new Column("vector_dimension", Types.UINT32), new Column("distance", Types.UTF8), new Column("vector_type", Types.UTF8), new Column("created_at", Types.TIMESTAMP), new Column("last_accessed_at", Types.TIMESTAMP))
+                .withColumns(new Column("collection", Types.UTF8), new Column("table_name", Types.UTF8), new Column("vector_dimension", Types.UINT32), new Column("distance", Types.UTF8), new Column("vector_type", Types.UTF8), new Column("created_at", Types.TIMESTAMP), new Column("last_accessed_at", Types.TIMESTAMP), new Column("user_uid", Types.optional(Types.UTF8)))
                 .withPrimaryKey("collection");
             try {
                 await s.createTable("qdr__collections", td);
@@ -48,10 +49,21 @@ export async function bootstrapMetaTable() {
         if (!hasLastAccessedAt) {
             throw new Error("bootstrapMetaTable: qdr__collections exists but is missing required column last_accessed_at");
         }
+        const hasUserUid = cols.some((c) => c.name === "user_uid");
+        if (!hasUserUid) {
+            throw new Error("bootstrapMetaTable: qdr__collections exists but is missing required column user_uid");
+        }
     });
 }
+function isBootstrapMetaTableEntrypoint(argv1) {
+    if (!argv1) {
+        return false;
+    }
+    const entry = basename(argv1);
+    return (entry === "bootstrapMetaTable.ts" || entry === "bootstrapMetaTable.js");
+}
 // CLI entrypoint
-if (process.argv[1]?.endsWith("bootstrapMetaTable.js")) {
+if (isBootstrapMetaTableEntrypoint(process.argv[1])) {
     const main = async () => {
         await bootstrapMetaTable();
         // Important: ydb-sdk driver/session pool keeps timers alive; explicitly

package/dist/ydb/client.d.ts

@@ -1,6 +1,6 @@
 import type { Session, IAuthService, ExecuteQuerySettings as YdbExecuteQuerySettings, BulkUpsertSettings as YdbBulkUpsertSettings, QuerySession } from "ydb-sdk";
-declare const Types: typeof import("ydb-sdk").Types, TypedValues: typeof import("ydb-sdk").TypedValues, TableDescription: typeof import("ydb-sdk").TableDescription, Column: typeof import("ydb-sdk").Column, ExecuteQuerySettings: typeof YdbExecuteQuerySettings, BulkUpsertSettings: typeof YdbBulkUpsertSettings, Ydb: typeof import("ydb-sdk-proto").Ydb;
-export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, BulkUpsertSettings, Ydb, };
+declare const Types: typeof import("ydb-sdk").Types, TypedValues: typeof import("ydb-sdk").TypedValues, TableDescription: typeof import("ydb-sdk").TableDescription, Column: typeof import("ydb-sdk").Column, TableIndex: typeof import("ydb-sdk").TableIndex, AlterTableDescription: typeof import("ydb-sdk").AlterTableDescription, ExecuteQuerySettings: typeof YdbExecuteQuerySettings, BulkUpsertSettings: typeof YdbBulkUpsertSettings, Ydb: typeof import("ydb-sdk-proto").Ydb;
+export { Types, TypedValues, TableDescription, Column, TableIndex, AlterTableDescription, ExecuteQuerySettings, BulkUpsertSettings, Ydb, };
 export declare function createExecuteQuerySettings(options?: {
     keepInCache?: boolean;
     idempotent?: boolean;
@@ -26,6 +26,14 @@ export declare function __resetRefreshStateForTests(): void;
 export declare function configureDriver(config: DriverConfig): void;
 export declare function readyOrThrow(): Promise<void>;
 export declare function withSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
+/**
+ * Runs a callback in a single session without re-running the callback on session errors.
+ *
+ * Use this for multi-step callbacks where rerunning from the beginning would cause
+ * incorrect counters or repeated side effects. Prefer `withSession()` for single-shot
+ * operations to auto-retry on BadSession/SessionBusy via ydb-sdk.
+ */
+export declare function withSessionOnce<T>(fn: (s: Session) => Promise<T>): Promise<T>;
 export declare function withQuerySession<T>(fn: (s: QuerySession) => Promise<T>, options?: {
     timeoutMs?: number;
     idempotent?: boolean;

package/dist/ydb/client.js

@@ -1,9 +1,9 @@
 import { createRequire } from "module";
-import { YDB_DATABASE, YDB_ENDPOINT, SESSION_POOL_MIN_SIZE, SESSION_POOL_MAX_SIZE, SESSION_KEEPALIVE_PERIOD_MS, STARTUP_PROBE_SESSION_TIMEOUT_MS, } from "../config/env.js";
+import { SESSION_POOL_MIN_SIZE, SESSION_POOL_MAX_SIZE, SESSION_KEEPALIVE_PERIOD_MS, STARTUP_PROBE_SESSION_TIMEOUT_MS, YDB_SESSION_RETRY_MAX_RETRIES, TABLE_SESSION_TIMEOUT_MS, resolveYdbConnectionConfig, } from "../config/env.js";
 import { logger } from "../logging/logger.js";
 const require = createRequire(import.meta.url);
-const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, BulkUpsertSettings, OperationParams, Ydb, } = require("ydb-sdk");
-export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, BulkUpsertSettings, Ydb, };
+const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, TableIndex, AlterTableDescription, ExecuteQuerySettings, BulkUpsertSettings, OperationParams, Ydb, } = require("ydb-sdk");
+export { Types, TypedValues, TableDescription, Column, TableIndex, AlterTableDescription, ExecuteQuerySettings, BulkUpsertSettings, Ydb, };
 export function createExecuteQuerySettings(options) {
     const { keepInCache = true, idempotent = true } = options ?? {};
     const settings = new ExecuteQuerySettings();
@@ -36,9 +36,9 @@ export function createBulkUpsertSettingsWithTimeout(options) {
     return settings;
 }
 const DRIVER_READY_TIMEOUT_MS = 15000;
-const TABLE_SESSION_TIMEOUT_MS = 20000;
 const YDB_HEALTHCHECK_READY_TIMEOUT_MS = 5000;
 const DRIVER_REFRESH_COOLDOWN_MS = 30000;
+const DRIVER_DESTROY_GRACE_PERIOD_MS = TABLE_SESSION_TIMEOUT_MS + 5000;
 let overrideConfig;
 let driver;
 let lastDriverRefreshAt = 0;
@@ -50,8 +50,8 @@ export function isCompilationTimeoutError(error) {
         return false;
     }
     const msg = error.message ?? "";
-    if (/Timeout \(code 400090\)/i.test(msg) ||
-        /Query compilation timed out/i.test(msg)) {
+    if (/Query compilation timed out/i.test(msg) ||
+        (/Timeout \(code 400090\)/i.test(msg) && /compilation/i.test(msg))) {
         return true;
     }
     // Startup probe uses explicit cancel-after; YDB returns Cancelled with
@@ -130,17 +130,13 @@ export function configureDriver(config) {
     }
     overrideConfig = config;
 }
-function getOrCreateDriver() {
-    if (driver) {
-        return driver;
-    }
-    const base = overrideConfig?.connectionString != null
-        ? { connectionString: overrideConfig.connectionString }
-        : {
-            endpoint: overrideConfig?.endpoint ?? YDB_ENDPOINT,
-            database: overrideConfig?.database ?? YDB_DATABASE,
-        };
-    const driverConfig = {
+function getDriverConfig() {
+    const base = resolveYdbConnectionConfig({
+        endpoint: overrideConfig?.endpoint,
+        database: overrideConfig?.database,
+        connectionString: overrideConfig?.connectionString,
+    });
+    return {
         ...base,
         authService: overrideConfig?.authService ?? getCredentialsFromEnv(),
         poolSettings: {
@@ -149,7 +145,10 @@ function getOrCreateDriver() {
             keepAlivePeriod: SESSION_KEEPALIVE_PERIOD_MS,
         },
     };
-    driver = driverFactoryOverride
+}
+function createDriverInstance() {
+    const driverConfig = getDriverConfig();
+    const created = driverFactoryOverride
         ? driverFactoryOverride(driverConfig)
         : new Driver(driverConfig);
     logger.info({
@@ -157,6 +156,13 @@ function getOrCreateDriver() {
         poolMaxSize: SESSION_POOL_MAX_SIZE,
         keepAlivePeriodMs: SESSION_KEEPALIVE_PERIOD_MS,
     }, "YDB driver created with session pool settings");
+    return created;
+}
+function getOrCreateDriver() {
+    if (driver) {
+        return driver;
+    }
+    driver = createDriverInstance();
     return driver;
 }
 export async function readyOrThrow() {
@@ -167,6 +173,23 @@ export async function readyOrThrow() {
     }
 }
 export async function withSession(fn) {
+    const d = getOrCreateDriver();
+    try {
+        return await d.tableClient.withSessionRetry(fn, TABLE_SESSION_TIMEOUT_MS, YDB_SESSION_RETRY_MAX_RETRIES);
+    }
+    catch (err) {
+        void maybeRefreshDriverOnSessionError(err);
+        throw err;
+    }
+}
+/**
+ * Runs a callback in a single session without re-running the callback on session errors.
+ *
+ * Use this for multi-step callbacks where rerunning from the beginning would cause
+ * incorrect counters or repeated side effects. Prefer `withSession()` for single-shot
+ * operations to auto-retry on BadSession/SessionBusy via ydb-sdk.
+ */
+export async function withSessionOnce(fn) {
     const d = getOrCreateDriver();
     try {
         return await d.tableClient.withSession(fn, TABLE_SESSION_TIMEOUT_MS);
@@ -194,7 +217,7 @@ export async function withQuerySession(fn, options) {
 export async function withStartupProbeSession(fn) {
     const d = getOrCreateDriver();
     try {
-        return await d.tableClient.withSession(fn, STARTUP_PROBE_SESSION_TIMEOUT_MS);
+        return await d.tableClient.withSessionRetry(fn, STARTUP_PROBE_SESSION_TIMEOUT_MS, YDB_SESSION_RETRY_MAX_RETRIES);
     }
     catch (err) {
         void maybeRefreshDriverOnSessionError(err);
@@ -219,13 +242,14 @@ export async function destroyDriver() {
         return;
     }
     logger.info("Destroying YDB driver and session pool");
+    const toDestroy = driver;
+    driver = undefined;
     try {
-        await driver.destroy();
+        await toDestroy.destroy();
     }
     catch (err) {
         logger.warn({ err }, "Error during driver destruction (ignored)");
     }
-    driver = undefined;
 }
 /**
  * Destroys the current driver and immediately creates a fresh one.
@@ -233,7 +257,42 @@ export async function destroyDriver() {
  */
 export async function refreshDriver() {
     logger.info("Refreshing YDB driver");
-    await destroyDriver();
-    await readyOrThrow();
-    logger.info("YDB driver refreshed successfully");
+    const oldDriver = driver;
+    const newDriver = createDriverInstance();
+    let ok;
+    try {
+        ok = await newDriver.ready(DRIVER_READY_TIMEOUT_MS);
+    }
+    catch (err) {
+        try {
+            await newDriver.destroy();
+        }
+        catch (destroyErr) {
+            logger.warn({ err: destroyErr }, "Error during fresh driver destruction after failed ready() (ignored)");
+        }
+        throw err;
+    }
+    if (!ok) {
+        try {
+            await newDriver.destroy();
+        }
+        catch (err) {
+            logger.warn({ err }, "Error during fresh driver destruction after failed ready() (ignored)");
+        }
+        throw new Error(`YDB driver is not ready in ${DRIVER_READY_TIMEOUT_MS / 1000}s. Check connectivity and credentials.`);
+    }
+    driver = newDriver;
+    logger.info({ gracePeriodMs: DRIVER_DESTROY_GRACE_PERIOD_MS }, "YDB driver swapped successfully; scheduling old driver destruction");
+    if (oldDriver) {
+        setTimeout(() => {
+            void (async () => {
+                try {
+                    await oldDriver.destroy();
+                }
+                catch (err) {
+                    logger.warn({ err }, "Error during delayed old driver destruction (ignored)");
+                }
+            })();
+        }, DRIVER_DESTROY_GRACE_PERIOD_MS);
+    }
 }

package/dist/ydb/helpers.d.ts

@@ -1,4 +1,3 @@
 export declare function buildVectorBinaryParams(vector: number[]): {
     float: Buffer<ArrayBufferLike>;
-    bit: Buffer<ArrayBufferLike>;
 };

package/dist/ydb/helpers.js

@@ -1,7 +1,6 @@
-import { vectorToFloatBinary, vectorToBitBinary, } from "../utils/vectorBinary.js";
+import { vectorToFloatBinary } from "../utils/vectorBinary.js";
 export function buildVectorBinaryParams(vector) {
     return {
         float: vectorToFloatBinary(vector),
-        bit: vectorToBitBinary(vector),
     };
 }

package/dist/ydb/schema.d.ts

@@ -1,4 +1,6 @@
 export declare const GLOBAL_POINTS_TABLE = "qdrant_all_points";
+export declare const POINTS_BY_FILE_LOOKUP_TABLE = "qdrant_points_by_file";
 export { UPSERT_BATCH_SIZE } from "../config/env.js";
 export declare function ensureMetaTable(): Promise<void>;
 export declare function ensureGlobalPointsTable(): Promise<void>;
+export declare function ensurePointsByFileTable(): Promise<void>;