@dbx-tools/search 0.6.9

package/lib/src/lakebase.js

@@ -0,0 +1,218 @@
+/**
+ * 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 { ExecutionError } from "@databricks/appkit";
+import { log, object, string } from "@dbx-tools/shared-core";
+import { Pool } from "pg";
+const logger = log.logger("search/lakebase");
+/** The internal columns every search table carries, excluded from a hit's `fields`. */
+const RESERVED_COLUMNS = new Set(["id", "search_text", "document", "search_vector"]);
+/**
+ * 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 class LakebaseSearchBackend {
+    pgConfigFactory;
+    schema;
+    poolFactory;
+    pool;
+    poolPromise;
+    provisioned = new Set();
+    constructor(pgConfigFactory, schema = "public", 
+    /** How a pool is built from the resolved config. Overridable for tests. */
+    poolFactory = (config) => new Pool(config)) {
+        this.pgConfigFactory = pgConfigFactory;
+        this.schema = schema;
+        this.poolFactory = poolFactory;
+    }
+    /** Lazily build (and cache) the pg pool from the resolved Lakebase config. */
+    async getPool() {
+        if (this.pool)
+            return this.pool;
+        this.poolPromise ??= (async () => {
+            const config = await this.pgConfigFactory();
+            const pool = this.poolFactory(config);
+            this.pool = pool;
+            return pool;
+        })();
+        return this.poolPromise;
+    }
+    /** Close the pool so a restarted app rebuilds it. */
+    async close() {
+        const pool = this.pool;
+        this.pool = undefined;
+        this.poolPromise = undefined;
+        this.provisioned.clear();
+        if (pool)
+            await pool.end();
+    }
+    /**
+     * Search a Lakebase-backed index. Returns hits sorted most-relevant-first,
+     * shaped identically to the Vector Search backend.
+     */
+    async search(index, query, options = {}) {
+        const text = string.trimToEmpty(query);
+        const table = this.tableFor(index);
+        const limit = options.limit ?? 10;
+        const pool = await this.getPool();
+        // `websearch_to_tsquery` accepts a bare search box string (quoted phrases,
+        // `or`, `-term`); an empty query returns the most recent rows so an empty
+        // search box still shows content, matching a keyword index's behavior.
+        const sql = text
+            ? `SELECT id, document, ts_rank(search_vector, websearch_to_tsquery('english', $1)) AS score
+           FROM ${table}
+          WHERE search_vector @@ websearch_to_tsquery('english', $1)
+          ORDER BY score DESC
+          LIMIT $2`
+            : `SELECT id, document, 0::float4 AS score FROM ${table} ORDER BY id LIMIT $2`;
+        const params = text ? [text, limit] : [limit];
+        const { rows } = await this.query(pool, sql, params, options.signal);
+        const hits = rows
+            .map((row) => ({
+            id: String(row.id),
+            score: Number(row.score) || 0,
+            fields: this.toFields(row.document),
+        }))
+            .filter((hit) => options.scoreThreshold === undefined || hit.score >= options.scoreThreshold);
+        return { query: text, index, hits, count: hits.length };
+    }
+    /**
+     * Ensure the table + full-text index exist and seed documents when empty.
+     * Idempotent, so it is safe to call on every boot.
+     */
+    async provision(index, options = {}) {
+        const table = this.tableFor(index);
+        const pool = await this.getPool();
+        await this.ensureTable(pool, table, options.signal);
+        const { rows } = await this.query(pool, `SELECT count(*)::text AS count FROM ${table}`, [], options.signal);
+        const existing = Number(rows[0]?.count ?? "0");
+        const seed = options.seed ?? [];
+        if (existing === 0 && seed.length > 0) {
+            await this.upsert(pool, table, seed, options.textColumn ?? "text", options.signal);
+            logger.info("index-seeded", { index, table, count: seed.length });
+            return seed.length;
+        }
+        return existing;
+    }
+    /** Add or update documents by primary key. */
+    async addDocuments(index, documents, textColumn = "text", signal) {
+        const table = this.tableFor(index);
+        const pool = await this.getPool();
+        await this.ensureTable(pool, table, signal);
+        await this.upsert(pool, table, documents, textColumn, signal);
+        return { index, count: documents.length };
+    }
+    /** Delete documents by primary key. */
+    async deleteDocuments(index, ids, signal) {
+        const table = this.tableFor(index);
+        const pool = await this.getPool();
+        await this.query(pool, `DELETE FROM ${table} WHERE id = ANY($1)`, [ids.map(String)], signal);
+        return { index, count: ids.length };
+    }
+    /** Create the table + GIN index once per table (memoized across calls). */
+    async ensureTable(pool, table, signal) {
+        if (this.provisioned.has(table))
+            return;
+        // `document` holds the whole row; `search_text` is the indexed text; the
+        // generated `search_vector` keeps the tsvector in lockstep with it so a
+        // write never has to compute the vector by hand.
+        await this.query(pool, `CREATE SCHEMA IF NOT EXISTS ${this.ident(this.schema)}`, [], signal);
+        await this.query(pool, `CREATE TABLE IF NOT EXISTS ${table} (
+         id text PRIMARY KEY,
+         search_text text NOT NULL DEFAULT '',
+         document jsonb NOT NULL DEFAULT '{}'::jsonb,
+         search_vector tsvector GENERATED ALWAYS AS (to_tsvector('english', search_text)) STORED
+       )`, [], signal);
+        await this.query(pool, `CREATE INDEX IF NOT EXISTS ${this.ident(`${this.bareName(table)}_fts`)}
+         ON ${table} USING gin (search_vector)`, [], signal);
+        this.provisioned.add(table);
+        logger.info("index-created", { table });
+    }
+    /** Upsert rows: the whole document as jsonb + a flattened text blob to index. */
+    async upsert(pool, table, documents, textColumn, signal) {
+        for (const doc of documents) {
+            const id = string.trimToNull(String(doc.id ?? doc.ID ?? "")) ?? undefined;
+            if (id === undefined) {
+                throw new ExecutionError("search (lakebase): a document is missing an `id`", {
+                    context: { operation: "addDocuments" },
+                });
+            }
+            const searchText = this.searchText(doc, textColumn);
+            await this.query(pool, `INSERT INTO ${table} (id, search_text, document)
+           VALUES ($1, $2, $3::jsonb)
+         ON CONFLICT (id) DO UPDATE
+           SET search_text = EXCLUDED.search_text, document = EXCLUDED.document`, [id, searchText, JSON.stringify(doc)], signal);
+        }
+    }
+    /** The text a row is indexed by: the text column first, then any other string field. */
+    searchText(doc, textColumn) {
+        const primary = string.trimToEmpty(String(doc[textColumn] ?? ""));
+        const rest = Object.entries(doc)
+            .filter(([key, value]) => key !== textColumn && key !== "id" && typeof value === "string")
+            .map(([, value]) => value);
+        return [primary, ...rest].filter(Boolean).join("\n");
+    }
+    /** A hit's `fields`: the stored document minus the reserved/internal keys. */
+    toFields(document) {
+        if (!object.isRecord(document))
+            return {};
+        const fields = {};
+        for (const [key, value] of Object.entries(document)) {
+            if (RESERVED_COLUMNS.has(key))
+                continue;
+            fields[key] = value;
+        }
+        return fields;
+    }
+    /** The fully-qualified table name for an index reference. */
+    tableFor(index) {
+        return `${this.ident(this.schema)}.${this.ident(this.bareName(index))}`;
+    }
+    /** A safe bare table name derived from an index reference. */
+    bareName(reference) {
+        const last = reference.split(".").filter(Boolean).pop() ?? reference;
+        const slug = last
+            .toLowerCase()
+            .replace(/[^a-z0-9_]+/g, "_")
+            .replace(/^_+|_+$/g, "");
+        return slug.length > 0 ? slug : "documents";
+    }
+    /** Quote a Postgres identifier. */
+    ident(name) {
+        return `"${name.replace(/"/g, '""')}"`;
+    }
+    /** Run one query under external cancellation. */
+    async query(pool, sql, params, signal) {
+        if (signal?.aborted)
+            throw ExecutionError.canceled();
+        const client = await pool.connect();
+        const onAbort = () => void client.release(true);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+            const result = await client.query(sql, params);
+            return { rows: result.rows };
+        }
+        finally {
+            signal?.removeEventListener("abort", onAbort);
+            client.release();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lakebase.js","sourceRoot":"","sources":["../../src/lakebase.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A Lakebase (Postgres) full-text search backend - the FALLBACK used when no\n * Databricks Vector Search endpoint/index is configured but a Lakebase pool is\n * available. It provisions a single table per index, indexes a generated\n * `tsvector`, and answers queries with `websearch_to_tsquery` + `ts_rank`.\n *\n * The whole point is parity: this backend returns the EXACT same\n * `@dbx-tools/shared-search` shapes (`SearchResult` / `SearchHit` /\n * `UpsertResult`) as the Vector Search backend, so the client, the Mastra\n * tools, the routes, and the React search box cannot tell which one answered.\n * A hit's `id` is the primary key, its `score` is the text-rank, and `fields`\n * is the stored document minus the internal columns.\n *\n * The Postgres pool is built the same way `@dbx-tools/appkit-mastra` builds its\n * memory pool: the AppKit `lakebase` plugin resolves a service-principal\n * `PoolConfig` (connection target + OAuth token-refresh `password` callback),\n * and this backend constructs a `pg.Pool` from it. It never re-implements auth.\n *\n * @module\n */\n\nimport { ExecutionError } from \"@databricks/appkit\";\nimport { log, object, string } from \"@dbx-tools/shared-core\";\nimport { Pool, type PoolConfig } from \"pg\";\nimport type {\n  SearchDocument,\n  SearchHit,\n  SearchResult,\n  UpsertResult,\n} from \"@dbx-tools/shared-search\";\n\nconst logger = log.logger(\"search/lakebase\");\n\n/** The internal columns every search table carries, excluded from a hit's `fields`. */\nconst RESERVED_COLUMNS = new Set([\"id\", \"search_text\", \"document\", \"search_vector\"]);\n\n/** Options for a single-index Lakebase search (mirrors the client's `SearchOptions`). */\nexport interface LakebaseSearchOptions {\n  limit?: number;\n  scoreThreshold?: number;\n  signal?: AbortSignal;\n}\n\n/** Options for provisioning a Lakebase-backed index. */\nexport interface LakebaseProvisionOptions {\n  /** Text column embedded into the search vector. Defaults to `text`. */\n  textColumn?: string;\n  /** Documents to seed when the table is empty. */\n  seed?: SearchDocument[];\n  signal?: AbortSignal;\n}\n\n/**\n * A Postgres full-text backend. One instance is shared across indexes; each\n * index maps to a table whose name is derived from the index reference.\n */\nexport class LakebaseSearchBackend {\n  private pool: Pool | undefined;\n  private poolPromise: Promise<Pool> | undefined;\n  private readonly provisioned = new Set<string>();\n\n  constructor(\n    private readonly pgConfigFactory: () => Promise<PoolConfig> | PoolConfig,\n    private readonly schema = \"public\",\n    /** How a pool is built from the resolved config. Overridable for tests. */\n    private readonly poolFactory: (config: PoolConfig) => Pool = (config) => new Pool(config),\n  ) {}\n\n  /** Lazily build (and cache) the pg pool from the resolved Lakebase config. */\n  private async getPool(): Promise<Pool> {\n    if (this.pool) return this.pool;\n    this.poolPromise ??= (async () => {\n      const config = await this.pgConfigFactory();\n      const pool = this.poolFactory(config);\n      this.pool = pool;\n      return pool;\n    })();\n    return this.poolPromise;\n  }\n\n  /** Close the pool so a restarted app rebuilds it. */\n  async close(): Promise<void> {\n    const pool = this.pool;\n    this.pool = undefined;\n    this.poolPromise = undefined;\n    this.provisioned.clear();\n    if (pool) await pool.end();\n  }\n\n  /**\n   * Search a Lakebase-backed index. Returns hits sorted most-relevant-first,\n   * shaped identically to the Vector Search backend.\n   */\n  async search(\n    index: string,\n    query: string,\n    options: LakebaseSearchOptions = {},\n  ): Promise<SearchResult> {\n    const text = string.trimToEmpty(query);\n    const table = this.tableFor(index);\n    const limit = options.limit ?? 10;\n    const pool = await this.getPool();\n\n    // `websearch_to_tsquery` accepts a bare search box string (quoted phrases,\n    // `or`, `-term`); an empty query returns the most recent rows so an empty\n    // search box still shows content, matching a keyword index's behavior.\n    const sql = text\n      ? `SELECT id, document, ts_rank(search_vector, websearch_to_tsquery('english', $1)) AS score\n           FROM ${table}\n          WHERE search_vector @@ websearch_to_tsquery('english', $1)\n          ORDER BY score DESC\n          LIMIT $2`\n      : `SELECT id, document, 0::float4 AS score FROM ${table} ORDER BY id LIMIT $2`;\n    const params = text ? [text, limit] : [limit];\n\n    const { rows } = await this.query<{ id: string; document: unknown; score: number }>(\n      pool,\n      sql,\n      params,\n      options.signal,\n    );\n    const hits: SearchHit[] = rows\n      .map((row) => ({\n        id: String(row.id),\n        score: Number(row.score) || 0,\n        fields: this.toFields(row.document),\n      }))\n      .filter((hit) => options.scoreThreshold === undefined || hit.score >= options.scoreThreshold);\n    return { query: text, index, hits, count: hits.length };\n  }\n\n  /**\n   * Ensure the table + full-text index exist and seed documents when empty.\n   * Idempotent, so it is safe to call on every boot.\n   */\n  async provision(index: string, options: LakebaseProvisionOptions = {}): Promise<number> {\n    const table = this.tableFor(index);\n    const pool = await this.getPool();\n    await this.ensureTable(pool, table, options.signal);\n\n    const { rows } = await this.query<{ count: string }>(\n      pool,\n      `SELECT count(*)::text AS count FROM ${table}`,\n      [],\n      options.signal,\n    );\n    const existing = Number(rows[0]?.count ?? \"0\");\n    const seed = options.seed ?? [];\n    if (existing === 0 && seed.length > 0) {\n      await this.upsert(pool, table, seed, options.textColumn ?? \"text\", options.signal);\n      logger.info(\"index-seeded\", { index, table, count: seed.length });\n      return seed.length;\n    }\n    return existing;\n  }\n\n  /** Add or update documents by primary key. */\n  async addDocuments(\n    index: string,\n    documents: SearchDocument[],\n    textColumn = \"text\",\n    signal?: AbortSignal,\n  ): Promise<UpsertResult> {\n    const table = this.tableFor(index);\n    const pool = await this.getPool();\n    await this.ensureTable(pool, table, signal);\n    await this.upsert(pool, table, documents, textColumn, signal);\n    return { index, count: documents.length };\n  }\n\n  /** Delete documents by primary key. */\n  async deleteDocuments(\n    index: string,\n    ids: Array<string | number>,\n    signal?: AbortSignal,\n  ): Promise<UpsertResult> {\n    const table = this.tableFor(index);\n    const pool = await this.getPool();\n    await this.query(pool, `DELETE FROM ${table} WHERE id = ANY($1)`, [ids.map(String)], signal);\n    return { index, count: ids.length };\n  }\n\n  /** Create the table + GIN index once per table (memoized across calls). */\n  private async ensureTable(pool: Pool, table: string, signal?: AbortSignal): Promise<void> {\n    if (this.provisioned.has(table)) return;\n    // `document` holds the whole row; `search_text` is the indexed text; the\n    // generated `search_vector` keeps the tsvector in lockstep with it so a\n    // write never has to compute the vector by hand.\n    await this.query(pool, `CREATE SCHEMA IF NOT EXISTS ${this.ident(this.schema)}`, [], signal);\n    await this.query(\n      pool,\n      `CREATE TABLE IF NOT EXISTS ${table} (\n         id text PRIMARY KEY,\n         search_text text NOT NULL DEFAULT '',\n         document jsonb NOT NULL DEFAULT '{}'::jsonb,\n         search_vector tsvector GENERATED ALWAYS AS (to_tsvector('english', search_text)) STORED\n       )`,\n      [],\n      signal,\n    );\n    await this.query(\n      pool,\n      `CREATE INDEX IF NOT EXISTS ${this.ident(`${this.bareName(table)}_fts`)}\n         ON ${table} USING gin (search_vector)`,\n      [],\n      signal,\n    );\n    this.provisioned.add(table);\n    logger.info(\"index-created\", { table });\n  }\n\n  /** Upsert rows: the whole document as jsonb + a flattened text blob to index. */\n  private async upsert(\n    pool: Pool,\n    table: string,\n    documents: SearchDocument[],\n    textColumn: string,\n    signal?: AbortSignal,\n  ): Promise<void> {\n    for (const doc of documents) {\n      const id = string.trimToNull(String(doc.id ?? doc.ID ?? \"\")) ?? undefined;\n      if (id === undefined) {\n        throw new ExecutionError(\"search (lakebase): a document is missing an `id`\", {\n          context: { operation: \"addDocuments\" },\n        });\n      }\n      const searchText = this.searchText(doc, textColumn);\n      await this.query(\n        pool,\n        `INSERT INTO ${table} (id, search_text, document)\n           VALUES ($1, $2, $3::jsonb)\n         ON CONFLICT (id) DO UPDATE\n           SET search_text = EXCLUDED.search_text, document = EXCLUDED.document`,\n        [id, searchText, JSON.stringify(doc)],\n        signal,\n      );\n    }\n  }\n\n  /** The text a row is indexed by: the text column first, then any other string field. */\n  private searchText(doc: SearchDocument, textColumn: string): string {\n    const primary = string.trimToEmpty(String(doc[textColumn] ?? \"\"));\n    const rest = Object.entries(doc)\n      .filter(([key, value]) => key !== textColumn && key !== \"id\" && typeof value === \"string\")\n      .map(([, value]) => value as string);\n    return [primary, ...rest].filter(Boolean).join(\"\\n\");\n  }\n\n  /** A hit's `fields`: the stored document minus the reserved/internal keys. */\n  private toFields(document: unknown): Record<string, unknown> {\n    if (!object.isRecord(document)) return {};\n    const fields: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(document)) {\n      if (RESERVED_COLUMNS.has(key)) continue;\n      fields[key] = value;\n    }\n    return fields;\n  }\n\n  /** The fully-qualified table name for an index reference. */\n  private tableFor(index: string): string {\n    return `${this.ident(this.schema)}.${this.ident(this.bareName(index))}`;\n  }\n\n  /** A safe bare table name derived from an index reference. */\n  private bareName(reference: string): string {\n    const last = reference.split(\".\").filter(Boolean).pop() ?? reference;\n    const slug = last\n      .toLowerCase()\n      .replace(/[^a-z0-9_]+/g, \"_\")\n      .replace(/^_+|_+$/g, \"\");\n    return slug.length > 0 ? slug : \"documents\";\n  }\n\n  /** Quote a Postgres identifier. */\n  private ident(name: string): string {\n    return `\"${name.replace(/\"/g, '\"\"')}\"`;\n  }\n\n  /** Run one query under external cancellation. */\n  private async query<T>(\n    pool: Pool,\n    sql: string,\n    params: unknown[],\n    signal?: AbortSignal,\n  ): Promise<{ rows: T[] }> {\n    if (signal?.aborted) throw ExecutionError.canceled();\n    const client = await pool.connect();\n    const onAbort = () => void client.release(true);\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n    try {\n      const result = await client.query(sql, params);\n      return { rows: result.rows as T[] };\n    } finally {\n      signal?.removeEventListener(\"abort\", onAbort);\n      client.release();\n    }\n  }\n}\n"]}

package/lib/src/plugin.d.ts

@@ -0,0 +1,216 @@
+/**
+ * AppKit plugin (registered name: `search`) that turns a Databricks AI
+ * Search (Vector Search) index into a batteries-included search surface. It is
+ * the "shortcut" half of this package: register it with nothing but an index
+ * name and you get, all at once -
+ *
+ *   - a `search` / `universal_search` / (opt-in) `add_documents` tool set for
+ *     both Mastra and AppKit agents (autocomplete is a small-`limit` search);
+ *   - HTTP routes under `/api/search` a browser search box calls directly
+ *     (`POST /` search, `POST /universal` federated, `GET /indexes` catalogue,
+ *     and `POST /documents` when writes are enabled);
+ *   - a `clientConfig()` payload so a UI knows the indexes, default, and page
+ *     size at boot with no round-trip;
+ *   - `exports()` so app code can `appkit.search.search(...)` directly.
+ *
+ * Everything runs under the caller's OBO identity (routes wrap in `asUser`),
+ * so Unity Catalog ACLs on the index apply. Registering the plugin resolves
+ * and logs the effective config (default index, known indexes, page size,
+ * mode) so a misconfiguration shows up in the boot log rather than on the
+ * first search.
+ *
+ * @module
+ */
+import { Plugin, ResourceType, type IAppRouter, type ResourceRequirement } from "@databricks/appkit";
+import { type AgentToolDefinition, type ToolProvider } from "@databricks/appkit/beta";
+import { search as searchContract } from "@dbx-tools/shared-search";
+import { type SearchPluginConfig } from "./config.ts";
+/**
+ * AppKit plugin exposing AI Search as a search box, an agent tool set, and a
+ * direct API.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as searchPlugin } from "@dbx-tools/search";
+ *
+ * await createApp({
+ *   plugins: [
+ *     server(),
+ *     // zero-config: reads DATABRICKS_VECTOR_SEARCH_INDEX
+ *     searchPlugin.search(),
+ *     // or go deeper:
+ *     // searchPlugin.search({
+ *     //   index: "main.support.docs",
+ *     //   indexes: ["main.support.docs", "main.catalog.products"],
+ *     //   columns: ["title", "url", "body"],
+ *     //   mode: "hybrid",
+ *     // }),
+ *   ],
+ * });
+ * ```
+ */
+export declare class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProvider {
+    static manifest: {
+        name: "search";
+        displayName: string;
+        description: string;
+        stability: "beta";
+        resources: {
+            required: never[];
+            optional: {
+                type: ResourceType.VECTOR_SEARCH_INDEX;
+                alias: string;
+                resourceKey: string;
+                description: string;
+                permission: "SELECT";
+                fields: {
+                    name: {
+                        env: string;
+                        description: string;
+                        discovery: {
+                            type: "cli";
+                            cliCommand: string;
+                            selectField: string;
+                        };
+                    };
+                };
+            }[];
+        };
+        config: {
+            schema: import("json-schema").JSONSchema7;
+        };
+    };
+    /** The base path AppKit mounts this plugin's routes under. */
+    private get basePath();
+    /**
+     * Promote the index to a required resource once a deployment pins a default,
+     * through plugin config or either environment name.
+     */
+    static getResourceRequirements(config: SearchPluginConfig): ResourceRequirement[];
+    /**
+     * The tools this plugin offers to an AppKit agent. `search` /
+     * `universal_search` are reads; `add_documents` / `create_index` /
+     * `sync_index` are only offered when the write surface is enabled. None is
+     * autoInheritable: every tool runs under the caller's identity, so it must be
+     * granted explicitly.
+     */
+    private get tools();
+    /** Prime the shared runtime from config and log the effective policy at boot. */
+    setup(): Promise<void>;
+    /**
+     * Build the Lakebase FALLBACK backend, or return `undefined` when Vector
+     * Search should be used. Falls back only when there is NO Vector Search
+     * endpoint configured (plugin config or `SEARCH_ENDPOINT` /
+     * `DATABRICKS_VECTOR_SEARCH_ENDPOINT`) AND the sibling AppKit `lakebase`
+     * plugin is registered. The pg pool is built from that plugin's
+     * service-principal config exactly like `@dbx-tools/appkit-mastra`'s memory
+     * pool - no auth is re-implemented here.
+     */
+    private resolveLakebaseBackend;
+    /**
+     * Ensure the endpoint + index exist and seed them, honoring `ensureOnSetup`.
+     * Uses boot-time SDK auth (env / config profile) via the client's
+     * out-of-request fallback. Failures are logged, never thrown - a search app
+     * should still start even if provisioning is slow or a permission is missing.
+     */
+    private runEnsureOnSetup;
+    /** Build a Vector Search `schema_json` map from a seed document's value types. */
+    private inferSchema;
+    /** Drop the shared runtime so a restarted app re-resolves config. */
+    shutdown(): Promise<void>;
+    abortActiveOperations(): void;
+    /**
+     * Mount the search routes under `/api/search`. Each is wrapped in
+     * `asUser(req)` so the query runs as the requesting user and the index's
+     * Unity Catalog ACLs apply. `GET /indexes` needs no user scope - it just
+     * echoes the configured catalogue.
+     */
+    injectRoutes(router: IAppRouter): void;
+    /**
+     * Run a route body, turning a failure into a JSON error response.
+     *
+     * AppKit's `route()` registers the handler as-is, so a rejection escapes as
+     * an unhandled promise rejection and takes the whole process down rather than
+     * failing the one request. Every route here goes through this, so a bad index
+     * name or a Vector Search API error returns 500 with a message instead of
+     * killing the server.
+     */
+    private respond;
+    /** Surface the index catalogue + defaults so a search box needs no round-trip. */
+    clientConfig(): Record<string, unknown>;
+    /** AppKit `ToolProvider`: the tool definitions offered to an agent. */
+    getAgentTools(): AgentToolDefinition[];
+    /** AppKit `ToolProvider`: run one tool call, validating input against its schema. */
+    executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown>;
+    exports(): {
+        /** Search one index (default when omitted). Runs as the current context user. */
+        search: (request: searchContract.SearchRequest, signal?: AbortSignal) => Promise<{
+            query: string;
+            hits: {
+                id: string;
+                score: number;
+                fields: Record<string, unknown>;
+                index?: string | undefined;
+            }[];
+            count: number;
+            index?: string | undefined;
+        }>;
+        /** Search across every configured index and merge the hits. */
+        universalSearch: (request: searchContract.UniversalSearchRequest, signal?: AbortSignal) => Promise<{
+            query: string;
+            hits: {
+                id: string;
+                score: number;
+                fields: Record<string, unknown>;
+                index?: string | undefined;
+            }[];
+            count: number;
+            index?: string | undefined;
+        }>;
+        /** Add or update documents in a direct-access index (throws when writes are disabled). */
+        addDocuments: (request: {
+            index?: string;
+            documents: unknown;
+        }, signal?: AbortSignal) => Promise<{
+            index: string;
+            count: number;
+        }>;
+        /** Create a Vector Search index (throws when writes are disabled). */
+        createIndex: (request: searchContract.CreateIndexRequest, signal?: AbortSignal) => Promise<import("./client.ts").IndexInfo>;
+        /** Sync a Delta Sync index from its source table (throws when writes are disabled). */
+        syncIndex: (request: searchContract.SyncIndexRequest, signal?: AbortSignal) => Promise<{
+            index: string;
+            synced: boolean;
+        }>;
+    };
+    private runSearch;
+    private runUniversalSearch;
+    private runAddDocuments;
+    private runCreateIndex;
+    private runSyncIndex;
+}
+/**
+ * Register the AI Search plugin with AppKit.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as searchPlugin, tool as searchToolModule } from "@dbx-tools/search";
+ * import { agents, plugin as mastraPlugin } from "@dbx-tools/appkit-mastra";
+ *
+ * const support = agents.createAgent({
+ *   instructions: "Answer from the docs; use `search` to find them.",
+ *   tools: () => ({ search: searchToolModule.searchTool() }),
+ * });
+ *
+ * await createApp({
+ *   plugins: [
+ *     server(),
+ *     searchPlugin.search({ index: "main.support.docs" }),
+ *     mastraPlugin.mastra({ agents: support }),
+ *   ],
+ * });
+ * ```
+ */
+export declare const search: import("@databricks/appkit").ToPlugin<typeof SearchPlugin, SearchPluginConfig, "search">;