@dbx-tools/search 0.6.9

package/lib/src/config.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Configuration for the AI Search plugin: the typed
+ * {@link SearchPluginConfig} (the plugin's slice of AppKit config), the JSON
+ * Schema the manifest publishes for it, and {@link resolveSearchConfig}
+ * which layers that config over environment defaults into the concrete
+ * {@link ResolvedSearchConfig} the runtime, client, tools, and routes read.
+ *
+ * The design goal is "one index, zero config": name a default index (or set
+ * `DATABRICKS_VECTOR_SEARCH_INDEX`) and everything else - the columns to
+ * return, the page size, the match mode, the mounted route path, the embedding
+ * model used when creating an index - has a sensible default that can be
+ * overridden when a deployment needs to go deeper.
+ *
+ * Which index / endpoint is used follows the standard precedence: explicit
+ * plugin config, then environment, then a default.
+ *
+ * Env fallbacks: `DATABRICKS_VECTOR_SEARCH_INDEX` (the default index),
+ * `SEARCH_INDEX`, `SEARCH_ENDPOINT`, `SEARCH_COLUMNS`,
+ * `SEARCH_PAGE_SIZE`, `SEARCH_MODE`, `SEARCH_EMBEDDING_MODEL`,
+ * `SEARCH_TIMEOUT_MS`, `SEARCH_WRITE`.
+ *
+ * @module
+ */
+import { type BasePluginConfig } from "@databricks/appkit";
+import type { SearchDocument, SearchMode } from "@dbx-tools/shared-search";
+import type { JSONSchema7 } from "json-schema";
+/** The default index, honoring AppKit's standard Vector Search binding name. */
+export declare const INDEX_ENV = "SEARCH_INDEX";
+/** AppKit's standard environment name for a Vector Search index binding. */
+export declare const DATABRICKS_INDEX_ENV = "DATABRICKS_VECTOR_SEARCH_INDEX";
+/** Dedicated override for the Vector Search serving endpoint that hosts indexes. */
+export declare const ENDPOINT_ENV = "SEARCH_ENDPOINT";
+/** Default match mode when a request does not name one. Hybrid suits most search boxes. */
+export declare const DEFAULT_MODE: SearchMode;
+/** Default number of hits a search returns (a good autocomplete / results-list size). */
+export declare const DEFAULT_PAGE_SIZE = 10;
+/** Default per-call timeout for a search / index operation. */
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+/** Base path the plugin mounts its routes under, unless overridden. */
+export declare const DEFAULT_BASE_PATH = "/api/search";
+/**
+ * A configured index the plugin knows about ahead of time. Only `name` (or
+ * `alias`) is required; the rest is resolved from the live index definition
+ * when omitted, so a deployment can register `{ name }` and let the plugin fill
+ * in the primary key and columns.
+ */
+export interface SearchIndexConfig {
+    /** Unity Catalog name of the index (catalog.schema.index). */
+    name: string;
+    /** Short alias a caller may use in place of `name` (defaults to the last name segment). */
+    alias?: string;
+    /** Primary-key column. Resolved from the index definition when omitted. */
+    primaryKey?: string;
+    /** Columns to return per hit, in display order. Defaults to every indexed column. */
+    columns?: string[];
+}
+/**
+ * The AI Search plugin's slice of AppKit config. Every field is optional - the
+ * plugin works with nothing but an index name in the environment.
+ */
+export interface SearchPluginConfig extends BasePluginConfig {
+    /** The default index searched when a request omits one (name or alias). */
+    index?: string;
+    /** Indexes the plugin should know about (for aliases, universal search, and the UI catalogue). */
+    indexes?: Array<string | SearchIndexConfig>;
+    /** The Vector Search serving endpoint indexes live on (only needed to create an index). */
+    endpoint?: string;
+    /** Default columns to return per hit. Falls back to each index's own columns. */
+    columns?: string[];
+    /** Default number of hits a search returns. */
+    pageSize?: number;
+    /** Default match mode. */
+    mode?: SearchMode;
+    /** Embedding model endpoint used when the plugin CREATES a Delta Sync index. Fuzzy-resolved. */
+    embeddingModel?: string;
+    /** Per-call timeout in milliseconds. */
+    timeoutMs?: number;
+    /** Enable the write surface (`add_documents` tool + `POST /documents`). Off by default. */
+    allowWrite?: boolean;
+    /**
+     * Provision a REAL index at boot: ensure the endpoint + index exist and seed
+     * documents when the index is empty. Runs in the background during `setup()`
+     * (a slow first-time endpoint/index build never blocks the server) using the
+     * boot-time SDK auth (env / config profile). Idempotent - safe every boot.
+     *
+     * The default is a MANAGED direct-access index (Databricks embeds the text
+     * column), so `documents` are plain rows and search-by-text works with no
+     * Delta table, no warehouse, and no vectors to compute. Point it at a
+     * `sourceTable` to provision a Delta Sync index instead.
+     */
+    ensureOnSetup?: EnsureOnSetupConfig;
+}
+/** Boot-time provisioning + seeding for a single index (see `ensureOnSetup`). */
+export interface EnsureOnSetupConfig {
+    /** UC name of the index to ensure (catalog.schema.index). Defaults to the plugin's `index`. */
+    index?: string;
+    /** Vector Search endpoint to host it on. Defaults to the plugin's `endpoint`. */
+    endpoint?: string;
+    /** Primary-key column. Defaults to `id`. */
+    primaryKey?: string;
+    /** Text column Databricks embeds (managed direct-access). Defaults to `text`. */
+    textColumn?: string;
+    /** Embedding model endpoint. Fuzzy-matched; defaults to the best embedding endpoint. */
+    embeddingModel?: string;
+    /** For a Delta Sync index instead of managed direct-access: the source Delta table. */
+    sourceTable?: string;
+    /** Column -> type map for the managed direct-access `schema_json`. Inferred from `documents` when omitted. */
+    schema?: Record<string, string>;
+    /** Documents to seed when the index is empty. Plain `{ id, text, ... }` rows for a managed index. */
+    documents?: SearchDocument[];
+    /** Max time to wait for endpoint + index readiness. Defaults to 20 minutes. */
+    timeoutMs?: number;
+}
+/** A fully resolved index entry (the plugin-known form). */
+export interface ResolvedIndexConfig {
+    name: string;
+    alias: string;
+    primaryKey?: string;
+    columns?: string[];
+}
+/** The concrete config the runtime, client, tools, and routes read. */
+export interface ResolvedSearchConfig {
+    defaultIndex?: string;
+    indexes: ResolvedIndexConfig[];
+    endpoint?: string;
+    columns?: string[];
+    pageSize: number;
+    mode: SearchMode;
+    embeddingModel?: string;
+    basePath: string;
+    timeoutMs: number;
+    allowWrite: boolean;
+    ensureOnSetup?: EnsureOnSetupConfig;
+}
+/** JSON Schema the plugin manifest publishes for {@link SearchPluginConfig}. */
+export declare const SEARCH_CONFIG_SCHEMA: JSONSchema7;
+/** Derive the default alias for an index name (its last dotted segment). */
+export declare function defaultAlias(name: string): string;
+/**
+ * Resolve plugin config over environment defaults into the concrete
+ * {@link ResolvedSearchConfig}. The default index is unioned into the known
+ * indexes so it always appears in the catalogue, aliases are de-duplicated,
+ * and a bad mode throws a {@link ConfigurationError} naming the field.
+ */
+export declare function resolveSearchConfig(config?: SearchPluginConfig): ResolvedSearchConfig;
+/**
+ * Resolve a caller-supplied index reference (a full UC name or a configured
+ * alias) into a concrete index name. Falls back to the default index when the
+ * reference is empty. Returns `null` when nothing can be resolved so callers
+ * raise a stable, user-facing error rather than calling a phantom index.
+ */
+export declare function resolveIndexName(config: ResolvedSearchConfig, reference: string | undefined): string | null;
+/** The known config for an index name, when the plugin was told about it. */
+export declare function indexConfigFor(config: ResolvedSearchConfig, name: string): ResolvedIndexConfig | undefined;

package/lib/src/config.js

@@ -0,0 +1,225 @@
+/**
+ * Configuration for the AI Search plugin: the typed
+ * {@link SearchPluginConfig} (the plugin's slice of AppKit config), the JSON
+ * Schema the manifest publishes for it, and {@link resolveSearchConfig}
+ * which layers that config over environment defaults into the concrete
+ * {@link ResolvedSearchConfig} the runtime, client, tools, and routes read.
+ *
+ * The design goal is "one index, zero config": name a default index (or set
+ * `DATABRICKS_VECTOR_SEARCH_INDEX`) and everything else - the columns to
+ * return, the page size, the match mode, the mounted route path, the embedding
+ * model used when creating an index - has a sensible default that can be
+ * overridden when a deployment needs to go deeper.
+ *
+ * Which index / endpoint is used follows the standard precedence: explicit
+ * plugin config, then environment, then a default.
+ *
+ * Env fallbacks: `DATABRICKS_VECTOR_SEARCH_INDEX` (the default index),
+ * `SEARCH_INDEX`, `SEARCH_ENDPOINT`, `SEARCH_COLUMNS`,
+ * `SEARCH_PAGE_SIZE`, `SEARCH_MODE`, `SEARCH_EMBEDDING_MODEL`,
+ * `SEARCH_TIMEOUT_MS`, `SEARCH_WRITE`.
+ *
+ * @module
+ */
+import { ConfigurationError } from "@databricks/appkit";
+import { object, string } from "@dbx-tools/shared-core";
+/** The default index, honoring AppKit's standard Vector Search binding name. */
+export const INDEX_ENV = "SEARCH_INDEX";
+/** AppKit's standard environment name for a Vector Search index binding. */
+export const DATABRICKS_INDEX_ENV = "DATABRICKS_VECTOR_SEARCH_INDEX";
+/** Dedicated override for the Vector Search serving endpoint that hosts indexes. */
+export const ENDPOINT_ENV = "SEARCH_ENDPOINT";
+/** Default match mode when a request does not name one. Hybrid suits most search boxes. */
+export const DEFAULT_MODE = "hybrid";
+/** Default number of hits a search returns (a good autocomplete / results-list size). */
+export const DEFAULT_PAGE_SIZE = 10;
+/** Default per-call timeout for a search / index operation. */
+export const DEFAULT_TIMEOUT_MS = 30_000;
+/** Base path the plugin mounts its routes under, unless overridden. */
+export const DEFAULT_BASE_PATH = "/api/search";
+/** JSON Schema the plugin manifest publishes for {@link SearchPluginConfig}. */
+export const SEARCH_CONFIG_SCHEMA = {
+    type: "object",
+    additionalProperties: true,
+    properties: {
+        index: {
+            type: "string",
+            description: "Default index to search (catalog.schema.index or a configured alias).",
+        },
+        indexes: {
+            type: "array",
+            description: "Indexes the plugin knows about, for aliases, universal search, and the UI.",
+            items: {
+                oneOf: [
+                    { type: "string" },
+                    {
+                        type: "object",
+                        required: ["name"],
+                        properties: {
+                            name: { type: "string" },
+                            alias: { type: "string" },
+                            primaryKey: { type: "string" },
+                            columns: { type: "array", items: { type: "string" } },
+                        },
+                    },
+                ],
+            },
+        },
+        endpoint: {
+            type: "string",
+            description: "Vector Search serving endpoint indexes live on (needed only to create one).",
+        },
+        columns: {
+            type: "array",
+            items: { type: "string" },
+            description: "Default columns to return.",
+        },
+        pageSize: { type: "number", description: "Default number of hits per search." },
+        mode: { enum: ["hybrid", "vector", "keyword"], description: "Default match mode." },
+        embeddingModel: {
+            type: "string",
+            description: "Embedding endpoint used when creating a Delta Sync index (fuzzy-matched).",
+        },
+        timeoutMs: { type: "number", description: "Per-call timeout in milliseconds." },
+        allowWrite: {
+            type: "boolean",
+            description: "Enable the document write surface (add_documents tool + route).",
+        },
+        ensureOnSetup: {
+            type: "object",
+            description: "Provision a real index at boot: ensure the endpoint + index exist and seed " +
+                "documents when empty. Runs in the background during setup using boot-time auth.",
+            additionalProperties: true,
+            properties: {
+                index: { type: "string" },
+                endpoint: { type: "string" },
+                primaryKey: { type: "string" },
+                textColumn: { type: "string" },
+                embeddingModel: { type: "string" },
+                sourceTable: { type: "string" },
+                schema: { type: "object", additionalProperties: { type: "string" } },
+                documents: { type: "array", items: { type: "object", additionalProperties: true } },
+                timeoutMs: { type: "number" },
+            },
+        },
+    },
+};
+/** Derive the default alias for an index name (its last dotted segment). */
+export function defaultAlias(name) {
+    const segments = name.split(".").filter(Boolean);
+    return segments.length > 0 ? segments[segments.length - 1] : name;
+}
+/** Normalize a config index entry (string or object) into a {@link ResolvedIndexConfig}. */
+function toResolvedIndex(entry) {
+    const raw = typeof entry === "string" ? { name: entry } : entry;
+    const name = string.trimToNull(raw.name);
+    if (name === null)
+        return null;
+    return {
+        name,
+        alias: string.trimToNull(raw.alias) ?? defaultAlias(name),
+        ...(raw.primaryKey ? { primaryKey: raw.primaryKey } : {}),
+        ...(raw.columns && raw.columns.length > 0 ? { columns: [...raw.columns] } : {}),
+    };
+}
+/** Coerce a positive integer from config or an env var, falling back to a default. */
+function resolvePositiveInt(configured, envVar, fallback) {
+    const raw = configured ?? Number(process.env[envVar]);
+    const value = Number(raw);
+    if (Number.isFinite(value) && value > 0)
+        return Math.floor(value);
+    return fallback;
+}
+/** Parse and validate a {@link SearchMode} from config or an env var. */
+function resolveMode(configured) {
+    const raw = configured ?? string.trimToNull(process.env.SEARCH_MODE) ?? undefined;
+    if (raw === undefined)
+        return DEFAULT_MODE;
+    if (raw !== "hybrid" && raw !== "vector" && raw !== "keyword") {
+        throw new ConfigurationError('mode must be "hybrid", "vector" or "keyword" (env: SEARCH_MODE)', { context: { field: "mode", envVar: "SEARCH_MODE" } });
+    }
+    return raw;
+}
+/**
+ * Resolve plugin config over environment defaults into the concrete
+ * {@link ResolvedSearchConfig}. The default index is unioned into the known
+ * indexes so it always appears in the catalogue, aliases are de-duplicated,
+ * and a bad mode throws a {@link ConfigurationError} naming the field.
+ */
+export function resolveSearchConfig(config = {}) {
+    const defaultIndexRaw = string.trimToNull(config.index) ??
+        string.trimToNull(process.env[INDEX_ENV]) ??
+        string.trimToNull(process.env[DATABRICKS_INDEX_ENV]) ??
+        undefined;
+    const configured = (config.indexes ?? [])
+        .map(toResolvedIndex)
+        .filter((entry) => entry !== null);
+    // Ensure the default index is represented in the known set.
+    if (defaultIndexRaw && !configured.some((i) => i.name === defaultIndexRaw)) {
+        const fromEnv = string.parseList(process.env.SEARCH_COLUMNS);
+        configured.unshift({
+            name: defaultIndexRaw,
+            alias: defaultAlias(defaultIndexRaw),
+            ...(fromEnv.length > 0 ? { columns: fromEnv } : {}),
+        });
+    }
+    const seenAliases = new Set();
+    const indexes = configured.map((entry) => {
+        let alias = entry.alias;
+        while (seenAliases.has(alias))
+            alias = `${alias}_`;
+        seenAliases.add(alias);
+        return { ...entry, alias };
+    });
+    const defaultIndex = defaultIndexRaw ?? indexes[0]?.name;
+    const columns = config.columns ?? string.parseList(process.env.SEARCH_COLUMNS);
+    return {
+        ...(defaultIndex ? { defaultIndex } : {}),
+        indexes,
+        ...((string.trimToNull(config.endpoint) ?? string.trimToNull(process.env[ENDPOINT_ENV]))
+            ? {
+                endpoint: string.trimToNull(config.endpoint) ??
+                    string.trimToNull(process.env[ENDPOINT_ENV]) ??
+                    undefined,
+            }
+            : {}),
+        ...(columns.length > 0 ? { columns } : {}),
+        pageSize: resolvePositiveInt(config.pageSize, "SEARCH_PAGE_SIZE", DEFAULT_PAGE_SIZE),
+        mode: resolveMode(config.mode),
+        ...((string.trimToNull(config.embeddingModel) ??
+            string.trimToNull(process.env.SEARCH_EMBEDDING_MODEL))
+            ? {
+                embeddingModel: string.trimToNull(config.embeddingModel) ??
+                    string.trimToNull(process.env.SEARCH_EMBEDDING_MODEL) ??
+                    undefined,
+            }
+            : {}),
+        basePath: DEFAULT_BASE_PATH,
+        timeoutMs: resolvePositiveInt(config.timeoutMs, "SEARCH_TIMEOUT_MS", DEFAULT_TIMEOUT_MS),
+        allowWrite: config.allowWrite ?? object.toBoolean(process.env.SEARCH_WRITE) ?? false,
+        ...(config.ensureOnSetup ? { ensureOnSetup: config.ensureOnSetup } : {}),
+    };
+}
+/**
+ * Resolve a caller-supplied index reference (a full UC name or a configured
+ * alias) into a concrete index name. Falls back to the default index when the
+ * reference is empty. Returns `null` when nothing can be resolved so callers
+ * raise a stable, user-facing error rather than calling a phantom index.
+ */
+export function resolveIndexName(config, reference) {
+    const ref = string.trimToNull(reference);
+    if (ref === null)
+        return config.defaultIndex ?? null;
+    const byAlias = config.indexes.find((i) => i.alias === ref || i.name === ref);
+    if (byAlias)
+        return byAlias.name;
+    // Accept an unregistered but fully-qualified UC name (three dotted parts).
+    if (ref.split(".").filter(Boolean).length === 3)
+        return ref;
+    return config.defaultIndex ?? null;
+}
+/** The known config for an index name, when the plugin was told about it. */
+export function indexConfigFor(config, name) {
+    return config.indexes.find((i) => i.name === name || i.alias === name);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,kBAAkB,EAAyB,MAAM,oBAAoB,CAAC;AAE/E,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGxD,gFAAgF;AAChF,MAAM,CAAC,MAAM,SAAS,GAAG,cAAc,CAAC;AAExC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAErE,oFAAoF;AACpF,MAAM,CAAC,MAAM,YAAY,GAAG,iBAAiB,CAAC;AAE9C,2FAA2F;AAC3F,MAAM,CAAC,MAAM,YAAY,GAAe,QAAQ,CAAC;AAEjD,yFAAyF;AACzF,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAEpC,+DAA+D;AAC/D,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAEzC,uEAAuE;AACvE,MAAM,CAAC,MAAM,iBAAiB,GAAG,aAAa,CAAC;AAqG/C,gFAAgF;AAChF,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,IAAI;IAC1B,UAAU,EAAE;QACV,KAAK,EAAE;YACL,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,uEAAuE;SACrF;QACD,OAAO,EAAE;YACP,IAAI,EAAE,OAAO;YACb,WAAW,EAAE,4EAA4E;YACzF,KAAK,EAAE;gBACL,KAAK,EAAE;oBACL,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAClB;wBACE,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,CAAC,MAAM,CAAC;wBAClB,UAAU,EAAE;4BACV,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;4BACxB,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;4BACzB,UAAU,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;4BAC9B,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;yBACtD;qBACF;iBACF;aACF;SACF;QACD,QAAQ,EAAE;YACR,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,6EAA6E;SAC3F;QACD,OAAO,EAAE;YACP,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YACzB,WAAW,EAAE,4BAA4B;SAC1C;QACD,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,oCAAoC,EAAE;QAC/E,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,WAAW,EAAE,qBAAqB,EAAE;QACnF,cAAc,EAAE;YACd,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,2EAA2E;SACzF;QACD,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,mCAAmC,EAAE;QAC/E,UAAU,EAAE;YACV,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,iEAAiE;SAC/E;QACD,aAAa,EAAE;YACb,IAAI,EAAE,QAAQ;YACd,WAAW,EACT,6EAA6E;gBAC7E,iFAAiF;YACnF,oBAAoB,EAAE,IAAI;YAC1B,UAAU,EAAE;gBACV,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBACzB,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC5B,UAAU,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC9B,UAAU,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC9B,cAAc,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAClC,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gBAC/B,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;gBACpE,SAAS,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,EAAE;gBACnF,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;aAC9B;SACF;KACF;CACF,CAAC;AAEF,4EAA4E;AAC5E,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACjD,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACpE,CAAC;AAED,4FAA4F;AAC5F,SAAS,eAAe,CAAC,KAAiC;IACxD,MAAM,GAAG,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IAChE,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO;QACL,IAAI;QACJ,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC;QACzD,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACzD,GAAG,CAAC,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAChF,CAAC;AACJ,CAAC;AAED,sFAAsF;AACtF,SAAS,kBAAkB,CACzB,UAA8B,EAC9B,MAAc,EACd,QAAgB;IAEhB,MAAM,GAAG,GAAG,UAAU,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACtD,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClE,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,yEAAyE;AACzE,SAAS,WAAW,CAAC,UAAkC;IACrD,MAAM,GAAG,GAAG,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,SAAS,CAAC;IAClF,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,YAAY,CAAC;IAC3C,IAAI,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QAC9D,MAAM,IAAI,kBAAkB,CAC1B,iEAAiE,EACjE,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,CACtD,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAA6B,EAAE;IACjE,MAAM,eAAe,GACnB,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC;QAC/B,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QACpD,SAAS,CAAC;IAEZ,MAAM,UAAU,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC;SACtC,GAAG,CAAC,eAAe,CAAC;SACpB,MAAM,CAAC,CAAC,KAAK,EAAgC,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;IAEnE,4DAA4D;IAC5D,IAAI,eAAe,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,eAAe,CAAC,EAAE,CAAC;QAC3E,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC7D,UAAU,CAAC,OAAO,CAAC;YACjB,IAAI,EAAE,eAAe;YACrB,KAAK,EAAE,YAAY,CAAC,eAAe,CAAC;YACpC,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACpD,CAAC,CAAC;IACL,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IACtC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACvC,IAAI,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACxB,OAAO,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,KAAK,GAAG,GAAG,KAAK,GAAG,CAAC;QACnD,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACvB,OAAO,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,CAAC;IAC7B,CAAC,CAAC,CAAC;IAEH,MAAM,YAAY,GAAG,eAAe,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;IACzD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAE/E,OAAO;QACL,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,OAAO;QACP,GAAG,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;YACtF,CAAC,CAAC;gBACE,QAAQ,EACN,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC;oBAClC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;oBAC5C,SAAS;aACZ;YACH,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1C,QAAQ,EAAE,kBAAkB,CAAC,MAAM,CAAC,QAAQ,EAAE,kBAAkB,EAAE,iBAAiB,CAAC;QACpF,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC;QAC9B,GAAG,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,CAAC;YAC7C,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC;YACpD,CAAC,CAAC;gBACE,cAAc,EACZ,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,CAAC;oBACxC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC;oBACrD,SAAS;aACZ;YACH,CAAC,CAAC,EAAE,CAAC;QACP,QAAQ,EAAE,iBAAiB;QAC3B,SAAS,EAAE,kBAAkB,CAAC,MAAM,CAAC,SAAS,EAAE,mBAAmB,EAAE,kBAAkB,CAAC;QACxF,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,KAAK;QACpF,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACzE,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAA4B,EAC5B,SAA6B;IAE7B,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACzC,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,YAAY,IAAI,IAAI,CAAC;IACrD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,GAAG,IAAI,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;IAC9E,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC,IAAI,CAAC;IACjC,2EAA2E;IAC3E,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAC5D,OAAO,MAAM,CAAC,YAAY,IAAI,IAAI,CAAC;AACrC,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,cAAc,CAC5B,MAA4B,EAC5B,IAAY;IAEZ,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;AACzE,CAAC","sourcesContent":["/**\n * Configuration for the AI Search plugin: the typed\n * {@link SearchPluginConfig} (the plugin's slice of AppKit config), the JSON\n * Schema the manifest publishes for it, and {@link resolveSearchConfig}\n * which layers that config over environment defaults into the concrete\n * {@link ResolvedSearchConfig} the runtime, client, tools, and routes read.\n *\n * The design goal is \"one index, zero config\": name a default index (or set\n * `DATABRICKS_VECTOR_SEARCH_INDEX`) and everything else - the columns to\n * return, the page size, the match mode, the mounted route path, the embedding\n * model used when creating an index - has a sensible default that can be\n * overridden when a deployment needs to go deeper.\n *\n * Which index / endpoint is used follows the standard precedence: explicit\n * plugin config, then environment, then a default.\n *\n * Env fallbacks: `DATABRICKS_VECTOR_SEARCH_INDEX` (the default index),\n * `SEARCH_INDEX`, `SEARCH_ENDPOINT`, `SEARCH_COLUMNS`,\n * `SEARCH_PAGE_SIZE`, `SEARCH_MODE`, `SEARCH_EMBEDDING_MODEL`,\n * `SEARCH_TIMEOUT_MS`, `SEARCH_WRITE`.\n *\n * @module\n */\n\nimport { ConfigurationError, type BasePluginConfig } from \"@databricks/appkit\";\nimport type { SearchDocument, SearchMode } from \"@dbx-tools/shared-search\";\nimport { object, string } from \"@dbx-tools/shared-core\";\nimport type { JSONSchema7 } from \"json-schema\";\n\n/** The default index, honoring AppKit's standard Vector Search binding name. */\nexport const INDEX_ENV = \"SEARCH_INDEX\";\n\n/** AppKit's standard environment name for a Vector Search index binding. */\nexport const DATABRICKS_INDEX_ENV = \"DATABRICKS_VECTOR_SEARCH_INDEX\";\n\n/** Dedicated override for the Vector Search serving endpoint that hosts indexes. */\nexport const ENDPOINT_ENV = \"SEARCH_ENDPOINT\";\n\n/** Default match mode when a request does not name one. Hybrid suits most search boxes. */\nexport const DEFAULT_MODE: SearchMode = \"hybrid\";\n\n/** Default number of hits a search returns (a good autocomplete / results-list size). */\nexport const DEFAULT_PAGE_SIZE = 10;\n\n/** Default per-call timeout for a search / index operation. */\nexport const DEFAULT_TIMEOUT_MS = 30_000;\n\n/** Base path the plugin mounts its routes under, unless overridden. */\nexport const DEFAULT_BASE_PATH = \"/api/search\";\n\n/**\n * A configured index the plugin knows about ahead of time. Only `name` (or\n * `alias`) is required; the rest is resolved from the live index definition\n * when omitted, so a deployment can register `{ name }` and let the plugin fill\n * in the primary key and columns.\n */\nexport interface SearchIndexConfig {\n  /** Unity Catalog name of the index (catalog.schema.index). */\n  name: string;\n  /** Short alias a caller may use in place of `name` (defaults to the last name segment). */\n  alias?: string;\n  /** Primary-key column. Resolved from the index definition when omitted. */\n  primaryKey?: string;\n  /** Columns to return per hit, in display order. Defaults to every indexed column. */\n  columns?: string[];\n}\n\n/**\n * The AI Search plugin's slice of AppKit config. Every field is optional - the\n * plugin works with nothing but an index name in the environment.\n */\nexport interface SearchPluginConfig extends BasePluginConfig {\n  /** The default index searched when a request omits one (name or alias). */\n  index?: string;\n  /** Indexes the plugin should know about (for aliases, universal search, and the UI catalogue). */\n  indexes?: Array<string | SearchIndexConfig>;\n  /** The Vector Search serving endpoint indexes live on (only needed to create an index). */\n  endpoint?: string;\n  /** Default columns to return per hit. Falls back to each index's own columns. */\n  columns?: string[];\n  /** Default number of hits a search returns. */\n  pageSize?: number;\n  /** Default match mode. */\n  mode?: SearchMode;\n  /** Embedding model endpoint used when the plugin CREATES a Delta Sync index. Fuzzy-resolved. */\n  embeddingModel?: string;\n  /** Per-call timeout in milliseconds. */\n  timeoutMs?: number;\n  /** Enable the write surface (`add_documents` tool + `POST /documents`). Off by default. */\n  allowWrite?: boolean;\n  /**\n   * Provision a REAL index at boot: ensure the endpoint + index exist and seed\n   * documents when the index is empty. Runs in the background during `setup()`\n   * (a slow first-time endpoint/index build never blocks the server) using the\n   * boot-time SDK auth (env / config profile). Idempotent - safe every boot.\n   *\n   * The default is a MANAGED direct-access index (Databricks embeds the text\n   * column), so `documents` are plain rows and search-by-text works with no\n   * Delta table, no warehouse, and no vectors to compute. Point it at a\n   * `sourceTable` to provision a Delta Sync index instead.\n   */\n  ensureOnSetup?: EnsureOnSetupConfig;\n}\n\n/** Boot-time provisioning + seeding for a single index (see `ensureOnSetup`). */\nexport interface EnsureOnSetupConfig {\n  /** UC name of the index to ensure (catalog.schema.index). Defaults to the plugin's `index`. */\n  index?: string;\n  /** Vector Search endpoint to host it on. Defaults to the plugin's `endpoint`. */\n  endpoint?: string;\n  /** Primary-key column. Defaults to `id`. */\n  primaryKey?: string;\n  /** Text column Databricks embeds (managed direct-access). Defaults to `text`. */\n  textColumn?: string;\n  /** Embedding model endpoint. Fuzzy-matched; defaults to the best embedding endpoint. */\n  embeddingModel?: string;\n  /** For a Delta Sync index instead of managed direct-access: the source Delta table. */\n  sourceTable?: string;\n  /** Column -> type map for the managed direct-access `schema_json`. Inferred from `documents` when omitted. */\n  schema?: Record<string, string>;\n  /** Documents to seed when the index is empty. Plain `{ id, text, ... }` rows for a managed index. */\n  documents?: SearchDocument[];\n  /** Max time to wait for endpoint + index readiness. Defaults to 20 minutes. */\n  timeoutMs?: number;\n}\n\n/** A fully resolved index entry (the plugin-known form). */\nexport interface ResolvedIndexConfig {\n  name: string;\n  alias: string;\n  primaryKey?: string;\n  columns?: string[];\n}\n\n/** The concrete config the runtime, client, tools, and routes read. */\nexport interface ResolvedSearchConfig {\n  defaultIndex?: string;\n  indexes: ResolvedIndexConfig[];\n  endpoint?: string;\n  columns?: string[];\n  pageSize: number;\n  mode: SearchMode;\n  embeddingModel?: string;\n  basePath: string;\n  timeoutMs: number;\n  allowWrite: boolean;\n  ensureOnSetup?: EnsureOnSetupConfig;\n}\n\n/** JSON Schema the plugin manifest publishes for {@link SearchPluginConfig}. */\nexport const SEARCH_CONFIG_SCHEMA: JSONSchema7 = {\n  type: \"object\",\n  additionalProperties: true,\n  properties: {\n    index: {\n      type: \"string\",\n      description: \"Default index to search (catalog.schema.index or a configured alias).\",\n    },\n    indexes: {\n      type: \"array\",\n      description: \"Indexes the plugin knows about, for aliases, universal search, and the UI.\",\n      items: {\n        oneOf: [\n          { type: \"string\" },\n          {\n            type: \"object\",\n            required: [\"name\"],\n            properties: {\n              name: { type: \"string\" },\n              alias: { type: \"string\" },\n              primaryKey: { type: \"string\" },\n              columns: { type: \"array\", items: { type: \"string\" } },\n            },\n          },\n        ],\n      },\n    },\n    endpoint: {\n      type: \"string\",\n      description: \"Vector Search serving endpoint indexes live on (needed only to create one).\",\n    },\n    columns: {\n      type: \"array\",\n      items: { type: \"string\" },\n      description: \"Default columns to return.\",\n    },\n    pageSize: { type: \"number\", description: \"Default number of hits per search.\" },\n    mode: { enum: [\"hybrid\", \"vector\", \"keyword\"], description: \"Default match mode.\" },\n    embeddingModel: {\n      type: \"string\",\n      description: \"Embedding endpoint used when creating a Delta Sync index (fuzzy-matched).\",\n    },\n    timeoutMs: { type: \"number\", description: \"Per-call timeout in milliseconds.\" },\n    allowWrite: {\n      type: \"boolean\",\n      description: \"Enable the document write surface (add_documents tool + route).\",\n    },\n    ensureOnSetup: {\n      type: \"object\",\n      description:\n        \"Provision a real index at boot: ensure the endpoint + index exist and seed \" +\n        \"documents when empty. Runs in the background during setup using boot-time auth.\",\n      additionalProperties: true,\n      properties: {\n        index: { type: \"string\" },\n        endpoint: { type: \"string\" },\n        primaryKey: { type: \"string\" },\n        textColumn: { type: \"string\" },\n        embeddingModel: { type: \"string\" },\n        sourceTable: { type: \"string\" },\n        schema: { type: \"object\", additionalProperties: { type: \"string\" } },\n        documents: { type: \"array\", items: { type: \"object\", additionalProperties: true } },\n        timeoutMs: { type: \"number\" },\n      },\n    },\n  },\n};\n\n/** Derive the default alias for an index name (its last dotted segment). */\nexport function defaultAlias(name: string): string {\n  const segments = name.split(\".\").filter(Boolean);\n  return segments.length > 0 ? segments[segments.length - 1] : name;\n}\n\n/** Normalize a config index entry (string or object) into a {@link ResolvedIndexConfig}. */\nfunction toResolvedIndex(entry: string | SearchIndexConfig): ResolvedIndexConfig | null {\n  const raw = typeof entry === \"string\" ? { name: entry } : entry;\n  const name = string.trimToNull(raw.name);\n  if (name === null) return null;\n  return {\n    name,\n    alias: string.trimToNull(raw.alias) ?? defaultAlias(name),\n    ...(raw.primaryKey ? { primaryKey: raw.primaryKey } : {}),\n    ...(raw.columns && raw.columns.length > 0 ? { columns: [...raw.columns] } : {}),\n  };\n}\n\n/** Coerce a positive integer from config or an env var, falling back to a default. */\nfunction resolvePositiveInt(\n  configured: number | undefined,\n  envVar: string,\n  fallback: number,\n): number {\n  const raw = configured ?? Number(process.env[envVar]);\n  const value = Number(raw);\n  if (Number.isFinite(value) && value > 0) return Math.floor(value);\n  return fallback;\n}\n\n/** Parse and validate a {@link SearchMode} from config or an env var. */\nfunction resolveMode(configured: SearchMode | undefined): SearchMode {\n  const raw = configured ?? string.trimToNull(process.env.SEARCH_MODE) ?? undefined;\n  if (raw === undefined) return DEFAULT_MODE;\n  if (raw !== \"hybrid\" && raw !== \"vector\" && raw !== \"keyword\") {\n    throw new ConfigurationError(\n      'mode must be \"hybrid\", \"vector\" or \"keyword\" (env: SEARCH_MODE)',\n      { context: { field: \"mode\", envVar: \"SEARCH_MODE\" } },\n    );\n  }\n  return raw;\n}\n\n/**\n * Resolve plugin config over environment defaults into the concrete\n * {@link ResolvedSearchConfig}. The default index is unioned into the known\n * indexes so it always appears in the catalogue, aliases are de-duplicated,\n * and a bad mode throws a {@link ConfigurationError} naming the field.\n */\nexport function resolveSearchConfig(config: SearchPluginConfig = {}): ResolvedSearchConfig {\n  const defaultIndexRaw =\n    string.trimToNull(config.index) ??\n    string.trimToNull(process.env[INDEX_ENV]) ??\n    string.trimToNull(process.env[DATABRICKS_INDEX_ENV]) ??\n    undefined;\n\n  const configured = (config.indexes ?? [])\n    .map(toResolvedIndex)\n    .filter((entry): entry is ResolvedIndexConfig => entry !== null);\n\n  // Ensure the default index is represented in the known set.\n  if (defaultIndexRaw && !configured.some((i) => i.name === defaultIndexRaw)) {\n    const fromEnv = string.parseList(process.env.SEARCH_COLUMNS);\n    configured.unshift({\n      name: defaultIndexRaw,\n      alias: defaultAlias(defaultIndexRaw),\n      ...(fromEnv.length > 0 ? { columns: fromEnv } : {}),\n    });\n  }\n\n  const seenAliases = new Set<string>();\n  const indexes = configured.map((entry) => {\n    let alias = entry.alias;\n    while (seenAliases.has(alias)) alias = `${alias}_`;\n    seenAliases.add(alias);\n    return { ...entry, alias };\n  });\n\n  const defaultIndex = defaultIndexRaw ?? indexes[0]?.name;\n  const columns = config.columns ?? string.parseList(process.env.SEARCH_COLUMNS);\n\n  return {\n    ...(defaultIndex ? { defaultIndex } : {}),\n    indexes,\n    ...((string.trimToNull(config.endpoint) ?? string.trimToNull(process.env[ENDPOINT_ENV]))\n      ? {\n          endpoint:\n            string.trimToNull(config.endpoint) ??\n            string.trimToNull(process.env[ENDPOINT_ENV]) ??\n            undefined,\n        }\n      : {}),\n    ...(columns.length > 0 ? { columns } : {}),\n    pageSize: resolvePositiveInt(config.pageSize, \"SEARCH_PAGE_SIZE\", DEFAULT_PAGE_SIZE),\n    mode: resolveMode(config.mode),\n    ...((string.trimToNull(config.embeddingModel) ??\n    string.trimToNull(process.env.SEARCH_EMBEDDING_MODEL))\n      ? {\n          embeddingModel:\n            string.trimToNull(config.embeddingModel) ??\n            string.trimToNull(process.env.SEARCH_EMBEDDING_MODEL) ??\n            undefined,\n        }\n      : {}),\n    basePath: DEFAULT_BASE_PATH,\n    timeoutMs: resolvePositiveInt(config.timeoutMs, \"SEARCH_TIMEOUT_MS\", DEFAULT_TIMEOUT_MS),\n    allowWrite: config.allowWrite ?? object.toBoolean(process.env.SEARCH_WRITE) ?? false,\n    ...(config.ensureOnSetup ? { ensureOnSetup: config.ensureOnSetup } : {}),\n  };\n}\n\n/**\n * Resolve a caller-supplied index reference (a full UC name or a configured\n * alias) into a concrete index name. Falls back to the default index when the\n * reference is empty. Returns `null` when nothing can be resolved so callers\n * raise a stable, user-facing error rather than calling a phantom index.\n */\nexport function resolveIndexName(\n  config: ResolvedSearchConfig,\n  reference: string | undefined,\n): string | null {\n  const ref = string.trimToNull(reference);\n  if (ref === null) return config.defaultIndex ?? null;\n  const byAlias = config.indexes.find((i) => i.alias === ref || i.name === ref);\n  if (byAlias) return byAlias.name;\n  // Accept an unregistered but fully-qualified UC name (three dotted parts).\n  if (ref.split(\".\").filter(Boolean).length === 3) return ref;\n  return config.defaultIndex ?? null;\n}\n\n/** The known config for an index name, when the plugin was told about it. */\nexport function indexConfigFor(\n  config: ResolvedSearchConfig,\n  name: string,\n): ResolvedIndexConfig | undefined {\n  return config.indexes.find((i) => i.name === name || i.alias === name);\n}\n"]}

