ydb-qdrant 8.1.1 → 9.0.3

package/dist/routes/points.js

@@ -1,10 +1,37 @@
 import { Router } from "express";
-import { upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/PointsService.js";
+import { upsertPoints, searchPoints, queryPoints, deletePoints, retrievePoints, } from "../services/PointsService.js";
 import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
 import { isCompilationTimeoutError } from "../ydb/client.js";
 import { scheduleExit } from "../utils/exit.js";
+import { isUpsertRequestTimedOut } from "../middleware/upsertRequestTimeout.js";
+import { qdrantResponse } from "../utils/qdrantResponse.js";
+import { elapsedMsSince, getElapsedMsSinceRequestStart, getMonotonicTimeNs, } from "../logging/requestContext.js";
+import { isAnonymousIdentityError, resolveRequestNamespaceUserUid, resolveRequestSigningKey, } from "../utils/requestIdentity.js";
 export const pointsRouter = Router();
+function buildPointsContext(req) {
+    const userUid = resolveRequestNamespaceUserUid(req);
+    return {
+        userUid,
+        collection: String(req.params.collection),
+        apiKey: resolveRequestSigningKey(req, userUid),
+        userAgent: req.header("User-Agent") ?? undefined,
+    };
+}
+function shouldSkipResponse(req, res) {
+    return res.headersSent || res.writableEnded || isUpsertRequestTimedOut(req);
+}
+function sendKnownRouteError(res, err) {
+    if (err instanceof QdrantServiceError) {
+        res.status(err.statusCode).json(err.payload);
+        return true;
+    }
+    if (isAnonymousIdentityError(err)) {
+        res.status(400).json({ status: "error", error: err.message });
+        return true;
+    }
+    return false;
+}
 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.
@@ -18,51 +45,123 @@ function toQdrantScoredPoint(p) {
         order_value: null,
     };
 }
