@dbx-tools/search 0.6.9

package/lib/src/client.js

@@ -0,0 +1,598 @@
+/**
+ * A small, Meilisearch-shaped client over Databricks AI Search (Vector
+ * Search). The whole point of this module is ergonomics: the Databricks SDK's
+ * `vectorSearchIndexes.queryIndex({ index_name, columns, query_text,
+ * query_type, num_results, filters_json })` is powerful but verbose, and the
+ * response is columnar. This client hides all of that behind two objects:
+ *
+ * ```ts
+ * const client = createSearchClient();
+ * const index = client.index("main.support.docs");
+ * const { hits } = await index.search("reset my password", { limit: 5 });
+ * await index.addDocuments([{ id: "42", title: "Reset", body: "..." }]);
+ * ```
+ *
+ * `client.search(query, opts)` searches the default index; `client.index(name)`
+ * returns a handle bound to one index; `client.universalSearch(query)` fans a
+ * query across several indexes and merges the results (Meilisearch's federated
+ * / multi-search, the "universal search" the caller asked for). Everything is
+ * async and cancellable, resolves the OBO workspace client from the active
+ * AppKit execution context (falling back to a service-principal client outside
+ * a request), and returns the browser-safe shapes from
+ * `@dbx-tools/shared-search`.
+ *
+ * Autocomplete is just a search with a small `limit` and the raw query text -
+ * hybrid mode already prefix-matches, so no separate endpoint is needed; the
+ * {@link SearchIndex.autocomplete} helper is a thin, self-documenting alias.
+ *
+ * @module
+ */
+import { ExecutionError, getExecutionContext } from "@databricks/appkit";
+import { appkit, databricks } from "@dbx-tools/appkit";
+import { invoke, resolve as modelResolve, serving } from "@dbx-tools/model";
+import { async as asyncUtil, json, log, string } from "@dbx-tools/shared-core";
+import { ModelClass } from "@dbx-tools/shared-model";
+import { DEFAULT_MODE, DEFAULT_PAGE_SIZE, DEFAULT_TIMEOUT_MS, indexConfigFor, resolveIndexName, } from "./config.js";
+import { compileFilter, toHits, toQueryType, toRequestColumns, } from "./query.js";
+const logger = log.logger("search/client");
+/**
+ * A handle bound to one index. Modeled on Meilisearch's `client.index(uid)`:
+ * `search` / `autocomplete` read, `addDocuments` / `deleteDocuments` write (to
+ * a direct-access index), and `info` fetches the live definition.
+ */
+export class SearchIndex {
+    name;
+    client;
+    constructor(name, client) {
+        this.name = name;
+        this.client = client;
+    }
+    /** Search this index. See {@link SearchClient.search}. */
+    search(query, options) {
+        return this.client.search(query, { ...options, index: this.name });
+    }
+    /**
+     * Autocomplete against this index: a search with a small default `limit` and
+     * the raw prefix as the query. Hybrid mode already handles prefixes, so this
+     * is a self-documenting alias rather than a separate code path.
+     */
+    autocomplete(prefix, options) {
+        return this.search(prefix, { limit: 5, ...options });
+    }
+    /** Add or update documents in this (direct-access) index. */
+    addDocuments(documents, signal) {
+        return this.client.addDocuments(this.name, documents, signal);
+    }
+    /** Delete documents from this (direct-access) index by primary key. */
+    deleteDocuments(ids, signal) {
+        return this.client.deleteDocuments(this.name, ids, signal);
+    }
+    /** Fetch this index's live definition (primary key, columns, readiness). */
+    info(signal) {
+        return this.client.getIndex(this.name, signal);
+    }
+    /** Trigger a sync of this (Delta Sync) index from its source table. */
+    sync(signal) {
+        return this.client.syncIndex(this.name, signal);
+    }
+    /** Delete this index. */
+    delete(signal) {
+        return this.client.deleteIndex(this.name, signal);
+    }
+    /** Create this index if it does not exist, otherwise return the existing one. */
+    ensure(options) {
+        return this.client.ensureIndex(this.name, options);
+    }
+}
+/**
+ * The AI Search client. Construct it with {@link createSearchClient} (which
+ * reads a resolved config) or directly for one-off use. All reads resolve the
+ * OBO workspace client from the active execution context.
+ */
+export class SearchClient {
+    config;
+    workspaceClientFactory;
+    lakebase;
+    constructor(config = {
+        indexes: [],
+        pageSize: DEFAULT_PAGE_SIZE,
+        mode: DEFAULT_MODE,
+        basePath: "/api/search",
+        timeoutMs: DEFAULT_TIMEOUT_MS,
+        allowWrite: false,
+    }, workspaceClientFactory = defaultWorkspaceClient, 
+    /**
+     * Optional Lakebase full-text FALLBACK backend. Present only when no Vector
+     * Search endpoint is configured but a Lakebase pool is available; when set,
+     * search / provision / write operations delegate to it and return the exact
+     * same shapes, so nothing downstream can tell which backend answered.
+     */
+    lakebase) {
+        this.config = config;
+        this.workspaceClientFactory = workspaceClientFactory;
+        this.lakebase = lakebase;
+    }
+    /** True when this client is answering out of the Lakebase fallback backend. */
+    get usesLakebase() {
+        return this.lakebase !== undefined;
+    }
+    /** A handle bound to one index (by full UC name or configured alias). */
+    index(reference) {
+        const name = resolveIndexName(this.config, reference) ?? reference;
+        return new SearchIndex(name, this);
+    }
+    /**
+     * Search one index. `index` may be a full UC name, a configured alias, or
+     * omitted to use the default index. Returns hits sorted most-relevant-first.
+     */
+    async search(query, options = {}) {
+        const text = string.trimToEmpty(query);
+        const name = resolveIndexName(this.config, options.index);
+        if (name === null) {
+            throw new ExecutionError("search: no index configured; set a default index or pass one", {
+                context: { operation: "search" },
+            });
+        }
+        if (this.lakebase) {
+            return this.lakebase.search(name, text, {
+                limit: options.limit ?? this.config.pageSize,
+                ...(options.scoreThreshold !== undefined ? { scoreThreshold: options.scoreThreshold } : {}),
+                ...(options.signal ? { signal: options.signal } : {}),
+            });
+        }
+        const known = indexConfigFor(this.config, name);
+        const primaryKey = known?.primaryKey;
+        const columns = toRequestColumns(options.columns, known?.columns ?? this.config.columns, primaryKey);
+        const mode = options.mode ?? this.config.mode;
+        const limit = options.limit ?? this.config.pageSize;
+        // Databricks only manages embeddings for Delta Sync indexes, so a query
+        // against a DIRECT_ACCESS index must carry a query VECTOR, not text. Embed
+        // the query client-side in that case (the index type is cached after the
+        // first lookup so this costs one extra call per index, not per search).
+        const directAccess = await this.isDirectAccess(name, options.signal);
+        const queryVector = directAccess
+            ? (await this.embed([text], this.config.embeddingModel, options.signal))[0]
+            : undefined;
+        const response = await this.withClient("search", options.signal, async (client, context) => {
+            return client.vectorSearchIndexes.queryIndex({
+                index_name: name,
+                columns,
+                ...(queryVector ? { query_vector: queryVector } : { query_text: text }),
+                query_type: toQueryType(mode),
+                num_results: limit,
+                ...(compileFilter(options.filter) ? { filters_json: compileFilter(options.filter) } : {}),
+                ...(options.scoreThreshold !== undefined
+                    ? { score_threshold: options.scoreThreshold }
+                    : {}),
+            }, context);
+        });
+        const hits = toHits(response, primaryKey);
+        return { query: text, index: name, hits, count: hits.length };
+    }
+    /** Cache of index-name -> is-DIRECT_ACCESS, so a search embeds its query only when needed. */
+    directAccessCache = new Map();
+    /** Whether an index is DIRECT_ACCESS (memoized); a lookup failure assumes Delta Sync. */
+    async isDirectAccess(name, signal) {
+        const cached = this.directAccessCache.get(name);
+        if (cached !== undefined)
+            return cached;
+        try {
+            const info = await this.getIndex(name, signal);
+            const value = info.directAccess ?? false;
+            this.directAccessCache.set(name, value);
+            return value;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Fan a query across several indexes and merge the hits, sorted by score -
+     * the "universal search" a single box over many collections needs. Each
+     * index is searched concurrently; an index that errors is logged and skipped
+     * so one bad index does not sink the whole search.
+     */
+    async universalSearch(query, options = {}) {
+        const text = string.trimToEmpty(query);
+        const names = options.indexes && options.indexes.length > 0
+            ? options.indexes.map((ref) => resolveIndexName(this.config, ref) ?? ref)
+            : this.config.indexes.map((i) => i.name);
+        const perIndex = options.limit ?? this.config.pageSize;
+        const settled = await Promise.allSettled(names.map(async (name) => {
+            const result = await this.search(text, {
+                index: name,
+                limit: perIndex,
+                ...(options.mode ? { mode: options.mode } : {}),
+                ...(options.signal ? { signal: options.signal } : {}),
+            });
+            return result.hits.map((hit) => ({ ...hit, index: name }));
+        }));
+        const hits = settled
+            .flatMap((outcome, i) => {
+            if (outcome.status === "fulfilled")
+                return outcome.value;
+            logger.warn("universal-index-failed", { index: names[i] });
+            return [];
+        })
+            .sort((a, b) => b.score - a.score);
+        return { query: text, hits, count: hits.length };
+    }
+    /**
+     * Resolve an index reference (full UC name or configured alias) to the name
+     * the API expects, failing fast when it resolves to nothing. Without this a
+     * blank reference - what an omitted `index` becomes when no default is
+     * configured - reaches the SDK as an empty `index_name`, which builds a
+     * URL with the name segment missing and comes back as a confusing
+     * `ENDPOINT_NOT_FOUND` instead of naming the real problem.
+     */
+    requireIndexName(reference, operation) {
+        const name = string.trimToNull(resolveIndexName(this.config, reference) ?? reference);
+        if (name === null) {
+            throw new ExecutionError(`search: no index configured; set a default index or pass one to ${operation}`, { context: { operation } });
+        }
+        return name;
+    }
+    /** Fetch an index's live definition. */
+    async getIndex(reference, signal) {
+        const name = this.requireIndexName(reference, "getIndex");
+        const index = await this.withClient("getIndex", signal, (client, context) => client.vectorSearchIndexes.getIndex({ index_name: name }, context));
+        const directAccess = index.direct_access_index_spec !== undefined;
+        const spec = index.delta_sync_index_spec ?? index.direct_access_index_spec;
+        // Delta Sync surfaces its embedding source columns directly; a direct-access
+        // index carries its columns in schema_json (minus the vector column).
+        let columns = (spec?.embedding_source_columns ?? []).map((c) => c.name ?? "").filter(Boolean);
+        const schemaJson = index.direct_access_index_spec?.schema_json;
+        if (directAccess && schemaJson) {
+            const schema = json.parseRecord(schemaJson) ?? {};
+            const vectorNames = new Set((index.direct_access_index_spec?.embedding_vector_columns ?? [])
+                .map((c) => c.name)
+                .filter((n) => Boolean(n)));
+            columns = Object.keys(schema).filter((c) => !vectorNames.has(c));
+        }
+        return {
+            name: index.name ?? name,
+            ...(index.endpoint_name ? { endpoint: index.endpoint_name } : {}),
+            ...(index.primary_key ? { primaryKey: index.primary_key } : {}),
+            columns,
+            ready: index.status?.ready ?? false,
+            ...(index.status?.indexed_row_count !== undefined
+                ? { rowCount: index.status.indexed_row_count }
+                : {}),
+            ...(directAccess ? { directAccess: true } : {}),
+        };
+    }
+    /** Add or update documents in a direct-access index. */
+    async addDocuments(reference, documents, signal) {
+        const name = this.requireIndexName(reference, "addDocuments");
+        if (this.lakebase) {
+            return this.lakebase.addDocuments(name, documents, this.config.ensureOnSetup?.textColumn ?? "text", signal);
+        }
+        await this.withClient("addDocuments", signal, (client, context) => client.vectorSearchIndexes.upsertDataVectorIndex({ index_name: name, inputs_json: JSON.stringify(documents) }, context));
+        return { index: name, count: documents.length };
+    }
+    /** Delete documents from a direct-access index by primary key. */
+    async deleteDocuments(reference, ids, signal) {
+        const name = this.requireIndexName(reference, "deleteDocuments");
+        if (this.lakebase) {
+            return this.lakebase.deleteDocuments(name, ids, signal);
+        }
+        await this.withClient("deleteDocuments", signal, (client, context) => client.vectorSearchIndexes.deleteDataVectorIndex({ index_name: name, primary_keys: ids.map(String) }, context));
+        return { index: name, count: ids.length };
+    }
+    /**
+     * Resolve an embedding endpoint id for creating a Delta Sync index. Reuses
+     * the model resolver: a configured / passed name is fuzzy-matched against the
+     * live catalogue, otherwise the highest-ranked embedding endpoint is chosen.
+     */
+    async resolveEmbeddingModel(requested, signal) {
+        const explicit = string.trimToNull(requested ?? this.config.embeddingModel);
+        // An explicit name that already looks like an endpoint id (no whitespace)
+        // is used verbatim - no need to fetch and fuzzy-match the live catalogue.
+        // A genuinely loose name (e.g. "gte large") still resolves against it.
+        if (explicit && !/\s/.test(explicit))
+            return explicit;
+        return this.withClient("resolveEmbeddingModel", signal, async (client) => {
+            const host = (await client.config.getHost()).toString();
+            const endpoints = await serving.listServingEndpoints(client, host);
+            const { modelId } = modelResolve.resolveModel(endpoints, {
+                ...(explicit ? { explicit } : { modelClass: ModelClass.Embedding }),
+            });
+            return string.trimToNull(modelId);
+        });
+    }
+    /**
+     * Embed text via a Databricks embedding serving endpoint, returning one
+     * vector per input. Used to seed a direct-access index and to turn a search
+     * query into a query vector - Databricks only manages embeddings for Delta
+     * Sync indexes, so a direct-access index (no Delta table, no warehouse) needs
+     * the client to embed on write and on query. The endpoint is resolved the
+     * same way as for index creation when not named.
+     */
+    async embed(texts, model, signal) {
+        if (texts.length === 0)
+            return [];
+        const endpoint = await this.resolveEmbeddingModel(model, signal);
+        if (!endpoint) {
+            throw new ExecutionError("search: could not resolve an embedding model to embed text", {
+                context: { operation: "embed" },
+            });
+        }
+        return this.withClient("embed", signal, async (client) => {
+            const host = (await client.config.getHost()).toString();
+            const url = invoke.invocationsUrl(host, endpoint);
+            const headers = await invoke.authHeaders(client);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { ...headers, "content-type": "application/json" },
+                body: JSON.stringify({ input: texts }),
+                ...(signal ? { signal } : {}),
+            });
+            if (!response.ok) {
+                throw new ExecutionError(`search: embedding endpoint ${endpoint} failed (${response.status})`, { context: { operation: "embed" } });
+            }
+            const body = (await response.json());
+            const vectors = (body.data ?? []).map((row) => row.embedding);
+            if (vectors.length !== texts.length) {
+                throw new ExecutionError("search: embedding response did not match the input count", {
+                    context: { operation: "embed" },
+                });
+            }
+            return vectors;
+        });
+    }
+    /** The vector dimension a model produces (embeds a probe string once). */
+    async embeddingDimension(model, signal) {
+        const [vector] = await this.embed(["dimension probe"], model, signal);
+        if (!vector || vector.length === 0) {
+            throw new ExecutionError("search: could not determine the embedding dimension", {
+                context: { operation: "createIndex" },
+            });
+        }
+        return vector.length;
+    }
+    /**
+     * Create an AI Search index with as little ceremony as possible. Two shapes:
+     *
+     *   - **Delta Sync** (the default): pass `sourceTable`; Databricks computes
+     *     embeddings from the text column and keeps the index synced. The
+     *     embedding model is resolved automatically when not named.
+     *   - **Direct Access**: omit `sourceTable` and pass `embeddingDimension`;
+     *     you write vectors yourself via {@link addDocuments}.
+     *
+     * Everything else infers: the endpoint from the plugin config, the primary
+     * key (`id`), the text column (`text` / `content` / `body`), and the vector
+     * column (`embedding`). Returns the created index's {@link IndexInfo}.
+     */
+    async createIndex(name, options = {}) {
+        const endpoint = options.endpoint ?? this.config.endpoint;
+        if (!endpoint) {
+            throw new ExecutionError("search: no Vector Search endpoint configured; pass `endpoint` or set it on the plugin", { context: { operation: "createIndex" } });
+        }
+        const primaryKey = options.primaryKey ?? "id";
+        const direct = !options.sourceTable;
+        const sourceColumn = options.embeddingSourceColumn ?? "text";
+        const vectorColumn = options.embeddingVectorColumn ?? "embedding";
+        // Delta Sync lets Databricks embed a source column, so it needs an embedding
+        // model. A direct-access index stores vectors YOU supply (Databricks only
+        // supports managed embeddings on Delta Sync), so it needs a dimension; we
+        // resolve one from the embedding model when not given so a direct-access
+        // index still works with zero extra config (embed via `embed()` on seed +
+        // query - see `provision` / `search`).
+        const embeddingModel = (await this.resolveEmbeddingModel(options.embeddingModel, options.signal)) ?? undefined;
+        if (!embeddingModel) {
+            throw new ExecutionError("search: could not resolve an embedding model; pass `embeddingModel`", { context: { operation: "createIndex" } });
+        }
+        const dimension = options.embeddingDimension ?? (await this.embeddingDimension(embeddingModel, options.signal));
+        const schema = {
+            [primaryKey]: "string",
+            [sourceColumn]: "string",
+            ...(options.schema ?? {}),
+        };
+        const directSpec = {
+            direct_access_index_spec: {
+                embedding_vector_columns: [{ name: vectorColumn, embedding_dimension: dimension }],
+                schema_json: JSON.stringify({ ...schema, [vectorColumn]: `array<float>` }),
+            },
+        };
+        await this.withClient("createIndex", options.signal, (client, context) => client.vectorSearchIndexes.createIndex({
+            name,
+            endpoint_name: endpoint,
+            primary_key: primaryKey,
+            index_type: direct ? "DIRECT_ACCESS" : "DELTA_SYNC",
+            ...(direct
+                ? directSpec
+                : {
+                    delta_sync_index_spec: {
+                        source_table: options.sourceTable,
+                        pipeline_type: options.pipelineType ?? "TRIGGERED",
+                        embedding_source_columns: [
+                            { name: sourceColumn, embedding_model_endpoint_name: embeddingModel },
+                        ],
+                        ...(options.columnsToSync && options.columnsToSync.length > 0
+                            ? { columns_to_sync: options.columnsToSync }
+                            : {}),
+                    },
+                }),
+        }, context));
+        logger.info("index-created", {
+            index: name,
+            endpoint,
+            type: direct ? "DIRECT_ACCESS" : "DELTA_SYNC",
+        });
+        return this.getIndex(name, options.signal);
+    }
+    /**
+     * Create the index if it does not already exist, otherwise return the
+     * existing one. Idempotent - safe to call on every boot to guarantee an
+     * index is present.
+     */
+    async ensureIndex(name, options = {}) {
+        try {
+            return await this.getIndex(name, options.signal);
+        }
+        catch {
+            return this.createIndex(name, options);
+        }
+    }
+    /**
+     * Ensure an index exists, is online, and (optionally) holds seed data - the
+     * "wire up a real index on boot" path. Idempotent and cheap to call every
+     * boot: it creates the endpoint and index only if missing, waits for them to
+     * come online, and seeds documents ONLY when the index is still empty.
+     *
+     * For the demo/dummy-data case this needs no Delta table and no warehouse:
+     * the default is a MANAGED direct-access index (Databricks embeds the `text`
+     * column on write and query), so seeding is just an `addDocuments` of plain
+     * rows and search-by-text works immediately.
+     */
+    async provision(name, options = {}) {
+        if (this.lakebase) {
+            // Lakebase fallback: no endpoint, no embeddings, no vectors - just a
+            // Postgres full-text table. Returns an IndexInfo-shaped result so the
+            // caller's logging + readiness handling is identical to Vector Search.
+            const rowCount = await this.lakebase.provision(name, {
+                textColumn: options.embeddingSourceColumn ?? "text",
+                ...(options.seed ? { seed: options.seed } : {}),
+                ...(options.signal ? { signal: options.signal } : {}),
+            });
+            return {
+                name,
+                primaryKey: options.primaryKey ?? "id",
+                columns: [],
+                ready: true,
+                rowCount,
+            };
+        }
+        const wait = options.wait ?? true;
+        const timeoutMs = options.timeoutMs ?? 20 * 60 * 1000;
+        const endpoint = options.endpoint ?? this.config.endpoint;
+        if (endpoint)
+            await this.ensureEndpoint(endpoint, { wait, signal: options.signal });
+        const { seed: _seed, wait: _wait, timeoutMs: _timeoutMs, ...createOptions } = options;
+        let info = await this.ensureIndex(name, createOptions);
+        if (wait && !info.ready)
+            info = await this.waitForIndexReady(name, timeoutMs, options.signal);
+        const seed = options.seed ?? [];
+        if (seed.length > 0 && (info.rowCount ?? 0) === 0) {
+            const sourceColumn = options.embeddingSourceColumn ?? "text";
+            const vectorColumn = options.embeddingVectorColumn ?? "embedding";
+            // Direct-access indexes store vectors we supply, so embed the text column
+            // for any seed row that did not already carry a vector.
+            const needEmbed = seed.some((doc) => doc[vectorColumn] === undefined);
+            let rows = seed;
+            if (needEmbed) {
+                const texts = seed.map((doc) => string.trimToEmpty(String(doc[sourceColumn] ?? "")));
+                const vectors = await this.embed(texts, options.embeddingModel, options.signal);
+                rows = seed.map((doc, i) => doc[vectorColumn] === undefined ? { ...doc, [vectorColumn]: vectors[i] } : doc);
+            }
+            await this.addDocuments(name, rows, options.signal);
+            logger.info("index-seeded", { index: name, count: rows.length });
+            info = await this.getIndex(name, options.signal);
+        }
+        return info;
+    }
+    /** Poll an index until it reports ready, or throw after {@link timeoutMs}. */
+    async waitForIndexReady(name, timeoutMs, signal) {
+        const deadline = Date.now() + timeoutMs;
+        let info = await this.getIndex(name, signal);
+        while (!info.ready) {
+            if (Date.now() > deadline) {
+                throw new ExecutionError(`search: index ${name} did not come online in time`, {
+                    context: { operation: "provision" },
+                });
+            }
+            await asyncUtil.sleep(5000, signal);
+            info = await this.getIndex(name, signal);
+        }
+        return info;
+    }
+    /** Trigger a sync of a Delta Sync index from its source table. */
+    async syncIndex(reference, signal) {
+        const name = this.requireIndexName(reference, "syncIndex");
+        await this.withClient("syncIndex", signal, (client, context) => client.vectorSearchIndexes.syncIndex({ index_name: name }, context));
+        logger.info("index-synced", { index: name });
+    }
+    /** Delete an index. */
+    async deleteIndex(reference, signal) {
+        const name = this.requireIndexName(reference, "deleteIndex");
+        await this.withClient("deleteIndex", signal, (client, context) => client.vectorSearchIndexes.deleteIndex({ index_name: name }, context));
+        logger.info("index-deleted", { index: name });
+    }
+    /** List the indexes hosted on a Vector Search endpoint (name + type only). */
+    async listIndexes(endpoint, signal) {
+        const endpointName = endpoint ?? this.config.endpoint;
+        if (!endpointName) {
+            throw new ExecutionError("search: no endpoint configured to list indexes", {
+                context: { operation: "listIndexes" },
+            });
+        }
+        return this.withClient("listIndexes", signal, async (client, context) => {
+            const names = [];
+            for await (const index of client.vectorSearchIndexes.listIndexes({ endpoint_name: endpointName }, context)) {
+                if (index.name)
+                    names.push(index.name);
+            }
+            return names;
+        });
+    }
+    /**
+     * Ensure a Vector Search endpoint exists, creating a `STANDARD` one when it
+     * does not. Optionally wait for it to come online. Idempotent.
+     */
+    async ensureEndpoint(name, options = {}) {
+        const endpoint = name ?? this.config.endpoint;
+        if (!endpoint) {
+            throw new ExecutionError("search: no endpoint name to ensure", {
+                context: { operation: "ensureEndpoint" },
+            });
+        }
+        await this.withClient("ensureEndpoint", options.signal, async (client, context) => {
+            try {
+                await client.vectorSearchEndpoints.getEndpoint({ endpoint_name: endpoint }, context);
+                return;
+            }
+            catch {
+                const waiter = await client.vectorSearchEndpoints.createEndpoint({ name: endpoint, endpoint_type: "STANDARD" }, context);
+                logger.info("endpoint-created", { endpoint });
+                if (options.wait)
+                    await waiter.wait();
+            }
+        });
+    }
+    /**
+     * Resolve the workspace client and run one call under a bounded timeout. The
+     * caller's signal (if any) and a timeout are merged into one SDK `Context`
+     * via {@link appkit.databricks.toContext}, so either unwinds the request.
+     */
+    async withClient(operation, signal, fn) {
+        const client = this.workspaceClientFactory();
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        const context = databricks.toContext(controller, signal);
+        try {
+            return await fn(client, context);
+        }
+        catch (err) {
+            if (signal?.aborted)
+                throw ExecutionError.canceled();
+            logger.warn("execution-failed", { operation });
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/** The OBO workspace client from the active context, or a service-principal client. */
+function defaultWorkspaceClient() {
+    const ctx = appkit.tryGetExecutionContext();
+    if (ctx?.client)
+        return ctx.client;
+    // Outside a request scope (a script, a test): a fresh env-auth client.
+    return getExecutionContext().client;
+}
+/** Construct a {@link SearchClient} from a resolved config. */
+export function createSearchClient(config, workspaceClientFactory, lakebase) {
+    return new SearchClient(config, workspaceClientFactory, lakebase);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A small, Meilisearch-shaped client over Databricks AI Search (Vector\n * Search). The whole point of this module is ergonomics: the Databricks SDK's\n * `vectorSearchIndexes.queryIndex({ index_name, columns, query_text,\n * query_type, num_results, filters_json })` is powerful but verbose, and the\n * response is columnar. This client hides all of that behind two objects:\n *\n * ```ts\n * const client = createSearchClient();\n * const index = client.index(\"main.support.docs\");\n * const { hits } = await index.search(\"reset my password\", { limit: 5 });\n * await index.addDocuments([{ id: \"42\", title: \"Reset\", body: \"...\" }]);\n * ```\n *\n * `client.search(query, opts)` searches the default index; `client.index(name)`\n * returns a handle bound to one index; `client.universalSearch(query)` fans a\n * query across several indexes and merges the results (Meilisearch's federated\n * / multi-search, the \"universal search\" the caller asked for). Everything is\n * async and cancellable, resolves the OBO workspace client from the active\n * AppKit execution context (falling back to a service-principal client outside\n * a request), and returns the browser-safe shapes from\n * `@dbx-tools/shared-search`.\n *\n * Autocomplete is just a search with a small `limit` and the raw query text -\n * hybrid mode already prefix-matches, so no separate endpoint is needed; the\n * {@link SearchIndex.autocomplete} helper is a thin, self-documenting alias.\n *\n * @module\n */\n\nimport { ExecutionError, getExecutionContext } from \"@databricks/appkit\";\nimport { Context } from \"@databricks/sdk-experimental\";\nimport { appkit, databricks } from \"@dbx-tools/appkit\";\nimport { invoke, resolve as modelResolve, serving } from \"@dbx-tools/model\";\nimport type {\n  SearchDocument,\n  SearchHit,\n  SearchMode,\n  SearchResult,\n  UpsertResult,\n} from \"@dbx-tools/shared-search\";\nimport { async as asyncUtil, json, log, string } from \"@dbx-tools/shared-core\";\nimport { ModelClass } from \"@dbx-tools/shared-model\";\nimport {\n  DEFAULT_MODE,\n  DEFAULT_PAGE_SIZE,\n  DEFAULT_TIMEOUT_MS,\n  indexConfigFor,\n  resolveIndexName,\n  type ResolvedSearchConfig,\n} from \"./config.ts\";\nimport {\n  compileFilter,\n  toHits,\n  toQueryType,\n  toRequestColumns,\n  type QueryResponseLike,\n} from \"./query.ts\";\nimport type { LakebaseSearchBackend } from \"./lakebase.ts\";\n\ntype WorkspaceClientLike = appkit.WorkspaceClientLike;\nconst logger = log.logger(\"search/client\");\n\n/** Options accepted by a single-index search. */\nexport interface SearchOptions {\n  /** Maximum hits to return. Defaults to the configured page size. */\n  limit?: number;\n  /** Match mode. Defaults to the configured mode (hybrid). */\n  mode?: SearchMode;\n  /** Columns to return per hit. Defaults to the index's configured columns. */\n  columns?: readonly string[];\n  /** Attribute filters as `{ column: value }` or `{ column: { \">=\": n } }`. */\n  filter?: Record<string, unknown>;\n  /** Drop hits below this score. */\n  scoreThreshold?: number;\n  /** External cancellation. */\n  signal?: AbortSignal;\n}\n\n/** Options accepted by a universal (federated) search. */\nexport interface UniversalSearchOptions {\n  /** Indexes to search. Defaults to every known index. */\n  indexes?: readonly string[];\n  /** Maximum hits per index before merging. */\n  limit?: number;\n  /** Match mode. */\n  mode?: SearchMode;\n  /** External cancellation. */\n  signal?: AbortSignal;\n}\n\n/**\n * A handle bound to one index. Modeled on Meilisearch's `client.index(uid)`:\n * `search` / `autocomplete` read, `addDocuments` / `deleteDocuments` write (to\n * a direct-access index), and `info` fetches the live definition.\n */\nexport class SearchIndex {\n  constructor(\n    readonly name: string,\n    private readonly client: SearchClient,\n  ) {}\n\n  /** Search this index. See {@link SearchClient.search}. */\n  search(query: string, options?: SearchOptions): Promise<SearchResult> {\n    return this.client.search(query, { ...options, index: this.name });\n  }\n\n  /**\n   * Autocomplete against this index: a search with a small default `limit` and\n   * the raw prefix as the query. Hybrid mode already handles prefixes, so this\n   * is a self-documenting alias rather than a separate code path.\n   */\n  autocomplete(prefix: string, options?: SearchOptions): Promise<SearchResult> {\n    return this.search(prefix, { limit: 5, ...options });\n  }\n\n  /** Add or update documents in this (direct-access) index. */\n  addDocuments(documents: SearchDocument[], signal?: AbortSignal): Promise<UpsertResult> {\n    return this.client.addDocuments(this.name, documents, signal);\n  }\n\n  /** Delete documents from this (direct-access) index by primary key. */\n  deleteDocuments(ids: Array<string | number>, signal?: AbortSignal): Promise<UpsertResult> {\n    return this.client.deleteDocuments(this.name, ids, signal);\n  }\n\n  /** Fetch this index's live definition (primary key, columns, readiness). */\n  info(signal?: AbortSignal): Promise<IndexInfo> {\n    return this.client.getIndex(this.name, signal);\n  }\n\n  /** Trigger a sync of this (Delta Sync) index from its source table. */\n  sync(signal?: AbortSignal): Promise<void> {\n    return this.client.syncIndex(this.name, signal);\n  }\n\n  /** Delete this index. */\n  delete(signal?: AbortSignal): Promise<void> {\n    return this.client.deleteIndex(this.name, signal);\n  }\n\n  /** Create this index if it does not exist, otherwise return the existing one. */\n  ensure(options?: CreateIndexOptions): Promise<IndexInfo> {\n    return this.client.ensureIndex(this.name, options);\n  }\n}\n\n/** A resolved live index definition. */\nexport interface IndexInfo {\n  name: string;\n  endpoint?: string;\n  primaryKey?: string;\n  columns: string[];\n  ready: boolean;\n  rowCount?: number;\n  /** True for a DIRECT_ACCESS index (you supply vectors; queries embed client-side). */\n  directAccess?: boolean;\n}\n\n/**\n * Options for {@link SearchClient.createIndex} / {@link SearchClient.ensureIndex}.\n * The goal is the same as the rest of the client: name a source table and a\n * text column, and everything else - the endpoint, the embedding model, the\n * index type, the sync mode - has a sensible default that infers from the\n * workspace, overridable when a deployment needs to go deeper.\n */\nexport interface CreateIndexOptions {\n  /**\n   * Source Delta table (catalog.schema.table) for a Delta Sync index. Provide\n   * this for the common case: Databricks computes and syncs embeddings from it.\n   * Omit it (and pass {@link embeddingDimension}) to create a direct-access\n   * index you write vectors to yourself.\n   */\n  sourceTable?: string;\n  /** Primary-key column. Defaults to `id`. */\n  primaryKey?: string;\n  /**\n   * The text column embeddings are computed from (Delta Sync). Defaults to the\n   * first of `text` / `content` / `body` present, else the caller must set it.\n   */\n  embeddingSourceColumn?: string;\n  /**\n   * Embedding model endpoint. A loose name is fuzzy-matched; when omitted the\n   * best embedding endpoint in the workspace is chosen ({@link resolveEmbeddingModel}).\n   */\n  embeddingModel?: string;\n  /** Vector Search endpoint to host the index on. Defaults to the plugin's `endpoint`. */\n  endpoint?: string;\n  /** For a direct-access index: the embedding vector dimension (self-managed vectors, no source table). */\n  embeddingDimension?: number;\n  /** For a direct-access index: the column the vector is stored in. Defaults to `embedding`. */\n  embeddingVectorColumn?: string;\n  /**\n   * The column-name -> type map used to build a direct-access index's\n   * `schema_json` (types: `string`, `int`, `long`, `float`, `double`,\n   * `boolean`, `date`, `timestamp`). Must include the primary key and any\n   * columns you upsert. Defaults to `{ id: \"string\", text: \"string\" }`. The\n   * embedding vector column is added automatically.\n   */\n  schema?: Record<string, string>;\n  /** Sync mode for a Delta Sync index. `TRIGGERED` (default) syncs on demand; `CONTINUOUS` keeps fresh. */\n  pipelineType?: \"TRIGGERED\" | \"CONTINUOUS\";\n  /** Extra columns to sync alongside the embedding source (Delta Sync). */\n  columnsToSync?: string[];\n  /** External cancellation. */\n  signal?: AbortSignal;\n}\n\n/** Options for {@link SearchClient.ensureEndpoint}. */\nexport interface EnsureEndpointOptions {\n  /** Wait for the endpoint to come online before returning. Defaults to false. */\n  wait?: boolean;\n  /** External cancellation. */\n  signal?: AbortSignal;\n}\n\n/**\n * Options for {@link SearchClient.provision} - a one-call \"make this index real\n * and searchable\" used at boot or in a seed script. It ensures the endpoint,\n * ensures the index, and (optionally) seeds documents when the index is empty.\n */\nexport interface ProvisionOptions extends CreateIndexOptions {\n  /** Documents to seed when the index has no rows yet. Skipped if it already has data. */\n  seed?: SearchDocument[];\n  /**\n   * Wait for the endpoint AND index to come online before returning (needed\n   * before seeding). Defaults to true. Endpoint creation can take many minutes.\n   */\n  wait?: boolean;\n  /** How long to wait for readiness before giving up. Defaults to 20 minutes. */\n  timeoutMs?: number;\n}\n\n/**\n * The AI Search client. Construct it with {@link createSearchClient} (which\n * reads a resolved config) or directly for one-off use. All reads resolve the\n * OBO workspace client from the active execution context.\n */\nexport class SearchClient {\n  constructor(\n    private readonly config: ResolvedSearchConfig = {\n      indexes: [],\n      pageSize: DEFAULT_PAGE_SIZE,\n      mode: DEFAULT_MODE,\n      basePath: \"/api/search\",\n      timeoutMs: DEFAULT_TIMEOUT_MS,\n      allowWrite: false,\n    },\n    private readonly workspaceClientFactory: () => WorkspaceClientLike = defaultWorkspaceClient,\n    /**\n     * Optional Lakebase full-text FALLBACK backend. Present only when no Vector\n     * Search endpoint is configured but a Lakebase pool is available; when set,\n     * search / provision / write operations delegate to it and return the exact\n     * same shapes, so nothing downstream can tell which backend answered.\n     */\n    private readonly lakebase?: LakebaseSearchBackend,\n  ) {}\n\n  /** True when this client is answering out of the Lakebase fallback backend. */\n  get usesLakebase(): boolean {\n    return this.lakebase !== undefined;\n  }\n\n  /** A handle bound to one index (by full UC name or configured alias). */\n  index(reference: string): SearchIndex {\n    const name = resolveIndexName(this.config, reference) ?? reference;\n    return new SearchIndex(name, this);\n  }\n\n  /**\n   * Search one index. `index` may be a full UC name, a configured alias, or\n   * omitted to use the default index. Returns hits sorted most-relevant-first.\n   */\n  async search(\n    query: string,\n    options: SearchOptions & { index?: string } = {},\n  ): Promise<SearchResult> {\n    const text = string.trimToEmpty(query);\n    const name = resolveIndexName(this.config, options.index);\n    if (name === null) {\n      throw new ExecutionError(\"search: no index configured; set a default index or pass one\", {\n        context: { operation: \"search\" },\n      });\n    }\n    if (this.lakebase) {\n      return this.lakebase.search(name, text, {\n        limit: options.limit ?? this.config.pageSize,\n        ...(options.scoreThreshold !== undefined ? { scoreThreshold: options.scoreThreshold } : {}),\n        ...(options.signal ? { signal: options.signal } : {}),\n      });\n    }\n    const known = indexConfigFor(this.config, name);\n    const primaryKey = known?.primaryKey;\n    const columns = toRequestColumns(\n      options.columns,\n      known?.columns ?? this.config.columns,\n      primaryKey,\n    );\n    const mode = options.mode ?? this.config.mode;\n    const limit = options.limit ?? this.config.pageSize;\n\n    // Databricks only manages embeddings for Delta Sync indexes, so a query\n    // against a DIRECT_ACCESS index must carry a query VECTOR, not text. Embed\n    // the query client-side in that case (the index type is cached after the\n    // first lookup so this costs one extra call per index, not per search).\n    const directAccess = await this.isDirectAccess(name, options.signal);\n    const queryVector = directAccess\n      ? (await this.embed([text], this.config.embeddingModel, options.signal))[0]\n      : undefined;\n\n    const response = await this.withClient(\"search\", options.signal, async (client, context) => {\n      return client.vectorSearchIndexes.queryIndex(\n        {\n          index_name: name,\n          columns,\n          ...(queryVector ? { query_vector: queryVector } : { query_text: text }),\n          query_type: toQueryType(mode),\n          num_results: limit,\n          ...(compileFilter(options.filter) ? { filters_json: compileFilter(options.filter) } : {}),\n          ...(options.scoreThreshold !== undefined\n            ? { score_threshold: options.scoreThreshold }\n            : {}),\n        },\n        context,\n      );\n    });\n\n    const hits = toHits(response as QueryResponseLike, primaryKey);\n    return { query: text, index: name, hits, count: hits.length };\n  }\n\n  /** Cache of index-name -> is-DIRECT_ACCESS, so a search embeds its query only when needed. */\n  private readonly directAccessCache = new Map<string, boolean>();\n\n  /** Whether an index is DIRECT_ACCESS (memoized); a lookup failure assumes Delta Sync. */\n  private async isDirectAccess(name: string, signal?: AbortSignal): Promise<boolean> {\n    const cached = this.directAccessCache.get(name);\n    if (cached !== undefined) return cached;\n    try {\n      const info = await this.getIndex(name, signal);\n      const value = info.directAccess ?? false;\n      this.directAccessCache.set(name, value);\n      return value;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Fan a query across several indexes and merge the hits, sorted by score -\n   * the \"universal search\" a single box over many collections needs. Each\n   * index is searched concurrently; an index that errors is logged and skipped\n   * so one bad index does not sink the whole search.\n   */\n  async universalSearch(\n    query: string,\n    options: UniversalSearchOptions = {},\n  ): Promise<SearchResult> {\n    const text = string.trimToEmpty(query);\n    const names =\n      options.indexes && options.indexes.length > 0\n        ? options.indexes.map((ref) => resolveIndexName(this.config, ref) ?? ref)\n        : this.config.indexes.map((i) => i.name);\n    const perIndex = options.limit ?? this.config.pageSize;\n\n    const settled = await Promise.allSettled(\n      names.map(async (name) => {\n        const result = await this.search(text, {\n          index: name,\n          limit: perIndex,\n          ...(options.mode ? { mode: options.mode } : {}),\n          ...(options.signal ? { signal: options.signal } : {}),\n        });\n        return result.hits.map((hit): SearchHit => ({ ...hit, index: name }));\n      }),\n    );\n\n    const hits = settled\n      .flatMap((outcome, i) => {\n        if (outcome.status === \"fulfilled\") return outcome.value;\n        logger.warn(\"universal-index-failed\", { index: names[i] });\n        return [];\n      })\n      .sort((a, b) => b.score - a.score);\n\n    return { query: text, hits, count: hits.length };\n  }\n\n  /**\n   * Resolve an index reference (full UC name or configured alias) to the name\n   * the API expects, failing fast when it resolves to nothing. Without this a\n   * blank reference - what an omitted `index` becomes when no default is\n   * configured - reaches the SDK as an empty `index_name`, which builds a\n   * URL with the name segment missing and comes back as a confusing\n   * `ENDPOINT_NOT_FOUND` instead of naming the real problem.\n   */\n  private requireIndexName(reference: string, operation: string): string {\n    const name = string.trimToNull(resolveIndexName(this.config, reference) ?? reference);\n    if (name === null) {\n      throw new ExecutionError(\n        `search: no index configured; set a default index or pass one to ${operation}`,\n        { context: { operation } },\n      );\n    }\n    return name;\n  }\n\n  /** Fetch an index's live definition. */\n  async getIndex(reference: string, signal?: AbortSignal): Promise<IndexInfo> {\n    const name = this.requireIndexName(reference, \"getIndex\");\n    const index = await this.withClient(\"getIndex\", signal, (client, context) =>\n      client.vectorSearchIndexes.getIndex({ index_name: name }, context),\n    );\n    const directAccess = index.direct_access_index_spec !== undefined;\n    const spec = index.delta_sync_index_spec ?? index.direct_access_index_spec;\n    // Delta Sync surfaces its embedding source columns directly; a direct-access\n    // index carries its columns in schema_json (minus the vector column).\n    let columns = (spec?.embedding_source_columns ?? []).map((c) => c.name ?? \"\").filter(Boolean);\n    const schemaJson = index.direct_access_index_spec?.schema_json;\n    if (directAccess && schemaJson) {\n      const schema = json.parseRecord(schemaJson) ?? {};\n      const vectorNames = new Set(\n        (index.direct_access_index_spec?.embedding_vector_columns ?? [])\n          .map((c) => c.name)\n          .filter((n): n is string => Boolean(n)),\n      );\n      columns = Object.keys(schema).filter((c) => !vectorNames.has(c));\n    }\n    return {\n      name: index.name ?? name,\n      ...(index.endpoint_name ? { endpoint: index.endpoint_name } : {}),\n      ...(index.primary_key ? { primaryKey: index.primary_key } : {}),\n      columns,\n      ready: index.status?.ready ?? false,\n      ...(index.status?.indexed_row_count !== undefined\n        ? { rowCount: index.status.indexed_row_count }\n        : {}),\n      ...(directAccess ? { directAccess: true } : {}),\n    };\n  }\n\n  /** Add or update documents in a direct-access index. */\n  async addDocuments(\n    reference: string,\n    documents: SearchDocument[],\n    signal?: AbortSignal,\n  ): Promise<UpsertResult> {\n    const name = this.requireIndexName(reference, \"addDocuments\");\n    if (this.lakebase) {\n      return this.lakebase.addDocuments(\n        name,\n        documents,\n        this.config.ensureOnSetup?.textColumn ?? \"text\",\n        signal,\n      );\n    }\n    await this.withClient(\"addDocuments\", signal, (client, context) =>\n      client.vectorSearchIndexes.upsertDataVectorIndex(\n        { index_name: name, inputs_json: JSON.stringify(documents) },\n        context,\n      ),\n    );\n    return { index: name, count: documents.length };\n  }\n\n  /** Delete documents from a direct-access index by primary key. */\n  async deleteDocuments(\n    reference: string,\n    ids: Array<string | number>,\n    signal?: AbortSignal,\n  ): Promise<UpsertResult> {\n    const name = this.requireIndexName(reference, \"deleteDocuments\");\n    if (this.lakebase) {\n      return this.lakebase.deleteDocuments(name, ids, signal);\n    }\n    await this.withClient(\"deleteDocuments\", signal, (client, context) =>\n      client.vectorSearchIndexes.deleteDataVectorIndex(\n        { index_name: name, primary_keys: ids.map(String) },\n        context,\n      ),\n    );\n    return { index: name, count: ids.length };\n  }\n\n  /**\n   * Resolve an embedding endpoint id for creating a Delta Sync index. Reuses\n   * the model resolver: a configured / passed name is fuzzy-matched against the\n   * live catalogue, otherwise the highest-ranked embedding endpoint is chosen.\n   */\n  async resolveEmbeddingModel(requested?: string, signal?: AbortSignal): Promise<string | null> {\n    const explicit = string.trimToNull(requested ?? this.config.embeddingModel);\n    // An explicit name that already looks like an endpoint id (no whitespace)\n    // is used verbatim - no need to fetch and fuzzy-match the live catalogue.\n    // A genuinely loose name (e.g. \"gte large\") still resolves against it.\n    if (explicit && !/\\s/.test(explicit)) return explicit;\n    return this.withClient(\"resolveEmbeddingModel\", signal, async (client) => {\n      const host = (await client.config.getHost()).toString();\n      const endpoints = await serving.listServingEndpoints(client, host);\n      const { modelId } = modelResolve.resolveModel(endpoints, {\n        ...(explicit ? { explicit } : { modelClass: ModelClass.Embedding }),\n      });\n      return string.trimToNull(modelId);\n    });\n  }\n\n  /**\n   * Embed text via a Databricks embedding serving endpoint, returning one\n   * vector per input. Used to seed a direct-access index and to turn a search\n   * query into a query vector - Databricks only manages embeddings for Delta\n   * Sync indexes, so a direct-access index (no Delta table, no warehouse) needs\n   * the client to embed on write and on query. The endpoint is resolved the\n   * same way as for index creation when not named.\n   */\n  async embed(texts: string[], model?: string, signal?: AbortSignal): Promise<number[][]> {\n    if (texts.length === 0) return [];\n    const endpoint = await this.resolveEmbeddingModel(model, signal);\n    if (!endpoint) {\n      throw new ExecutionError(\"search: could not resolve an embedding model to embed text\", {\n        context: { operation: \"embed\" },\n      });\n    }\n    return this.withClient(\"embed\", signal, async (client) => {\n      const host = (await client.config.getHost()).toString();\n      const url = invoke.invocationsUrl(host, endpoint);\n      const headers = await invoke.authHeaders(client);\n      const response = await fetch(url, {\n        method: \"POST\",\n        headers: { ...headers, \"content-type\": \"application/json\" },\n        body: JSON.stringify({ input: texts }),\n        ...(signal ? { signal } : {}),\n      });\n      if (!response.ok) {\n        throw new ExecutionError(\n          `search: embedding endpoint ${endpoint} failed (${response.status})`,\n          { context: { operation: \"embed\" } },\n        );\n      }\n      const body = (await response.json()) as { data?: Array<{ embedding: number[] }> };\n      const vectors = (body.data ?? []).map((row) => row.embedding);\n      if (vectors.length !== texts.length) {\n        throw new ExecutionError(\"search: embedding response did not match the input count\", {\n          context: { operation: \"embed\" },\n        });\n      }\n      return vectors;\n    });\n  }\n\n  /** The vector dimension a model produces (embeds a probe string once). */\n  private async embeddingDimension(model?: string, signal?: AbortSignal): Promise<number> {\n    const [vector] = await this.embed([\"dimension probe\"], model, signal);\n    if (!vector || vector.length === 0) {\n      throw new ExecutionError(\"search: could not determine the embedding dimension\", {\n        context: { operation: \"createIndex\" },\n      });\n    }\n    return vector.length;\n  }\n\n  /**\n   * Create an AI Search index with as little ceremony as possible. Two shapes:\n   *\n   *   - **Delta Sync** (the default): pass `sourceTable`; Databricks computes\n   *     embeddings from the text column and keeps the index synced. The\n   *     embedding model is resolved automatically when not named.\n   *   - **Direct Access**: omit `sourceTable` and pass `embeddingDimension`;\n   *     you write vectors yourself via {@link addDocuments}.\n   *\n   * Everything else infers: the endpoint from the plugin config, the primary\n   * key (`id`), the text column (`text` / `content` / `body`), and the vector\n   * column (`embedding`). Returns the created index's {@link IndexInfo}.\n   */\n  async createIndex(name: string, options: CreateIndexOptions = {}): Promise<IndexInfo> {\n    const endpoint = options.endpoint ?? this.config.endpoint;\n    if (!endpoint) {\n      throw new ExecutionError(\n        \"search: no Vector Search endpoint configured; pass `endpoint` or set it on the plugin\",\n        { context: { operation: \"createIndex\" } },\n      );\n    }\n    const primaryKey = options.primaryKey ?? \"id\";\n    const direct = !options.sourceTable;\n    const sourceColumn = options.embeddingSourceColumn ?? \"text\";\n    const vectorColumn = options.embeddingVectorColumn ?? \"embedding\";\n\n    // Delta Sync lets Databricks embed a source column, so it needs an embedding\n    // model. A direct-access index stores vectors YOU supply (Databricks only\n    // supports managed embeddings on Delta Sync), so it needs a dimension; we\n    // resolve one from the embedding model when not given so a direct-access\n    // index still works with zero extra config (embed via `embed()` on seed +\n    // query - see `provision` / `search`).\n    const embeddingModel =\n      (await this.resolveEmbeddingModel(options.embeddingModel, options.signal)) ?? undefined;\n    if (!embeddingModel) {\n      throw new ExecutionError(\n        \"search: could not resolve an embedding model; pass `embeddingModel`\",\n        { context: { operation: \"createIndex\" } },\n      );\n    }\n    const dimension =\n      options.embeddingDimension ?? (await this.embeddingDimension(embeddingModel, options.signal));\n\n    const schema = {\n      [primaryKey]: \"string\",\n      [sourceColumn]: \"string\",\n      ...(options.schema ?? {}),\n    };\n\n    const directSpec = {\n      direct_access_index_spec: {\n        embedding_vector_columns: [{ name: vectorColumn, embedding_dimension: dimension }],\n        schema_json: JSON.stringify({ ...schema, [vectorColumn]: `array<float>` }),\n      },\n    };\n\n    await this.withClient(\"createIndex\", options.signal, (client, context) =>\n      client.vectorSearchIndexes.createIndex(\n        {\n          name,\n          endpoint_name: endpoint,\n          primary_key: primaryKey,\n          index_type: direct ? \"DIRECT_ACCESS\" : \"DELTA_SYNC\",\n          ...(direct\n            ? directSpec\n            : {\n                delta_sync_index_spec: {\n                  source_table: options.sourceTable,\n                  pipeline_type: options.pipelineType ?? \"TRIGGERED\",\n                  embedding_source_columns: [\n                    { name: sourceColumn, embedding_model_endpoint_name: embeddingModel },\n                  ],\n                  ...(options.columnsToSync && options.columnsToSync.length > 0\n                    ? { columns_to_sync: options.columnsToSync }\n                    : {}),\n                },\n              }),\n        },\n        context,\n      ),\n    );\n    logger.info(\"index-created\", {\n      index: name,\n      endpoint,\n      type: direct ? \"DIRECT_ACCESS\" : \"DELTA_SYNC\",\n    });\n    return this.getIndex(name, options.signal);\n  }\n\n  /**\n   * Create the index if it does not already exist, otherwise return the\n   * existing one. Idempotent - safe to call on every boot to guarantee an\n   * index is present.\n   */\n  async ensureIndex(name: string, options: CreateIndexOptions = {}): Promise<IndexInfo> {\n    try {\n      return await this.getIndex(name, options.signal);\n    } catch {\n      return this.createIndex(name, options);\n    }\n  }\n\n  /**\n   * Ensure an index exists, is online, and (optionally) holds seed data - the\n   * \"wire up a real index on boot\" path. Idempotent and cheap to call every\n   * boot: it creates the endpoint and index only if missing, waits for them to\n   * come online, and seeds documents ONLY when the index is still empty.\n   *\n   * For the demo/dummy-data case this needs no Delta table and no warehouse:\n   * the default is a MANAGED direct-access index (Databricks embeds the `text`\n   * column on write and query), so seeding is just an `addDocuments` of plain\n   * rows and search-by-text works immediately.\n   */\n  async provision(name: string, options: ProvisionOptions = {}): Promise<IndexInfo> {\n    if (this.lakebase) {\n      // Lakebase fallback: no endpoint, no embeddings, no vectors - just a\n      // Postgres full-text table. Returns an IndexInfo-shaped result so the\n      // caller's logging + readiness handling is identical to Vector Search.\n      const rowCount = await this.lakebase.provision(name, {\n        textColumn: options.embeddingSourceColumn ?? \"text\",\n        ...(options.seed ? { seed: options.seed } : {}),\n        ...(options.signal ? { signal: options.signal } : {}),\n      });\n      return {\n        name,\n        primaryKey: options.primaryKey ?? \"id\",\n        columns: [],\n        ready: true,\n        rowCount,\n      };\n    }\n    const wait = options.wait ?? true;\n    const timeoutMs = options.timeoutMs ?? 20 * 60 * 1000;\n    const endpoint = options.endpoint ?? this.config.endpoint;\n    if (endpoint) await this.ensureEndpoint(endpoint, { wait, signal: options.signal });\n\n    const { seed: _seed, wait: _wait, timeoutMs: _timeoutMs, ...createOptions } = options;\n    let info = await this.ensureIndex(name, createOptions);\n\n    if (wait && !info.ready) info = await this.waitForIndexReady(name, timeoutMs, options.signal);\n\n    const seed = options.seed ?? [];\n    if (seed.length > 0 && (info.rowCount ?? 0) === 0) {\n      const sourceColumn = options.embeddingSourceColumn ?? \"text\";\n      const vectorColumn = options.embeddingVectorColumn ?? \"embedding\";\n      // Direct-access indexes store vectors we supply, so embed the text column\n      // for any seed row that did not already carry a vector.\n      const needEmbed = seed.some((doc) => doc[vectorColumn] === undefined);\n      let rows = seed;\n      if (needEmbed) {\n        const texts = seed.map((doc) => string.trimToEmpty(String(doc[sourceColumn] ?? \"\")));\n        const vectors = await this.embed(texts, options.embeddingModel, options.signal);\n        rows = seed.map((doc, i) =>\n          doc[vectorColumn] === undefined ? { ...doc, [vectorColumn]: vectors[i] } : doc,\n        );\n      }\n      await this.addDocuments(name, rows, options.signal);\n      logger.info(\"index-seeded\", { index: name, count: rows.length });\n      info = await this.getIndex(name, options.signal);\n    }\n    return info;\n  }\n\n  /** Poll an index until it reports ready, or throw after {@link timeoutMs}. */\n  private async waitForIndexReady(\n    name: string,\n    timeoutMs: number,\n    signal?: AbortSignal,\n  ): Promise<IndexInfo> {\n    const deadline = Date.now() + timeoutMs;\n    let info = await this.getIndex(name, signal);\n    while (!info.ready) {\n      if (Date.now() > deadline) {\n        throw new ExecutionError(`search: index ${name} did not come online in time`, {\n          context: { operation: \"provision\" },\n        });\n      }\n      await asyncUtil.sleep(5000, signal);\n      info = await this.getIndex(name, signal);\n    }\n    return info;\n  }\n\n  /** Trigger a sync of a Delta Sync index from its source table. */\n  async syncIndex(reference: string, signal?: AbortSignal): Promise<void> {\n    const name = this.requireIndexName(reference, \"syncIndex\");\n    await this.withClient(\"syncIndex\", signal, (client, context) =>\n      client.vectorSearchIndexes.syncIndex({ index_name: name }, context),\n    );\n    logger.info(\"index-synced\", { index: name });\n  }\n\n  /** Delete an index. */\n  async deleteIndex(reference: string, signal?: AbortSignal): Promise<void> {\n    const name = this.requireIndexName(reference, \"deleteIndex\");\n    await this.withClient(\"deleteIndex\", signal, (client, context) =>\n      client.vectorSearchIndexes.deleteIndex({ index_name: name }, context),\n    );\n    logger.info(\"index-deleted\", { index: name });\n  }\n\n  /** List the indexes hosted on a Vector Search endpoint (name + type only). */\n  async listIndexes(endpoint?: string, signal?: AbortSignal): Promise<string[]> {\n    const endpointName = endpoint ?? this.config.endpoint;\n    if (!endpointName) {\n      throw new ExecutionError(\"search: no endpoint configured to list indexes\", {\n        context: { operation: \"listIndexes\" },\n      });\n    }\n    return this.withClient(\"listIndexes\", signal, async (client, context) => {\n      const names: string[] = [];\n      for await (const index of client.vectorSearchIndexes.listIndexes(\n        { endpoint_name: endpointName },\n        context,\n      )) {\n        if (index.name) names.push(index.name);\n      }\n      return names;\n    });\n  }\n\n  /**\n   * Ensure a Vector Search endpoint exists, creating a `STANDARD` one when it\n   * does not. Optionally wait for it to come online. Idempotent.\n   */\n  async ensureEndpoint(name?: string, options: EnsureEndpointOptions = {}): Promise<void> {\n    const endpoint = name ?? this.config.endpoint;\n    if (!endpoint) {\n      throw new ExecutionError(\"search: no endpoint name to ensure\", {\n        context: { operation: \"ensureEndpoint\" },\n      });\n    }\n    await this.withClient(\"ensureEndpoint\", options.signal, async (client, context) => {\n      try {\n        await client.vectorSearchEndpoints.getEndpoint({ endpoint_name: endpoint }, context);\n        return;\n      } catch {\n        const waiter = await client.vectorSearchEndpoints.createEndpoint(\n          { name: endpoint, endpoint_type: \"STANDARD\" },\n          context,\n        );\n        logger.info(\"endpoint-created\", { endpoint });\n        if (options.wait) await waiter.wait();\n      }\n    });\n  }\n\n  /**\n   * Resolve the workspace client and run one call under a bounded timeout. The\n   * caller's signal (if any) and a timeout are merged into one SDK `Context`\n   * via {@link appkit.databricks.toContext}, so either unwinds the request.\n   */\n  private async withClient<T>(\n    operation: string,\n    signal: AbortSignal | undefined,\n    fn: (client: WorkspaceClientLike, context?: Context) => Promise<T>,\n  ): Promise<T> {\n    const client = this.workspaceClientFactory();\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);\n    const context = databricks.toContext(controller, signal);\n    try {\n      return await fn(client, context);\n    } catch (err) {\n      if (signal?.aborted) throw ExecutionError.canceled();\n      logger.warn(\"execution-failed\", { operation });\n      throw err;\n    } finally {\n      clearTimeout(timer);\n    }\n  }\n}\n\n/** The OBO workspace client from the active context, or a service-principal client. */\nfunction defaultWorkspaceClient(): WorkspaceClientLike {\n  const ctx = appkit.tryGetExecutionContext();\n  if (ctx?.client) return ctx.client;\n  // Outside a request scope (a script, a test): a fresh env-auth client.\n  return getExecutionContext().client;\n}\n\n/** Construct a {@link SearchClient} from a resolved config. */\nexport function createSearchClient(\n  config?: ResolvedSearchConfig,\n  workspaceClientFactory?: () => WorkspaceClientLike,\n  lakebase?: LakebaseSearchBackend,\n): SearchClient {\n  return new SearchClient(config, workspaceClientFactory, lakebase);\n}\n"]}