package/lib/src/index-tools.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared translation from the browser-safe {@link CreateIndexRequest} wire
+ * shape onto the client's {@link CreateIndexOptions}. Lives in its own module
+ * because both the Mastra `create_index` tool (`tool.ts`) and the AppKit tool
+ * provider (`plugin.ts`) build the same options object, and the mapping (which
+ * optional fields to spread, folding in the abort signal) is easy to let drift
+ * between the two.
+ *
+ * @module
+ */
+import type { CreateIndexRequest } from "@dbx-tools/shared-search";
+import type { CreateIndexOptions } from "./client.ts";
+/**
+ * Map a validated {@link CreateIndexRequest} onto {@link CreateIndexOptions},
+ * spreading only the fields that were supplied so the client's own defaults
+ * (endpoint, embedding model, primary key, text column) still apply, and
+ * folding in the caller's abort signal.
+ */
+export declare function toCreateIndexOptions(request: CreateIndexRequest, signal?: AbortSignal): CreateIndexOptions;

package/lib/src/index-tools.js

@@ -0,0 +1,34 @@
+/**
+ * Shared translation from the browser-safe {@link CreateIndexRequest} wire
+ * shape onto the client's {@link CreateIndexOptions}. Lives in its own module
+ * because both the Mastra `create_index` tool (`tool.ts`) and the AppKit tool
+ * provider (`plugin.ts`) build the same options object, and the mapping (which
+ * optional fields to spread, folding in the abort signal) is easy to let drift
+ * between the two.
+ *
+ * @module
+ */
+/**
+ * Map a validated {@link CreateIndexRequest} onto {@link CreateIndexOptions},
+ * spreading only the fields that were supplied so the client's own defaults
+ * (endpoint, embedding model, primary key, text column) still apply, and
+ * folding in the caller's abort signal.
+ */
+export function toCreateIndexOptions(request, signal) {
+    return {
+        ...(request.sourceTable ? { sourceTable: request.sourceTable } : {}),
+        ...(request.primaryKey ? { primaryKey: request.primaryKey } : {}),
+        ...(request.embeddingSourceColumn
+            ? { embeddingSourceColumn: request.embeddingSourceColumn }
+            : {}),
+        ...(request.embeddingModel ? { embeddingModel: request.embeddingModel } : {}),
+        ...(request.endpoint ? { endpoint: request.endpoint } : {}),
+        ...(request.embeddingDimension !== undefined
+            ? { embeddingDimension: request.embeddingDimension }
+            : {}),
+        ...(request.pipelineType ? { pipelineType: request.pipelineType } : {}),
+        ...(request.columnsToSync ? { columnsToSync: request.columnsToSync } : {}),
+        ...(signal ? { signal } : {}),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/lakebase.d.ts

@@ -0,0 +1,86 @@
+/**
+ * A Lakebase (Postgres) full-text search backend - the FALLBACK used when no
+ * Databricks Vector Search endpoint/index is configured but a Lakebase pool is
+ * available. It provisions a single table per index, indexes a generated
+ * `tsvector`, and answers queries with `websearch_to_tsquery` + `ts_rank`.
+ *
+ * The whole point is parity: this backend returns the EXACT same
+ * `@dbx-tools/shared-search` shapes (`SearchResult` / `SearchHit` /
+ * `UpsertResult`) as the Vector Search backend, so the client, the Mastra
+ * tools, the routes, and the React search box cannot tell which one answered.
+ * A hit's `id` is the primary key, its `score` is the text-rank, and `fields`
+ * is the stored document minus the internal columns.
+ *
+ * The Postgres pool is built the same way `@dbx-tools/appkit-mastra` builds its
+ * memory pool: the AppKit `lakebase` plugin resolves a service-principal
+ * `PoolConfig` (connection target + OAuth token-refresh `password` callback),
+ * and this backend constructs a `pg.Pool` from it. It never re-implements auth.
+ *
+ * @module
+ */
+import { Pool, type PoolConfig } from "pg";
+import type { SearchDocument, SearchResult, UpsertResult } from "@dbx-tools/shared-search";
+/** Options for a single-index Lakebase search (mirrors the client's `SearchOptions`). */
+export interface LakebaseSearchOptions {
+    limit?: number;
+    scoreThreshold?: number;
+    signal?: AbortSignal;
+}
+/** Options for provisioning a Lakebase-backed index. */
+export interface LakebaseProvisionOptions {
+    /** Text column embedded into the search vector. Defaults to `text`. */
+    textColumn?: string;
+    /** Documents to seed when the table is empty. */
+    seed?: SearchDocument[];
+    signal?: AbortSignal;
+}
+/**
+ * A Postgres full-text backend. One instance is shared across indexes; each
+ * index maps to a table whose name is derived from the index reference.
+ */
+export declare class LakebaseSearchBackend {
+    private readonly pgConfigFactory;
+    private readonly schema;
+    /** How a pool is built from the resolved config. Overridable for tests. */
+    private readonly poolFactory;
+    private pool;
+    private poolPromise;
+    private readonly provisioned;
+    constructor(pgConfigFactory: () => Promise<PoolConfig> | PoolConfig, schema?: string, 
+    /** How a pool is built from the resolved config. Overridable for tests. */
+    poolFactory?: (config: PoolConfig) => Pool);
+    /** Lazily build (and cache) the pg pool from the resolved Lakebase config. */
+    private getPool;
+    /** Close the pool so a restarted app rebuilds it. */
+    close(): Promise<void>;
+    /**
+     * Search a Lakebase-backed index. Returns hits sorted most-relevant-first,
+     * shaped identically to the Vector Search backend.
+     */
+    search(index: string, query: string, options?: LakebaseSearchOptions): Promise<SearchResult>;
+    /**
+     * Ensure the table + full-text index exist and seed documents when empty.
+     * Idempotent, so it is safe to call on every boot.
+     */
+    provision(index: string, options?: LakebaseProvisionOptions): Promise<number>;
+    /** Add or update documents by primary key. */
+    addDocuments(index: string, documents: SearchDocument[], textColumn?: string, signal?: AbortSignal): Promise<UpsertResult>;
+    /** Delete documents by primary key. */
+    deleteDocuments(index: string, ids: Array<string | number>, signal?: AbortSignal): Promise<UpsertResult>;
+    /** Create the table + GIN index once per table (memoized across calls). */
+    private ensureTable;
+    /** Upsert rows: the whole document as jsonb + a flattened text blob to index. */
+    private upsert;
+    /** The text a row is indexed by: the text column first, then any other string field. */
+    private searchText;
+    /** A hit's `fields`: the stored document minus the reserved/internal keys. */
+    private toFields;
+    /** The fully-qualified table name for an index reference. */
+    private tableFor;
+    /** A safe bare table name derived from an index reference. */
+    private bareName;
+    /** Quote a Postgres identifier. */
+    private ident;
+    /** Run one query under external cancellation. */
+    private query;
+}