@voyant-travel/catalog 0.117.2

package/dist/search/routes.test.js

@@ -0,0 +1,322 @@
+import { handleApiError } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { describe, expect, it, vi } from "vitest";
+import { createCatalogSearchHonoModule, createCatalogSearchRoutes, } from "./routes.js";
+const emptyResults = { total: 0, hits: [], facets: {} };
+function createIndexer(search = async () => emptyResults) {
+    return {
+        capabilities: {
+            supportsKeywordSearch: true,
+            supportsHybridSearch: true,
+            supportsVectorFields: true,
+            vectorDimensions: 3,
+            maxVectorsPerDocument: null,
+            supportsCrossAudienceFederation: false,
+            supportsAdminDenormalization: true,
+        },
+        ensureCollection: async () => { },
+        upsert: async () => { },
+        delete: async () => { },
+        search,
+        bulkReindex: async () => { },
+    };
+}
+function routeApp(options) {
+    const app = new Hono();
+    app.onError(handleApiError);
+    app.route("/v1/admin/catalog", createCatalogSearchRoutes(options));
+    return app;
+}
+describe("createCatalogSearchRoutes", () => {
+    it("exposes admin and public search routes through the Hono module wrapper", () => {
+        const module = createCatalogSearchHonoModule({
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+        });
+        expect(module.module.name).toBe("catalog");
+        expect(module.adminRoutes).toBeTruthy();
+        expect(module.publicRoutes).toBeTruthy();
+    });
+    it("requires a vertical", async () => {
+        const app = routeApp({
+            surface: "admin",
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+        });
+        const response = await app.request("/v1/admin/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({ query: "rome" }),
+        });
+        expect(response.status).toBe(400);
+        await expect(response.json()).resolves.toEqual({ error: "vertical is required" });
+    });
+    it("returns shared validation errors for invalid search bodies", async () => {
+        const executeSearch = vi.fn(async (_input) => emptyResults);
+        const app = routeApp({
+            surface: "admin",
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+            executeSearch,
+        });
+        const response = await app.request("/v1/admin/catalog/search", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                vertical: "products",
+                mode: "unknown",
+                pagination: { limit: "10" },
+            }),
+        });
+        expect(response.status).toBe(400);
+        await expect(response.json()).resolves.toMatchObject({
+            code: "invalid_request",
+        });
+        expect(executeSearch).not.toHaveBeenCalled();
+    });
+    it("returns a deployment error when no indexer is configured", async () => {
+        const app = routeApp({
+            surface: "admin",
+            resolveRuntime: () => ({
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+        });
+        const response = await app.request("/v1/admin/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({ vertical: "products" }),
+        });
+        expect(response.status).toBe(503);
+        await expect(response.json()).resolves.toEqual({
+            error: "Search indexer is not configured (missing TYPESENSE_HOST)",
+        });
+    });
+    it("uses the admin default audience and the customer public audience", async () => {
+        const executeSearch = vi.fn(async (_input) => emptyResults);
+        const module = createCatalogSearchHonoModule({
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+            executeSearch,
+        });
+        const app = new Hono();
+        app.route("/v1/admin/catalog", module.adminRoutes);
+        app.route("/v1/public/catalog", module.publicRoutes);
+        await app.request("/v1/admin/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({ vertical: "products", mode: "keyword" }),
+        });
+        await app.request("/v1/public/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({ vertical: "products", mode: "keyword", locale: "ro-RO" }),
+        });
+        expect(executeSearch.mock.calls[0]?.[0].slice).toEqual({
+            vertical: "products",
+            locale: "en-GB",
+            audience: "staff",
+            market: "default",
+        });
+        expect(executeSearch.mock.calls[1]?.[0].slice).toEqual({
+            vertical: "products",
+            locale: "ro-RO",
+            audience: "customer",
+            market: "default",
+        });
+    });
+    it("downgrades semantic modes to keyword when embeddings are unavailable", async () => {
+        const executeSearch = vi.fn(async (_input) => emptyResults);
+        const app = routeApp({
+            surface: "admin",
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+            executeSearch,
+        });
+        const response = await app.request("/v1/admin/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({ vertical: "products", mode: "hybrid", query: "rome" }),
+        });
+        expect(response.status).toBe(200);
+        await expect(response.json()).resolves.toMatchObject({ mode: "keyword" });
+        expect(executeSearch).toHaveBeenCalledWith(expect.objectContaining({
+            request: expect.objectContaining({ mode: "keyword" }),
+        }));
+    });
+    it("passes typed storefront sort options into the search request", async () => {
+        const executeSearch = vi.fn(async (_input) => emptyResults);
+        const app = routeApp({
+            surface: "public",
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+            executeSearch,
+        });
+        const response = await app.request("/v1/admin/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({
+                vertical: "products",
+                mode: "keyword",
+                sort: "price-asc",
+                pagination: { limit: 12 },
+            }),
+        });
+        expect(response.status).toBe(200);
+        expect(executeSearch).toHaveBeenCalledWith(expect.objectContaining({
+            request: expect.objectContaining({
+                sort: "price-asc",
+                pagination: { limit: 12 },
+            }),
+        }));
+    });
+    it("projects storefront cards from indexed fields when requested", async () => {
+        const executeSearch = vi.fn(async (_input) => ({
+            total: 1,
+            facets: {
+                "categorySlugs[]": [{ value: "cruises", count: 4 }],
+            },
+            hits: [
+                {
+                    id: "prod_abc",
+                    score: 12,
+                    document: {
+                        id: "prod_abc",
+                        fields: {
+                            name: "Danube Cruise",
+                            slug: "danube-cruise",
+                            primaryCategoryId: "cat_cruises",
+                            primaryCategoryName: "Cruises",
+                            primaryCategorySlug: "cruises",
+                            thumbnailUrl: "https://cdn.example/thumb.jpg",
+                            coverMediaUrl: "https://cdn.example/cover.jpg",
+                            priceFromAmountCents: 125000,
+                            priceFromCurrency: "EUR",
+                            originalPriceFromAmountCents: 150000,
+                            hasOffer: true,
+                            bestOfferId: "offer_spring",
+                            bestOfferName: "Spring Sale",
+                            bestOfferDiscountKind: "percentage",
+                            bestOfferDiscountPercent: 15,
+                            upcomingDepartureCount: 3,
+                            nextDepartureAt: "2026-06-01T09:00:00Z",
+                            nextDepartureDate: "2026-06-01",
+                            "departureMonths[]": ["2026-06", "2026-07"],
+                            "departureDates[]": ["2026-06-01", "2026-07-15"],
+                            "regions[]": ["Europe"],
+                            "countries[]": ["Romania"],
+                            "cities[]": ["Tulcea"],
+                            "destinationIds[]": ["dest_ro"],
+                            "destinationSlugs[]": ["romania"],
+                            latitude: 45.18,
+                            longitude: 28.8,
+                        },
+                    },
+                },
+            ],
+        }));
+        const module = createCatalogSearchHonoModule({
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+            executeSearch,
+        });
+        const app = new Hono();
+        app.route("/v1/public/catalog", module.publicRoutes);
+        const response = await app.request("/v1/public/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({
+                vertical: "products",
+                mode: "keyword",
+                projection: "storefront-card",
+                pagination: { limit: 12 },
+            }),
+        });
+        expect(response.status).toBe(200);
+        await expect(response.json()).resolves.toMatchObject({
+            total: 1,
+            facets: {
+                "categorySlugs[]": [{ value: "cruises", count: 4 }],
+            },
+            cards: [
+                {
+                    id: "prod_abc",
+                    name: "Danube Cruise",
+                    slug: "danube-cruise",
+                    primaryCategory: {
+                        id: "cat_cruises",
+                        name: "Cruises",
+                        slug: "cruises",
+                    },
+                    media: {
+                        thumbnailUrl: "https://cdn.example/thumb.jpg",
+                        coverMediaUrl: "https://cdn.example/cover.jpg",
+                    },
+                    priceFrom: {
+                        amountCents: 125000,
+                        currency: "EUR",
+                        originalAmountCents: 150000,
+                    },
+                    offerBadges: [
+                        {
+                            id: "offer_spring",
+                            name: "Spring Sale",
+                            discountKind: "percentage",
+                            discountPercent: 15,
+                            discountAmountCents: null,
+                        },
+                    ],
+                    departures: {
+                        upcomingCount: 3,
+                        nextDepartureAt: "2026-06-01T09:00:00Z",
+                        nextDepartureDate: "2026-06-01",
+                        months: ["2026-06", "2026-07"],
+                        dates: ["2026-06-01", "2026-07-15"],
+                    },
+                    destinations: {
+                        regions: ["Europe"],
+                        countries: ["Romania"],
+                        cities: ["Tulcea"],
+                        ids: ["dest_ro"],
+                        slugs: ["romania"],
+                    },
+                    coordinates: {
+                        latitude: 45.18,
+                        longitude: 28.8,
+                    },
+                },
+            ],
+        });
+    });
+    it("retries hybrid searches as keyword when semantic execution fails", async () => {
+        const executeSearch = vi
+            .fn(async (_input) => emptyResults)
+            .mockRejectedValueOnce(new Error("embedding provider unavailable"))
+            .mockResolvedValueOnce(emptyResults);
+        const app = routeApp({
+            surface: "admin",
+            resolveRuntime: () => ({
+                indexer: createIndexer(),
+                embeddings: { kind: "test-embeddings" },
+                defaultScope: { locale: "en-GB", audience: "staff", market: "default" },
+            }),
+            executeSearch,
+        });
+        const response = await app.request("/v1/admin/catalog/search", {
+            method: "POST",
+            body: JSON.stringify({ vertical: "products", mode: "hybrid", query: "rome" }),
+        });
+        expect(response.status).toBe(200);
+        await expect(response.json()).resolves.toMatchObject({ mode: "keyword" });
+        expect(executeSearch.mock.calls.map(([input]) => input.request.mode)).toEqual([
+            "hybrid",
+            "keyword",
+        ]);
+    });
+});