+function logUpsertHandlerEntry(alias) {
+    logger.info({
+        phase: "upsertEntry",
+        alias,
+        timeToHandlerMs: getElapsedMsSinceRequestStart(),
+    }, "upsert: handler entry");
+}
+function logUpsertFailure(args) {
+    if (args.err instanceof QdrantServiceError ||
+        isAnonymousIdentityError(args.err)) {
+        return;
+    }
+    logger.error({
+        err: args.err instanceof Error
+            ? args.err
+            : new Error(String(args.err)),
+        phase: "upsertFailed",
+        alias: args.alias,
+        routeElapsedMs: elapsedMsSince(args.routeStartNs),
+        timeToHandlerMs: getElapsedMsSinceRequestStart(),
+    }, "upsert: failed");
+}
+// Qdrant-compatible: POST /collections/:collection/points (retrieve by IDs)
+pointsRouter.post("/:collection/points", async (req, res) => {
+    const start = process.hrtime();
+    try {
+        const { points } = await retrievePoints(buildPointsContext(req), req.body);
+        const result = points.map((p) => ({
+            id: p.id,
+            version: 0,
+            payload: p.payload,
+            vector: null,
+            shard_key: null,
+            order_value: null,
+        }));
+        res.json(qdrantResponse(result, start));
+    }
+    catch (err) {
+        if (sendKnownRouteError(res, err)) {
+            return;
+        }
+        logger.error({ err }, "retrieve points failed");
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        res.status(500).json({ status: "error", error: errorMessage });
+    }
+});
+// Fix #6: Upsert → UpdateResult shape
 // Qdrant-compatible: PUT /collections/:collection/points (upsert)
 pointsRouter.put("/:collection/points", async (req, res) => {
+    const start = process.hrtime();
+    const routeStartNs = getMonotonicTimeNs();
     try {
-        const result = await upsertPoints({
-            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);
-        res.json({ status: "ok", result });
+        logUpsertHandlerEntry("put");
+        if (shouldSkipResponse(req, res)) {
+            return;
+        }
+        await upsertPoints(buildPointsContext(req), req.body);
+        if (shouldSkipResponse(req, res)) {
+            return;
+        }
+        res.json(qdrantResponse({ operation_id: 0, status: "completed" }, start));
     }
     catch (err) {
-        if (err instanceof QdrantServiceError) {
-            return res.status(err.statusCode).json(err.payload);
-        }
+        logUpsertFailure({ alias: "put", routeStartNs, err });
         const errorMessage = err instanceof Error ? err.message : String(err);
-        if (isCompilationTimeoutError(err)) {
-            logger.error({ err }, "YDB compilation error during upsert points (PUT); scheduling process exit");
-            res.status(500).json({ status: "error", error: errorMessage });
+        const isCompilationTimeout = isCompilationTimeoutError(err);
+        if (isCompilationTimeout) {
+            logger.error({ err }, "YDB compilation timeout during upsert points (PUT); scheduling process exit");
             scheduleExit(1);
+            if (shouldSkipResponse(req, res)) {
+                return;
+            }
+            res.status(500).json({ status: "error", error: errorMessage });
+            return;
+        }
+        if (shouldSkipResponse(req, res)) {
+            return;
+        }
+        if (sendKnownRouteError(res, err)) {
             return;
         }
         logger.error({ err }, "upsert points (PUT) failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
 });
+// Fix #6: Upsert → UpdateResult shape
 pointsRouter.post("/:collection/points/upsert", async (req, res) => {
+    const start = process.hrtime();
+    const routeStartNs = getMonotonicTimeNs();
     try {
-        const result = await upsertPoints({
-            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);
-        res.json({ status: "ok", result });
+        logUpsertHandlerEntry("post");
+        if (shouldSkipResponse(req, res)) {
+            return;
+        }
+        await upsertPoints(buildPointsContext(req), req.body);
+        if (shouldSkipResponse(req, res)) {
+            return;
+        }
+        res.json(qdrantResponse({ operation_id: 0, status: "completed" }, start));
     }
     catch (err) {
-        if (err instanceof QdrantServiceError) {
-            return res.status(err.statusCode).json(err.payload);
-        }
+        logUpsertFailure({ alias: "post", routeStartNs, err });
         const errorMessage = err instanceof Error ? err.message : String(err);
-        if (isCompilationTimeoutError(err)) {
-            logger.error({ err }, "YDB compilation error during upsert points; scheduling process exit");
-            res.status(500).json({ status: "error", error: errorMessage });
+        const isCompilationTimeout = isCompilationTimeoutError(err);
+        if (isCompilationTimeout) {
+            logger.error({ err }, "YDB compilation timeout during upsert points; scheduling process exit");
             scheduleExit(1);
+            if (shouldSkipResponse(req, res)) {
+                return;
+            }
+            res.status(500).json({ status: "error", error: errorMessage });
+            return;
+        }
+        if (shouldSkipResponse(req, res)) {
+            return;
+        }
+        if (sendKnownRouteError(res, err)) {
             return;
         }
         logger.error({ err }, "upsert points failed");
@@ -70,22 +169,18 @@ pointsRouter.post("/:collection/points/upsert", async (req, res) => {
     }
 });
 pointsRouter.post("/:collection/points/search", async (req, res) => {
+    const start = process.hrtime();
     try {
-        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);
-        res.json({ status: "ok", result: points.map(toQdrantScoredPoint) });
+        const { points } = await searchPoints(buildPointsContext(req), req.body);
+        res.json(qdrantResponse(points.map(toQdrantScoredPoint), start));
     }
     catch (err) {
-        if (err instanceof QdrantServiceError) {
-            return res.status(err.statusCode).json(err.payload);
+        if (sendKnownRouteError(res, err)) {
+            return;
         }
         const errorMessage = err instanceof Error ? err.message : String(err);
         if (isCompilationTimeoutError(err)) {
-            logger.error({ err }, "YDB compilation error during search points; scheduling process exit");
+            logger.error({ err }, "YDB compilation timeout during search points; scheduling process exit");
             res.status(500).json({ status: "error", error: errorMessage });
             scheduleExit(1);
             return;
@@ -96,26 +191,19 @@ 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) => {
+    const start = process.hrtime();
     try {
-        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);
+        const { points } = await queryPoints(buildPointsContext(req), req.body);
         // Qdrant-compatible: /points/query returns QueryResponse with { points: ScoredPoint[] }.
-        res.json({
-            status: "ok",
-            result: { points: points.map(toQdrantScoredPoint) },
-        });
+        res.json(qdrantResponse({ points: points.map(toQdrantScoredPoint) }, start));
     }
     catch (err) {
-        if (err instanceof QdrantServiceError) {
-            return res.status(err.statusCode).json(err.payload);
+        if (sendKnownRouteError(res, err)) {
+            return;
         }
         const errorMessage = err instanceof Error ? err.message : String(err);
         if (isCompilationTimeoutError(err)) {
-            logger.error({ err }, "YDB compilation error during search points (query); scheduling process exit");
+            logger.error({ err }, "YDB compilation timeout during search points (query); scheduling process exit");
             res.status(500).json({ status: "error", error: errorMessage });
             scheduleExit(1);
             return;
@@ -124,19 +212,16 @@ pointsRouter.post("/:collection/points/query", async (req, res) => {
         res.status(500).json({ status: "error", error: errorMessage });
     }
 });
+// Fix #7: Delete → UpdateResult shape
 pointsRouter.post("/:collection/points/delete", async (req, res) => {
+    const start = process.hrtime();
     try {
-        const result = await deletePoints({
-            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);
-        res.json({ status: "ok", result });
+        await deletePoints(buildPointsContext(req), req.body);
+        res.json(qdrantResponse({ operation_id: 0, status: "completed" }, start));
     }
     catch (err) {
-        if (err instanceof QdrantServiceError) {
-            return res.status(err.statusCode).json(err.payload);
+        if (sendKnownRouteError(res, err)) {
+            return;
         }
         logger.error({ err }, "delete points failed");
         const errorMessage = err instanceof Error ? err.message : String(err);

package/dist/server.js

@@ -2,6 +2,8 @@ import express from "express";
 import { collectionsRouter } from "./routes/collections.js";
 import { pointsRouter } from "./routes/points.js";
 import { requestLogger } from "./middleware/requestLogger.js";
+import { isUpsertRequestTimedOut, upsertBodyTimeout, upsertProcessingTimeout, } from "./middleware/upsertRequestTimeout.js";
+import { instrumentUpsertRequestBody, logUpsertBodyPhase, logUpsertBodyPhaseError, verifyUpsertRequestBody, } from "./middleware/upsertBodyPhase.js";
 import { isYdbAvailable, isCompilationTimeoutError } from "./ydb/client.js";
 import { verifyCollectionsQueryCompilationForStartup } from "./repositories/collectionsRepo.js";
 import { logger } from "./logging/logger.js";
@@ -9,7 +11,7 @@ import { scheduleExit } from "./utils/exit.js";
 export async function healthHandler(_req, res) {
     const ok = await isYdbAvailable();
     if (!ok) {
-        logger.error("YDB unavailable during health check; scheduling process exit");
+        logger.error("YDB unavailable during health check");
         res.status(503).json({ status: "error", error: "YDB unavailable" });
         scheduleExit(1);
         return;
@@ -20,8 +22,8 @@ export async function healthHandler(_req, res) {
     catch (err) {
         const isTimeout = isCompilationTimeoutError(err);
         logger.error({ err }, isTimeout
-            ? "YDB compilation timeout during health probe; scheduling process exit"
-            : "YDB health probe failed; scheduling process exit");
+            ? "YDB compilation timeout during health probe"
+            : "YDB health probe failed");
         res.status(503).json({
             status: "error",
             error: "YDB health probe failed",
@@ -38,7 +40,15 @@ export function rootHandler(_req, res) {
 export function buildServer() {
     const app = express();
     app.use(requestLogger);
-    app.use(express.json({ limit: "20mb" }));
+    app.use(upsertBodyTimeout);
+    app.use(instrumentUpsertRequestBody);
+    app.use(express.json({
+        limit: "20mb",
+        verify: verifyUpsertRequestBody,
+    }));
+    app.use(logUpsertBodyPhaseError);
+    app.use(logUpsertBodyPhase);
+    app.use(upsertProcessingTimeout);
     app.get("/", rootHandler);
     app.get("/health", healthHandler);
     app.use("/collections", collectionsRouter);
@@ -57,12 +67,16 @@ export function buildServer() {
     });
     // Catch-all error handler: avoid Express default handler printing stacktraces to stderr
     // and provide consistent JSON error responses.
-    app.use((err, _req, res, _next) => {
-        logger.error({ err }, "Unhandled error in Express middleware");
+    app.use((err, req, res, _next) => {
         void _next;
         if (res.headersSent || res.writableEnded) {
+            if (shouldSuppressLateMiddlewareError(req, err)) {
+                return;
+            }
+            logger.error({ err }, "Late middleware error after response sent");
             return;
         }
+        logger.error({ err }, "Unhandled error in Express middleware");
         const statusCode = extractHttpStatusCode(err) ?? 500;
         const errorMessage = err instanceof Error ? err.message : String(err);
         res.status(statusCode).json({
@@ -85,6 +99,28 @@ function isRequestAbortedError(err) {
     }
     return false;
 }
+function isBodyParserRequestReadError(err) {
+    if (!err || typeof err !== "object") {
+        return false;
+    }
+    const typeValue = "type" in err && typeof err.type === "string" ? err.type : undefined;
+    if (!typeValue) {
+        return false;
+    }
+    return (typeValue === "entity.parse.failed" ||
+        typeValue === "entity.too.large" ||
+        typeValue === "request.size.invalid" ||
+        typeValue === "charset.unsupported" ||
+        typeValue === "encoding.unsupported" ||
+        typeValue === "stream.encoding.set" ||
+        typeValue === "stream.not.readable");
+}
+function shouldSuppressLateMiddlewareError(req, err) {
+    if (isRequestAbortedError(err)) {
+        return true;
+    }
+    return isUpsertRequestTimedOut(req) && isBodyParserRequestReadError(err);
+}
 function extractHttpStatusCode(err) {
     if (!err || typeof err !== "object") {
         return undefined;

package/dist/services/CollectionService.d.ts

@@ -1,23 +1,25 @@
-import { type DistanceKind } from "../types.js";
+import type { DistanceKind } from "../qdrant/QdrantRestTypes.js";
 export interface CollectionContextInput {
-    tenant: string | undefined;
+    userUid: string;
     collection: string;
-    apiKey?: string;
+    apiKey: string;
     userAgent?: string;
 }
 export interface NormalizedCollectionContext {
-    tenant: string;
+    userUid: string;
     collection: string;
     metaKey: string;
+    uid: string;
 }
 export declare function putCollectionIndex(ctx: CollectionContextInput): Promise<{
     acknowledged: boolean;
 }>;
 export declare function createCollection(ctx: CollectionContextInput, body: unknown): Promise<{
     name: string;
-    tenant: string;
 }>;
 export declare function getCollection(ctx: CollectionContextInput): Promise<{
+    status: string;
+    points_count: number;
     name: string;
     vectors: {
         size: number;

package/dist/services/CollectionService.js

@@ -1,11 +1,11 @@
-import { CreateCollectionReq } from "../types.js";
+import { CreateCollectionReq } from "../qdrant/Requests.js";
 import { ensureMetaTable } from "../ydb/schema.js";
-import { createCollection as repoCreateCollection, deleteCollection as repoDeleteCollection, getCollectionMeta, touchCollectionLastAccess, } from "../repositories/collectionsRepo.js";
+import { createCollection as repoCreateCollection, countPointsForCollection, deleteCollection as repoDeleteCollection, getCollectionMeta, touchCollectionLastAccess, } from "../repositories/collectionsRepo.js";
 import { QdrantServiceError } from "./errors.js";
 import { normalizeCollectionContextShared } from "./CollectionService.shared.js";
 export async function putCollectionIndex(ctx) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
+    const normalized = normalizeCollectionContextShared(ctx.userUid, ctx.collection, ctx.userAgent);
     const meta = await getCollectionMeta(normalized.metaKey);
     if (!meta) {
         throw new QdrantServiceError(404, {
@@ -18,7 +18,7 @@ export async function putCollectionIndex(ctx) {
 }
 export async function createCollection(ctx, body) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
+    const normalized = normalizeCollectionContextShared(ctx.userUid, ctx.collection, ctx.userAgent);
     const parsed = CreateCollectionReq.safeParse(body);
     if (!parsed.success) {
         throw new QdrantServiceError(400, {
@@ -35,7 +35,7 @@ export async function createCollection(ctx, body) {
             existing.distance === distance &&
             existing.vectorType === vectorType) {
             await touchCollectionLastAccess(normalized.metaKey);
-            return { name: normalized.collection, tenant: normalized.tenant };
+            return { name: normalized.collection };
         }
         const errorMessage = `Collection already exists with different config: dimension=${existing.dimension}, distance=${existing.distance}, type=${existing.vectorType}`;
         throw new QdrantServiceError(400, {
@@ -43,12 +43,12 @@ export async function createCollection(ctx, body) {
             error: errorMessage,
         });
     }
-    await repoCreateCollection(normalized.metaKey, dim, distance, vectorType);
-    return { name: normalized.collection, tenant: normalized.tenant };
+    await repoCreateCollection(normalized.metaKey, dim, distance, vectorType, ctx.userUid);
+    return { name: normalized.collection };
 }
 export async function getCollection(ctx) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
+    const normalized = normalizeCollectionContextShared(ctx.userUid, ctx.collection, ctx.userAgent);
     const meta = await getCollectionMeta(normalized.metaKey);
     if (!meta) {
         throw new QdrantServiceError(404, {
@@ -56,8 +56,11 @@ export async function getCollection(ctx) {
             error: "collection not found",
         });
     }
+    const pointsCount = await countPointsForCollection(normalized.uid);
     await touchCollectionLastAccess(normalized.metaKey);
     return {
+        status: "green",
+        points_count: pointsCount,
         name: normalized.collection,
         vectors: {
             size: meta.dimension,
@@ -77,7 +80,7 @@ export async function getCollection(ctx) {
 }
 export async function deleteCollection(ctx) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
+    const normalized = normalizeCollectionContextShared(ctx.userUid, ctx.collection, ctx.userAgent);
     await repoDeleteCollection(normalized.metaKey);
     return { acknowledged: true };
 }

package/dist/services/CollectionService.one-table.js

@@ -1,9 +1,8 @@
-import { uidFor, } from "./CollectionService.shared.js";
 import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
 export async function resolvePointsTableAndUidOneTable(ctx) {
     await ensureGlobalPointsTable();
     return {
         tableName: GLOBAL_POINTS_TABLE,
-        uid: uidFor(ctx.tenant, ctx.collection),
+        uid: ctx.uid,
     };
 }

package/dist/services/CollectionService.shared.d.ts

@@ -1,12 +1,13 @@
 export interface NormalizedCollectionContextLike {
-    tenant: string;
+    userUid: string;
     collection: string;
     metaKey: string;
+    uid: string;
 }
-export declare function tableNameFor(tenantId: string, collection: string): string;
-export declare function uidFor(tenantId: string, collection: string): string;
-export declare function normalizeCollectionContextShared(tenant: string | undefined, collection: string, apiKey?: string, userAgent?: string): {
-    tenant: string;
+export declare function uidForCollection(userUid: string, collection: string): string;
+export declare function normalizeCollectionContextShared(userUid: string, collection: string, _userAgent?: string): {
+    userUid: string;
     collection: string;
     metaKey: string;
+    uid: string;
 };

package/dist/services/CollectionService.shared.js

@@ -1,19 +1,35 @@
-import { sanitizeCollectionName, sanitizeTenantId, metaKeyFor, tableNameFor as tableNameForInternal, uidFor as uidForInternal, hashApiKey, normalizeUserAgent, } from "../utils/tenant.js";
-export function tableNameFor(tenantId, collection) {
-    return tableNameForInternal(tenantId, collection);
+import { sanitizeCollectionName, metaKeyFor, uidFor, } from "../utils/tenant.js";
+import { QdrantServiceError } from "./errors.js";
+function requireAndSanitizeUserUid(userUid) {
+    if (!userUid || userUid.trim() === "") {
+        throw new QdrantServiceError(401, {
+            status: "error",
+            error: "unauthorized",
+        });
+    }
+    const raw = userUid.toString();
+    const cleaned = raw.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_");
+    const lowered = cleaned.toLowerCase().replace(/^_+/, "");
+    if (lowered.length === 0) {
+        throw new QdrantServiceError(401, {
+            status: "error",
+            error: "unauthorized",
+        });
+    }
+    return lowered;
 }
-export function uidFor(tenantId, collection) {
-    return uidForInternal(tenantId, collection);
+export function uidForCollection(userUid, collection) {
+    return uidFor(userUid, collection);
 }
-export function normalizeCollectionContextShared(tenant, collection, apiKey, userAgent) {
-    const normalizedTenant = sanitizeTenantId(tenant);
-    const apiKeyHash = hashApiKey(apiKey);
-    const userAgentNormalized = normalizeUserAgent(userAgent);
-    const normalizedCollection = sanitizeCollectionName(collection, apiKeyHash, userAgentNormalized);
-    const metaKey = metaKeyFor(normalizedTenant, normalizedCollection);
+export function normalizeCollectionContextShared(userUid, collection, _userAgent) {
+    void _userAgent;
+    const normalizedUserUid = requireAndSanitizeUserUid(userUid);
+    const normalizedCollection = sanitizeCollectionName(collection);
+    const metaKey = metaKeyFor(normalizedUserUid, normalizedCollection);
     return {
-        tenant: normalizedTenant,
+        userUid: normalizedUserUid,
         collection: normalizedCollection,
         metaKey,
+        uid: uidForCollection(normalizedUserUid, normalizedCollection),
     };
 }

package/dist/services/PointsService.d.ts

@@ -1,5 +1,6 @@
 import { type CollectionContextInput } from "./CollectionService.js";
 import type { YdbQdrantScoredPoint } from "../qdrant/QdrantRestTypes.js";
+import type { RetrievedPoint } from "../repositories/pointsRepo.one-table/Retrieve.js";
 type PointsContextInput = CollectionContextInput;
 export declare function upsertPoints(ctx: PointsContextInput, body: unknown): Promise<{
     upserted: number;
@@ -10,6 +11,13 @@ export declare function searchPoints(ctx: PointsContextInput, body: unknown): Pr
 export declare function queryPoints(ctx: PointsContextInput, body: unknown): Promise<{
     points: YdbQdrantScoredPoint[];
 }>;
+export declare function retrievePoints(ctx: PointsContextInput, body: unknown): Promise<{
+    points: RetrievedPoint[];
+}>;
+/**
+ * @returns `deleted` — number of points removed, or `-1` when the exact count
+ *          is unavailable (e.g. bulk BATCH DELETE or clear-all-points).
+ */
 export declare function deletePoints(ctx: PointsContextInput, body: unknown): Promise<{
     deleted: number;
 }>;