ydb-qdrant 7.0.1 → 8.1.0

package/dist/routes/collections.js

@@ -3,67 +3,15 @@ import { putCollectionIndex, createCollection, getCollection, deleteCollection,
 import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
 export const collectionsRouter = Router();
-// Placeholder defaults to satisfy Qdrant `CollectionInfo` shape. These values are
-// not used for execution in ydb-qdrant, only for client compatibility.
-const DEFAULT_HNSW_CONFIG = {
-    m: 16,
-    ef_construct: 100,
-    full_scan_threshold: 10000,
-    max_indexing_threads: 0,
-    on_disk: false,
-};
-const DEFAULT_OPTIMIZERS_CONFIG = {
-    deleted_threshold: 0.2,
-    vacuum_min_vector_number: 1000,
-    default_segment_number: 0,
-    indexing_threshold: 10000,
-    flush_interval_sec: 5,
-};
-function mapVectorDatatype(dataType) {
-    // Our service exposes `float`; Qdrant uses `float32`/`float16`/`uint8`.
-    if (dataType === "float16")
-        return "float16";
-    if (dataType === "uint8")
-        return "uint8";
-    return "float32";
-}
-function toQdrantCollectionInfo(result) {
-    const vectors = result.vectors;
-    const datatype = mapVectorDatatype(vectors?.data_type);
-    const config = {
-        params: {
-            vectors: {
-                size: vectors.size,
-                distance: vectors.distance,
-                datatype,
-                on_disk: false,
-            },
-            shard_number: 1,
-            replication_factor: 1,
-            write_consistency_factor: 1,
-            on_disk_payload: false,
-        },
-        hnsw_config: DEFAULT_HNSW_CONFIG,
-        optimizer_config: DEFAULT_OPTIMIZERS_CONFIG,
-    };
-    return {
-        status: "green",
-        optimizer_status: "ok",
-        segments_count: 1,
-        config,
-        payload_schema: {},
-    };
-}
 collectionsRouter.put("/:collection/index", async (req, res) => {
     try {
-        await putCollectionIndex({
+        const result = await putCollectionIndex({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         });
-        // Qdrant compatibility: index operations return boolean `result`.
-        res.json({ status: "ok", result: true });
+        res.json({ status: "ok", result });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -76,14 +24,13 @@ collectionsRouter.put("/:collection/index", async (req, res) => {
 });
 collectionsRouter.put("/:collection", async (req, res) => {
     try {
-        await createCollection({
+        const result = await createCollection({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         }, req.body);
-        // Qdrant compatibility: create collection returns boolean `result`.
-        res.json({ status: "ok", result: true });
+        res.json({ status: "ok", result });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -102,7 +49,7 @@ collectionsRouter.get("/:collection", async (req, res) => {
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         });
-        res.json({ status: "ok", result: toQdrantCollectionInfo(result) });
+        res.json({ status: "ok", result });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -115,14 +62,13 @@ collectionsRouter.get("/:collection", async (req, res) => {
 });
 collectionsRouter.delete("/:collection", async (req, res) => {
     try {
-        await deleteCollection({
+        const result = await deleteCollection({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         });
-        // Qdrant compatibility: delete collection returns boolean `result`.
-        res.json({ status: "ok", result: true });
+        res.json({ status: "ok", result });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {

package/dist/routes/points.js

@@ -2,18 +2,17 @@ import { Router } from "express";
 import { upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/PointsService.js";
 import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
-import { SEARCH_OPERATION_TIMEOUT_MS, UPSERT_OPERATION_TIMEOUT_MS, } from "../config/env.js";
-import { getAbortErrorCause, isCompilationTimeoutError, isTimeoutAbortError, } from "../ydb/client.js";
+import { isCompilationTimeoutError } from "../ydb/client.js";
 import { scheduleExit } from "../utils/exit.js";
 export const pointsRouter = Router();
-function toQdrantScoredPoint(hit) {
-    // Qdrant's ScoredPoint includes a mandatory `version`.
-    // We don't track versions; emit a stable default.
+function toQdrantScoredPoint(p) {
+    // We don't currently track per-point versions or return vectors/shard keys,
+    // but many Qdrant clients expect these fields to exist in the response.
     return {
-        id: hit.id,
+        id: p.id,
         version: 0,
-        score: hit.score,
-        payload: hit.payload ?? null,
+        score: p.score,
+        payload: p.payload ?? null,
         vector: null,
         shard_key: null,
         order_value: null,
@@ -41,17 +40,6 @@ pointsRouter.put("/:collection/points", async (req, res) => {
             scheduleExit(1);
             return;
         }
-        if (isTimeoutAbortError(err)) {
-            logger.error({
-                err,
-                errCause: getAbortErrorCause(err),
-                timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
-            }, "YDB upsert operation timed out");
-            return res.status(500).json({
-                status: "error",
-                error: `upsert operation timed out after ${UPSERT_OPERATION_TIMEOUT_MS}ms`,
-            });
-        }
         logger.error({ err }, "upsert points (PUT) failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
@@ -77,35 +65,19 @@ pointsRouter.post("/:collection/points/upsert", async (req, res) => {
             scheduleExit(1);
             return;
         }
-        if (isTimeoutAbortError(err)) {
-            logger.error({
-                err,
-                errCause: getAbortErrorCause(err),
-                timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
-            }, "YDB upsert operation timed out");
-            return res.status(500).json({
-                status: "error",
-                error: `upsert operation timed out after ${UPSERT_OPERATION_TIMEOUT_MS}ms`,
-            });
-        }
         logger.error({ err }, "upsert points failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
 });
 pointsRouter.post("/:collection/points/search", async (req, res) => {
     try {
-        const result = await searchPoints({
+        const { points } = await searchPoints({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         }, req.body);
-        // Qdrant compatibility: REST API returns `result` as an array of points.
-        // Keep service return shape internal (`{ points: [...] }`).
-        res.json({
-            status: "ok",
-            result: result.points.map(toQdrantScoredPoint),
-        });
+        res.json({ status: "ok", result: points.map(toQdrantScoredPoint) });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -118,17 +90,6 @@ pointsRouter.post("/:collection/points/search", async (req, res) => {
             scheduleExit(1);
             return;
         }
-        if (isTimeoutAbortError(err)) {
-            logger.error({
-                err,
-                errCause: getAbortErrorCause(err),
-                timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
-            }, "YDB search operation timed out");
-            return res.status(500).json({
-                status: "error",
-                error: `search operation timed out after ${SEARCH_OPERATION_TIMEOUT_MS}ms`,
-            });
-        }
         logger.error({ err }, "search points failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
@@ -136,18 +97,13 @@ pointsRouter.post("/:collection/points/search", async (req, res) => {
 // Compatibility: some clients call POST /collections/:collection/points/query
 pointsRouter.post("/:collection/points/query", async (req, res) => {
     try {
-        const result = await queryPoints({
+        const { points } = await queryPoints({
             tenant: req.header("X-Tenant-Id") ?? undefined,
             collection: String(req.params.collection),
             apiKey: req.header("api-key") ?? undefined,
             userAgent: req.header("User-Agent") ?? undefined,
         }, req.body);
-        // Qdrant compatibility: /points/query returns `result` as an object.
-        // (Unlike /points/search, where result is a list.)
-        const qdrantResult = {
-            points: result.points.map(toQdrantScoredPoint),
-        };
-        res.json({ status: "ok", result: qdrantResult });
+        res.json({ status: "ok", result: points.map(toQdrantScoredPoint) });
     }
     catch (err) {
         if (err instanceof QdrantServiceError) {
@@ -160,17 +116,6 @@ pointsRouter.post("/:collection/points/query", async (req, res) => {
             scheduleExit(1);
             return;
         }
-        if (isTimeoutAbortError(err)) {
-            logger.error({
-                err,
-                errCause: getAbortErrorCause(err),
-                timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
-            }, "YDB search operation timed out");
-            return res.status(500).json({
-                status: "error",
-                error: `search operation timed out after ${SEARCH_OPERATION_TIMEOUT_MS}ms`,
-            });
-        }
         logger.error({ err }, "search points (query) failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }

package/dist/services/PointsService.d.ts

@@ -1,19 +1,14 @@
 import { type CollectionContextInput } from "./CollectionService.js";
-import type { QdrantPayload } from "../qdrant/QdrantTypes.js";
+import type { YdbQdrantScoredPoint } from "../qdrant/QdrantRestTypes.js";
 type PointsContextInput = CollectionContextInput;
-type InternalScoredPoint = {
-    id: string;
-    score: number;
-    payload?: QdrantPayload;
-};
 export declare function upsertPoints(ctx: PointsContextInput, body: unknown): Promise<{
     upserted: number;
 }>;
 export declare function searchPoints(ctx: PointsContextInput, body: unknown): Promise<{
-    points: InternalScoredPoint[];
+    points: YdbQdrantScoredPoint[];
 }>;
 export declare function queryPoints(ctx: PointsContextInput, body: unknown): Promise<{
-    points: InternalScoredPoint[];
+    points: YdbQdrantScoredPoint[];
 }>;
 export declare function deletePoints(ctx: PointsContextInput, body: unknown): Promise<{
     deleted: number;

package/dist/services/PointsService.js

@@ -7,31 +7,29 @@ import { QdrantServiceError, isVectorDimensionMismatchError, } from "./errors.js
 import { normalizeCollectionContextShared } from "./CollectionService.shared.js";
 import { resolvePointsTableAndUidOneTable } from "./CollectionService.one-table.js";
 import { normalizeSearchBodyForSearch, normalizeSearchBodyForQuery, } from "../utils/normalization.js";
-import { isRecord } from "../utils/typeGuards.js";
 function parsePathSegmentsFilterToPaths(filter) {
     const extractMust = (must) => {
         if (!Array.isArray(must) || must.length === 0)
             return null;
         const pairs = [];
         for (const cond of must) {
-            if (!isRecord(cond))
+            if (typeof cond !== "object" || cond === null)
                 return null;
-            const key = cond.key;
-            if (typeof key !== "string")
+            const c = cond;
+            if (typeof c.key !== "string")
                 return null;
-            const m = /^pathSegments\.(\d+)$/.exec(key);
+            const m = /^pathSegments\.(\d+)$/.exec(c.key);
             if (!m)
                 return null;
             const idx = Number(m[1]);
             if (!Number.isInteger(idx) || idx < 0)
                 return null;
-            const match = cond.match;
-            if (!isRecord(match))
+            if (typeof c.match !== "object" || c.match === null)
                 return null;
-            const value = match.value;
-            if (typeof value !== "string")
+            const match = c.match;
+            if (typeof match.value !== "string")
                 return null;
-            pairs.push({ idx, value });
+            pairs.push({ idx, value: match.value });
         }
         pairs.sort((a, b) => a.idx - b.idx);
         // Require contiguous indexes starting from 0 to avoid ambiguous matches.
@@ -41,22 +39,22 @@ function parsePathSegmentsFilterToPaths(filter) {
         }
         return pairs.map((p) => p.value);
     };
-    if (!isRecord(filter))
+    if (typeof filter !== "object" || filter === null)
         return null;
-    const must = filter.must;
-    if (must !== undefined) {
-        const path = extractMust(must);
+    const f = filter;
+    if (f.must !== undefined) {
+        const path = extractMust(f.must);
         return path ? [path] : null;
     }
-    const should = filter.should;
-    if (should !== undefined) {
-        if (!Array.isArray(should) || should.length === 0)
+    if (f.should !== undefined) {
+        if (!Array.isArray(f.should) || f.should.length === 0)
             return null;
         const paths = [];
-        for (const g of should) {
-            if (!isRecord(g))
+        for (const g of f.should) {
+            if (typeof g !== "object" || g === null)
                 return null;
-            const path = extractMust(g.must);
+            const group = g;
+            const path = extractMust(group.must);
             if (!path)
                 return null;
             paths.push(path);
@@ -85,9 +83,7 @@ export async function upsertPoints(ctx, body) {
     const { tableName, uid } = await resolvePointsTableAndUidOneTable(normalized);
     let upserted;
     try {
-        // Narrow Qdrant OpenAPI types to the dense-vector subset we support.
-        const points = parsed.data.points;
-        upserted = await repoUpsertPoints(tableName, points, meta.dimension, uid);
+        upserted = await repoUpsertPoints(tableName, parsed.data.points, meta.dimension, uid);
     }
     catch (err) {
         if (isVectorDimensionMismatchError(err)) {

package/dist/types.d.ts

@@ -1,18 +1,9 @@
 import { z } from "zod";
-import type { QdrantDistance, QdrantPointId, QdrantDenseVector } from "./qdrant/QdrantTypes.js";
-export declare const DistanceKindSchema: z.ZodEnum<{
-    Cosine: "Cosine";
-    Euclid: "Euclid";
-    Dot: "Dot";
-    Manhattan: "Manhattan";
-}>;
+import type { QdrantDistance, QdrantPayload, QdrantWithPayloadInterface, YdbQdrantPointId, YdbQdrantUpsertPoint } from "./qdrant/QdrantRestTypes.js";
 export type DistanceKind = QdrantDistance;
-export declare const VectorTypeSchema: z.ZodLiteral<"float">;
-export type VectorType = z.infer<typeof VectorTypeSchema>;
-export declare const PointIdSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-export type PointId = QdrantPointId;
-export declare const DenseVectorSchema: z.ZodArray<z.ZodNumber>;
-export type DenseVector = QdrantDenseVector;
+export type VectorType = "float";
+export type Payload = QdrantPayload;
+export type WithPayload = QdrantWithPayloadInterface;
 /**
  * Collection metadata from qdr__collections table.
  *
@@ -29,34 +20,37 @@ export interface CollectionMeta {
 export declare const CreateCollectionReq: z.ZodObject<{
     vectors: z.ZodObject<{
         size: z.ZodNumber;
-        distance: z.ZodEnum<{
-            Cosine: "Cosine";
-            Euclid: "Euclid";
-            Dot: "Dot";
-            Manhattan: "Manhattan";
-        }>;
-        data_type: z.ZodOptional<z.ZodLiteral<"float">>;
+        distance: z.ZodType<DistanceKind>;
+        data_type: z.ZodOptional<z.ZodEnum<{
+            float: "float";
+        }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const UpsertPointSchema: z.ZodObject<{
-    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    vector: z.ZodArray<z.ZodNumber>;
-    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
 export declare const UpsertPointsReq: z.ZodObject<{
     points: z.ZodArray<z.ZodObject<{
-        id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        id: z.ZodType<YdbQdrantPointId>;
         vector: z.ZodArray<z.ZodNumber>;
-        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        payload: z.ZodType<Payload | undefined>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+export type UpsertPoint = YdbQdrantUpsertPoint;
+export type UpsertPointsBody = {
+    points: UpsertPoint[];
+};
 export declare const SearchReq: z.ZodObject<{
     vector: z.ZodArray<z.ZodNumber>;
     top: z.ZodNumber;
     with_payload: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
+export type SearchPointsBody = {
+    vector: number[];
+    top?: number;
+    limit?: number;
+    with_payload?: WithPayload;
+    score_threshold?: number | null;
+};
 export declare const DeletePointsByIdsReq: z.ZodObject<{
-    points: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    points: z.ZodArray<z.ZodType<YdbQdrantPointId, unknown, z.core.$ZodTypeInternals<YdbQdrantPointId, unknown>>>;
 }, z.core.$strip>;
 export declare const DeletePointsByFilterReq: z.ZodObject<{
     filter: z.ZodUnion<readonly [z.ZodObject<{
@@ -78,7 +72,7 @@ export declare const DeletePointsByFilterReq: z.ZodObject<{
     }, z.core.$strip>]>;
 }, z.core.$strip>;
 export declare const DeletePointsReq: z.ZodUnion<readonly [z.ZodObject<{
-    points: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    points: z.ZodArray<z.ZodType<YdbQdrantPointId, unknown, z.core.$ZodTypeInternals<YdbQdrantPointId, unknown>>>;
 }, z.core.$strip>, z.ZodObject<{
     filter: z.ZodUnion<readonly [z.ZodObject<{
         must: z.ZodArray<z.ZodObject<{
@@ -98,7 +92,3 @@ export declare const DeletePointsReq: z.ZodUnion<readonly [z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>]>;
 }, z.core.$strip>]>;
-export type CreateCollectionBody = z.infer<typeof CreateCollectionReq>;
-export type UpsertPointsBody = z.infer<typeof UpsertPointsReq>;
-export type SearchBody = z.infer<typeof SearchReq>;
-export type DeletePointsBody = z.infer<typeof DeletePointsReq>;

package/dist/types.js

@@ -1,36 +1,34 @@
 import { z } from "zod";
-const DISTANCE_KIND_VALUES = [
-    "Cosine",
-    "Euclid",
-    "Dot",
-    "Manhattan",
-];
-export const DistanceKindSchema = z.enum(DISTANCE_KIND_VALUES);
-export const VectorTypeSchema = z.literal("float");
-export const PointIdSchema = z.union([z.string(), z.number()]);
-export const DenseVectorSchema = z.array(z.number());
 export const CreateCollectionReq = z.object({
     vectors: z.object({
         size: z.number().int().positive(),
-        distance: DistanceKindSchema,
-        data_type: VectorTypeSchema.optional(),
+        distance: z.enum([
+            "Cosine",
+            "Euclid",
+            "Dot",
+            "Manhattan",
+        ]),
+        data_type: z.enum(["float"]).optional(),
     }),
 });
-export const UpsertPointSchema = z.object({
-    id: PointIdSchema,
-    vector: DenseVectorSchema,
-    payload: z.record(z.string(), z.unknown()).optional(),
-});
 export const UpsertPointsReq = z.object({
-    points: z.array(UpsertPointSchema).min(1),
+    points: z
+        .array(z.object({
+        id: z.union([z.string(), z.number()]),
+        vector: z.array(z.number()),
+        payload: z.record(z.string(), z.unknown()).optional(),
+    }))
+        .min(1),
 });
 export const SearchReq = z.object({
-    vector: DenseVectorSchema.min(1),
+    vector: z.array(z.number()).min(1),
     top: z.number().int().positive().max(1000),
     with_payload: z.boolean().optional(),
 });
 export const DeletePointsByIdsReq = z.object({
-    points: z.array(PointIdSchema).min(1),
+    points: z
+        .array(z.union([z.string(), z.number()]))
+        .min(1),
 });
 const DeletePointsFilterCondition = z.object({
     key: z.string(),

package/dist/utils/normalization.js

@@ -1,9 +1,8 @@
-import { isRecord } from "./typeGuards.js";
 export function isNumberArray(value) {
     return Array.isArray(value) && value.every((x) => typeof x === "number");
 }
 export function extractVectorLoose(body, depth = 0) {
-    if (!isRecord(body) || depth > 3) {
+    if (!body || typeof body !== "object" || depth > 3) {
         return undefined;
     }
     const obj = body;
@@ -11,17 +10,17 @@ export function extractVectorLoose(body, depth = 0) {
         return obj.vector;
     if (isNumberArray(obj.embedding))
         return obj.embedding;
-    const query = isRecord(obj.query) ? obj.query : undefined;
+    const query = obj.query;
     if (query) {
-        const queryVector = query.vector;
+        const queryVector = query["vector"];
         if (isNumberArray(queryVector))
             return queryVector;
-        const nearest = isRecord(query.nearest) ? query.nearest : undefined;
+        const nearest = query["nearest"];
         if (nearest && isNumberArray(nearest.vector)) {
             return nearest.vector;
         }
     }
-    const nearest = isRecord(obj.nearest) ? obj.nearest : undefined;
+    const nearest = obj.nearest;
     if (nearest && isNumberArray(nearest.vector)) {
         return nearest.vector;
     }
@@ -43,7 +42,7 @@ export function extractVectorLoose(body, depth = 0) {
     return undefined;
 }
 export function normalizeSearchBodyForSearch(body) {
-    if (!isRecord(body)) {
+    if (!body || typeof body !== "object") {
         return {
             vector: undefined,
             top: undefined,
@@ -52,12 +51,12 @@ export function normalizeSearchBodyForSearch(body) {
         };
     }
     const b = body;
-    const rawVector = b.vector;
+    const rawVector = b["vector"];
     const vector = isNumberArray(rawVector) ? rawVector : undefined;
     return normalizeSearchCommon(b, vector);
 }
 export function normalizeSearchBodyForQuery(body) {
-    if (!isRecord(body)) {
+    if (!body || typeof body !== "object") {
         return {
             vector: undefined,
             top: undefined,
@@ -70,14 +69,14 @@ export function normalizeSearchBodyForQuery(body) {
     return normalizeSearchCommon(b, vector);
 }
 function normalizeSearchCommon(b, vector) {
-    const rawTop = b.top;
-    const rawLimit = b.limit;
+    const rawTop = b["top"];
+    const rawLimit = b["limit"];
     const topFromTop = typeof rawTop === "number" ? rawTop : undefined;
     const topFromLimit = typeof rawLimit === "number" ? rawLimit : undefined;
     const top = topFromTop ?? topFromLimit;
-    const filter = b.filter;
+    const filter = b["filter"];
     let withPayload;
-    const rawWithPayload = b.with_payload;
+    const rawWithPayload = b["with_payload"];
     if (typeof rawWithPayload === "boolean") {
         withPayload = rawWithPayload;
     }
@@ -85,7 +84,7 @@ function normalizeSearchCommon(b, vector) {
         typeof rawWithPayload === "object") {
         withPayload = true;
     }
-    const thresholdRaw = b.score_threshold;
+    const thresholdRaw = b["score_threshold"];
     const thresholdValue = typeof thresholdRaw === "number" ? thresholdRaw : Number(thresholdRaw);
     const scoreThreshold = Number.isFinite(thresholdValue)
         ? thresholdValue

package/dist/utils/retry.js

@@ -1,5 +1,4 @@
 import { logger } from "../logging/logger.js";
-import { retry as ydbRetry } from "@ydbjs/retry";
 const DEFAULT_MAX_RETRIES = 6;
 const DEFAULT_BASE_DELAY_MS = 250;
 export function isTransientYdbError(error) {
@@ -23,35 +22,26 @@ export async function withRetry(fn, options = {}) {
     const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
     const isTransient = options.isTransient ?? isTransientYdbError;
     const context = options.context ?? {};
-    // We keep the public API in terms of `maxRetries`, but @ydbjs/retry uses a budget
-    // in terms of total attempts. Convert retries→attempts.
-    const attemptsBudget = Math.max(0, maxRetries) + 1;
-    const delayByAttempt = new Map();
-    return await ydbRetry({
-        budget: attemptsBudget,
-        retry: (error) => isTransient(error),
-        strategy: (ctx) => {
-            // Preserve previous backoff shape: baseDelayMs * 2^attemptIndex + jitter(0..100)
-            // where attemptIndex started at 0 for the first retry.
-            const attemptIndex = Math.max(0, ctx.attempt - 1);
-            const delayMs = Math.floor(baseDelayMs * Math.pow(2, attemptIndex) + Math.random() * 100);
-            delayByAttempt.set(ctx.attempt, delayMs);
-            return delayMs;
-        },
-        onRetry: (ctx) => {
-            const attemptIndex = Math.max(0, ctx.attempt - 1);
+    let attempt = 0;
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (!isTransient(e) || attempt >= maxRetries) {
+                throw e;
+            }
+            const backoffMs = Math.floor(baseDelayMs * Math.pow(2, attempt) + Math.random() * 100);
             logger.warn({
                 ...context,
-                attempt: attemptIndex,
-                backoffMs: delayByAttempt.get(ctx.attempt),
-                err: ctx.error instanceof Error
-                    ? ctx.error
-                    : new Error(typeof ctx.error === "string"
-                        ? ctx.error
-                        : JSON.stringify(ctx.error)),
+                attempt,
+                backoffMs,
+                err: e instanceof Error
+                    ? e
+                    : new Error(typeof e === "string" ? e : JSON.stringify(e)),
             }, "operation aborted due to transient error; retrying");
-        },
-    }, async () => {
-        return await fn();
-    });
+            await new Promise((r) => setTimeout(r, backoffMs));
+            attempt += 1;
+        }
+    }
 }