package/dist/search/semantic.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Semantic / hybrid search orchestration.
+ *
+ * Wraps the Phase 1 `IndexerAdapter.search` with the embedding-generation
+ * step. When `mode: "semantic" | "hybrid"`, this helper embeds the query
+ * via the configured `EmbeddingProvider`, attaches the vector to the
+ * `SearchRequest` as `query_embedding`, and delegates to the adapter.
+ *
+ * Callers that already have a query embedding (an upstream agent that
+ * vectorized the user's intent) can skip embedding by passing
+ * `query_embedding` directly — `executeSemanticSearch` honors a
+ * caller-supplied vector and skips the embed call.
+ *
+ * See `docs/architecture/catalog-architecture.md` for the design.
+ */
+import type { EmbeddingProvider } from "../embeddings/contract.js";
+import type { IndexerAdapter, IndexerSlice, SearchRequest, SearchResults } from "../indexer/contract.js";
+export interface SemanticSearchOptions {
+    /** Adapter to query. */
+    adapter: IndexerAdapter;
+    /**
+     * Embedding provider — used to vectorize the query string when the mode
+     * needs vectors. Optional: callers running pure-keyword searches can omit
+     * this. `executeSemanticSearch` throws a clear error if mode is
+     * `semantic` / `hybrid` and no provider is configured.
+     */
+    embeddings?: EmbeddingProvider;
+    /** The variant slice (vertical, locale, audience, market) to search. */
+    slice: IndexerSlice;
+    /** The search request. `mode` controls keyword/hybrid/semantic blending. */
+    request: SearchRequest;
+}
+/**
+ * Run a search request that may need a query embedding generated.
+ *
+ * Behavior by mode:
+ *   - `keyword`   — adapter.search called directly; no embedding work.
+ *   - `hybrid`    — query string is embedded (unless caller supplied
+ *                   `query_embedding`), adapter blends keyword + vector
+ *                   scores.
+ *   - `semantic`  — query string is embedded, adapter does pure vector
+ *                   similarity. (Engines that don't support pure-semantic
+ *                   typically fall back to hybrid with the keyword weight
+ *                   set very low.)
+ *
+ * Verifies adapter capabilities at runtime: requesting `semantic` /
+ * `hybrid` against an adapter without `supportsVectorFields` throws
+ * a clear error rather than silently degrading to keyword-only.
+ */
+export declare function executeSemanticSearch(options: SemanticSearchOptions): Promise<SearchResults>;
+/**
+ * Helper for callers (typically AI agents) that have already vectorized
+ * a query upstream and want to bypass the embedding step entirely. The
+ * vector is attached to the request as-is.
+ */
+export declare function executeBYOVectorSearch(options: {
+    adapter: IndexerAdapter;
+    slice: IndexerSlice;
+    request: SearchRequest & {
+        query_embedding: number[];
+    };
+}): Promise<SearchResults>;
+//# sourceMappingURL=semantic.d.ts.map

package/dist/search/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../src/search/semantic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAClE,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,wBAAwB,CAAA;AAE/B,MAAM,WAAW,qBAAqB;IACpC,wBAAwB;IACxB,OAAO,EAAE,cAAc,CAAA;IACvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,wEAAwE;IACxE,KAAK,EAAE,YAAY,CAAA;IACnB,4EAA4E;IAC5E,OAAO,EAAE,aAAa,CAAA;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,aAAa,CAAC,CAyCxB;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE;IACpD,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,aAAa,GAAG;QAAE,eAAe,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;CACvD,GAAG,OAAO,CAAC,aAAa,CAAC,CAQzB"}

package/dist/search/semantic.js

@@ -0,0 +1,75 @@
+/**
+ * Semantic / hybrid search orchestration.
+ *
+ * Wraps the Phase 1 `IndexerAdapter.search` with the embedding-generation
+ * step. When `mode: "semantic" | "hybrid"`, this helper embeds the query
+ * via the configured `EmbeddingProvider`, attaches the vector to the
+ * `SearchRequest` as `query_embedding`, and delegates to the adapter.
+ *
+ * Callers that already have a query embedding (an upstream agent that
+ * vectorized the user's intent) can skip embedding by passing
+ * `query_embedding` directly — `executeSemanticSearch` honors a
+ * caller-supplied vector and skips the embed call.
+ *
+ * See `docs/architecture/catalog-architecture.md` for the design.
+ */
+/**
+ * Run a search request that may need a query embedding generated.
+ *
+ * Behavior by mode:
+ *   - `keyword`   — adapter.search called directly; no embedding work.
+ *   - `hybrid`    — query string is embedded (unless caller supplied
+ *                   `query_embedding`), adapter blends keyword + vector
+ *                   scores.
+ *   - `semantic`  — query string is embedded, adapter does pure vector
+ *                   similarity. (Engines that don't support pure-semantic
+ *                   typically fall back to hybrid with the keyword weight
+ *                   set very low.)
+ *
+ * Verifies adapter capabilities at runtime: requesting `semantic` /
+ * `hybrid` against an adapter without `supportsVectorFields` throws
+ * a clear error rather than silently degrading to keyword-only.
+ */
+export async function executeSemanticSearch(options) {
+    const { adapter, embeddings, slice, request } = options;
+    if (request.mode === "keyword") {
+        return adapter.search(slice, request);
+    }
+    if (!adapter.capabilities.supportsVectorFields) {
+        throw new Error(`Search mode "${request.mode}" requires an indexer that supports vector fields. ` +
+            `Configured adapter does not declare supportsVectorFields. Use mode: "keyword" or swap to a vector-capable adapter (e.g. Typesense).`);
+    }
+    if (request.mode === "hybrid" && !adapter.capabilities.supportsHybridSearch) {
+        throw new Error(`Search mode "hybrid" requires an indexer that declares supportsHybridSearch. ` +
+            `Configured adapter does not. Either use mode: "semantic" (pure vector) or swap to a hybrid-capable engine.`);
+    }
+    // Use caller-supplied embedding if provided; otherwise generate one.
+    let queryEmbedding = request.query_embedding;
+    if (!queryEmbedding && request.query.length > 0) {
+        if (!embeddings) {
+            throw new Error(`Search mode "${request.mode}" requires an EmbeddingProvider to vectorize the query. ` +
+                `Configure one (e.g. createGeminiEmbeddingProvider) or supply request.query_embedding directly.`);
+        }
+        const [vector] = await embeddings.embed([request.query]);
+        if (!vector) {
+            throw new Error("EmbeddingProvider returned no vector for the query string");
+        }
+        queryEmbedding = vector;
+    }
+    return adapter.search(slice, {
+        ...request,
+        query_embedding: queryEmbedding,
+    });
+}
+/**
+ * Helper for callers (typically AI agents) that have already vectorized
+ * a query upstream and want to bypass the embedding step entirely. The
+ * vector is attached to the request as-is.
+ */
+export async function executeBYOVectorSearch(options) {
+    const { adapter, slice, request } = options;
+    if (!adapter.capabilities.supportsVectorFields) {
+        throw new Error("BYO-vector search requires an indexer with supportsVectorFields. The configured adapter does not.");
+    }
+    return adapter.search(slice, request);
+}

package/dist/search/semantic.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=semantic.test.d.ts.map

package/dist/search/semantic.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.test.d.ts","sourceRoot":"","sources":["../../src/search/semantic.test.ts"],"names":[],"mappings":""}

package/dist/search/semantic.test.js

@@ -0,0 +1,143 @@
+import { describe, expect, it, vi } from "vitest";
+import { executeBYOVectorSearch, executeSemanticSearch } from "./semantic.js";
+function makeAdapter(capabilities = {}) {
+    const baseCapabilities = {
+        supportsKeywordSearch: true,
+        supportsHybridSearch: true,
+        supportsVectorFields: true,
+        vectorDimensions: 1536,
+        maxVectorsPerDocument: null,
+        supportsCrossAudienceFederation: false,
+        supportsAdminDenormalization: true,
+        ...capabilities,
+    };
+    const searchSpy = vi.fn(async (_slice, _request) => ({
+        hits: [],
+        total: 0,
+    }));
+    return {
+        capabilities: baseCapabilities,
+        async ensureCollection() { },
+        async upsert() { },
+        async delete() { },
+        async bulkReindex() { },
+        search: searchSpy,
+        searchSpy,
+    };
+}
+function makeEmbeddings() {
+    const embedSpy = vi.fn(async (texts) => texts.map(() => [0.1, 0.2, 0.3]));
+    return {
+        capabilities: {
+            modelId: "test/v1",
+            dimensions: 3,
+            maxTokensPerInput: 1000,
+            maxBatchSize: 100,
+        },
+        embed: embedSpy,
+        embedSpy,
+    };
+}
+const slice = {
+    vertical: "products",
+    locale: "en-GB",
+    audience: "customer",
+    market: "default",
+};
+describe("executeSemanticSearch", () => {
+    it("keyword mode delegates directly without embedding", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "wellness", mode: "keyword" },
+        });
+        expect(embeddings.embedSpy).not.toHaveBeenCalled();
+        expect(adapter.searchSpy).toHaveBeenCalledTimes(1);
+    });
+    it("semantic mode embeds the query and attaches the vector", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "wellness", mode: "semantic" },
+        });
+        expect(embeddings.embedSpy).toHaveBeenCalledWith(["wellness"]);
+        const [, request] = adapter.searchSpy.mock.calls[0];
+        expect(request.query_embedding).toEqual([0.1, 0.2, 0.3]);
+    });
+    it("hybrid mode embeds the query when caller didn't supply one", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "wellness", mode: "hybrid" },
+        });
+        expect(embeddings.embedSpy).toHaveBeenCalledTimes(1);
+    });
+    it("honors caller-supplied query_embedding without re-embedding", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        const caller_vector = [0.9, 0.8, 0.7];
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: {
+                query: "wellness",
+                mode: "semantic",
+                query_embedding: caller_vector,
+            },
+        });
+        expect(embeddings.embedSpy).not.toHaveBeenCalled();
+        const [, request] = adapter.searchSpy.mock.calls[0];
+        expect(request.query_embedding).toBe(caller_vector);
+    });
+    it("throws when semantic mode is requested but adapter doesn't support vectors", async () => {
+        const adapter = makeAdapter({ supportsVectorFields: false });
+        const embeddings = makeEmbeddings();
+        await expect(executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "x", mode: "semantic" },
+        })).rejects.toThrow(/supports vector fields/);
+    });
+    it("throws when hybrid mode is requested but adapter doesn't support hybrid", async () => {
+        const adapter = makeAdapter({ supportsVectorFields: true, supportsHybridSearch: false });
+        const embeddings = makeEmbeddings();
+        await expect(executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "x", mode: "hybrid" },
+        })).rejects.toThrow(/supportsHybridSearch/);
+    });
+});
+describe("executeBYOVectorSearch", () => {
+    it("attaches the caller-supplied vector and delegates without embedding", async () => {
+        const adapter = makeAdapter();
+        const vector = [1, 2, 3];
+        await executeBYOVectorSearch({
+            adapter,
+            slice,
+            request: { query: "x", mode: "semantic", query_embedding: vector },
+        });
+        const [, request] = adapter.searchSpy.mock.calls[0];
+        expect(request.query_embedding).toBe(vector);
+    });
+    it("throws when adapter does not support vector fields", async () => {
+        const adapter = makeAdapter({ supportsVectorFields: false });
+        await expect(executeBYOVectorSearch({
+            adapter,
+            slice,
+            request: { query: "x", mode: "semantic", query_embedding: [1, 2, 3] },
+        })).rejects.toThrow(/supportsVectorFields/);
+    });
+});

package/dist/services/build-indexer-document.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-indexer-document.test.d.ts.map

package/dist/services/build-indexer-document.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-indexer-document.test.d.ts","sourceRoot":"","sources":["../../src/services/build-indexer-document.test.ts"],"names":[],"mappings":""}