@dbx-tools/search 0.6.9

package/lib/src/plugin.js

@@ -0,0 +1,506 @@
+/**
+ * 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 { lakebase, Plugin, ResourceType, toPlugin, } from "@databricks/appkit";
+import { defineTool, executeFromRegistry, toolsFromRegistry, } from "@databricks/appkit/beta";
+import { plugin as pluginLookup } from "@dbx-tools/appkit";
+import { search as searchContract } from "@dbx-tools/shared-search";
+import { error as errorUtil, log, string } from "@dbx-tools/shared-core";
+import { SEARCH_CONFIG_SCHEMA, DATABRICKS_INDEX_ENV, ENDPOINT_ENV, INDEX_ENV, resolveSearchConfig, } from "./config.js";
+import { LakebaseSearchBackend } from "./lakebase.js";
+import { toCreateIndexOptions } from "./index-tools.js";
+import { toDocumentArray } from "./query.js";
+import { getSearchRuntime, resetSearchRuntime } from "./runtime.js";
+import { ADD_DOCUMENTS_TOOL_DESCRIPTION, CREATE_INDEX_TOOL_DESCRIPTION, SEARCH_TOOL_DESCRIPTION, SYNC_INDEX_TOOL_DESCRIPTION, UNIVERSAL_SEARCH_TOOL_DESCRIPTION, } from "./schema.js";
+const logger = log.logger("search");
+/** Mount-relative route (under `/api/search`) for a single-index search. */
+const SEARCH_ROUTE = "/";
+/** Mount-relative route for a universal (federated) search across indexes. */
+const UNIVERSAL_ROUTE = "/universal";
+/** Mount-relative route serving the index catalogue a search box reads. */
+const INDEXES_ROUTE = "/indexes";
+/** Mount-relative route for adding documents to a direct-access index. */
+const DOCUMENTS_ROUTE = "/documents";
+/** Mount-relative route for creating a Vector Search index. */
+const INDEX_ROUTE = "/index";
+/** Mount-relative route for syncing a Delta Sync index from its source table. */
+const INDEX_SYNC_ROUTE = "/index/sync";
+/**
+ * The AI Search index resource. Declared optional because the plugin is happy
+ * with no default index (a caller can name one per request); it is promoted to
+ * required once a deployment pins one. `SELECT` is the permission a query needs.
+ */
+const INDEX_RESOURCE = {
+    type: ResourceType.VECTOR_SEARCH_INDEX,
+    alias: "AI Search Index",
+    resourceKey: "search-index",
+    description: "Databricks AI Search (Vector Search) index the app searches by default " +
+        "(catalog.schema.index). Optional: a request may name any index the caller can read.",
+    permission: "SELECT",
+    fields: {
+        name: {
+            env: INDEX_ENV,
+            description: `Default AI Search index. ${DATABRICKS_INDEX_ENV} is also honored.`,
+            discovery: {
+                type: "cli",
+                cliCommand: "databricks vector-search-indexes list-indexes --endpoint-name <ENDPOINT> --output json",
+                selectField: ".name",
+            },
+        },
+    },
+};
+/**
+ * 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 class SearchPlugin extends Plugin {
+    static manifest = {
+        name: "search",
+        displayName: "AI Search",
+        description: "Search Databricks AI Search (Vector Search) indexes: agent tools, HTTP routes for a " +
+            "search box, universal search across indexes, and an opt-in document write surface.",
+        stability: "beta",
+        resources: {
+            required: [],
+            optional: [INDEX_RESOURCE],
+        },
+        config: { schema: SEARCH_CONFIG_SCHEMA },
+    };
+    /** The base path AppKit mounts this plugin's routes under. */
+    get basePath() {
+        return `/api/${SearchPlugin.manifest.name}`;
+    }
+    /**
+     * Promote the index to a required resource once a deployment pins a default,
+     * through plugin config or either environment name.
+     */
+    static getResourceRequirements(config) {
+        const pinned = string.trimToNull(config.index) ??
+            string.trimToNull(process.env[INDEX_ENV]) ??
+            string.trimToNull(process.env[DATABRICKS_INDEX_ENV]);
+        return pinned === null ? [] : [{ ...INDEX_RESOURCE, required: true }];
+    }
+    /**
+     * 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.
+     */
+    get tools() {
+        const { config } = getSearchRuntime({ config: this.config });
+        const registry = {
+            search: defineTool({
+                description: SEARCH_TOOL_DESCRIPTION,
+                schema: searchContract.searchRequestSchema,
+                annotations: { effect: "read", requiresUserContext: true },
+                autoInheritable: false,
+                execute: async (args, signal) => this.runSearch(args, signal),
+            }),
+            universal_search: defineTool({
+                description: UNIVERSAL_SEARCH_TOOL_DESCRIPTION,
+                schema: searchContract.universalSearchRequestSchema,
+                annotations: { effect: "read", requiresUserContext: true },
+                autoInheritable: false,
+                execute: async (args, signal) => this.runUniversalSearch(args, signal),
+            }),
+        };
+        if (config.allowWrite) {
+            registry.add_documents = defineTool({
+                description: ADD_DOCUMENTS_TOOL_DESCRIPTION,
+                schema: searchContract.searchRequestSchema
+                    .pick({ index: true })
+                    .extend({ documents: searchContract.searchDocumentSchema.array() }),
+                annotations: { effect: "write", requiresUserContext: true },
+                autoInheritable: false,
+                execute: async (args, signal) => this.runAddDocuments(args, signal),
+            });
+            registry.create_index = defineTool({
+                description: CREATE_INDEX_TOOL_DESCRIPTION,
+                schema: searchContract.createIndexRequestSchema,
+                annotations: { effect: "write", requiresUserContext: true },
+                autoInheritable: false,
+                execute: async (args, signal) => this.runCreateIndex(args, signal),
+            });
+            registry.sync_index = defineTool({
+                description: SYNC_INDEX_TOOL_DESCRIPTION,
+                schema: searchContract.syncIndexRequestSchema,
+                annotations: { effect: "write", requiresUserContext: true },
+                autoInheritable: false,
+                execute: async (args, signal) => this.runSyncIndex(args, signal),
+            });
+        }
+        return registry;
+    }
+    /** Prime the shared runtime from config and log the effective policy at boot. */
+    async setup() {
+        // Choose a backend. Vector Search is primary; when NO Vector Search
+        // endpoint is configured but the AppKit `lakebase` plugin is registered,
+        // fall back to a Postgres full-text index. Both answer with the identical
+        // shape, so this choice is invisible to tools, routes, and the UI.
+        const lakebaseBackend = this.resolveLakebaseBackend();
+        // The runtime may already have been built (config-only) when `tools()` ran
+        // during registration; rebuild it so it carries the chosen backend.
+        resetSearchRuntime();
+        const { config } = getSearchRuntime({
+            config: this.config,
+            ...(lakebaseBackend ? { lakebase: lakebaseBackend } : {}),
+        });
+        logger.info("ready", {
+            backend: lakebaseBackend ? "lakebase" : "vector-search",
+            defaultIndex: config.defaultIndex ?? "(none - pass per request)",
+            indexes: config.indexes.map((i) => i.alias),
+            pageSize: config.pageSize,
+            mode: config.mode,
+            allowWrite: config.allowWrite,
+            basePath: this.basePath,
+            ensureOnSetup: config.ensureOnSetup
+                ? (config.ensureOnSetup.index ?? config.defaultIndex)
+                : "off",
+        });
+        // Provision a real index in the BACKGROUND so a slow first-time endpoint or
+        // index build never blocks the server from coming up.
+        if (config.ensureOnSetup)
+            void this.runEnsureOnSetup(config);
+    }
+    /**
+     * 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.
+     */
+    resolveLakebaseBackend() {
+        const config = resolveSearchConfig(this.config);
+        const hasEndpoint = config.endpoint !== undefined ||
+            string.trimToNull(process.env[ENDPOINT_ENV]) !== null ||
+            string.trimToNull(process.env.DATABRICKS_VECTOR_SEARCH_ENDPOINT) !== null;
+        if (hasEndpoint)
+            return undefined;
+        const lake = pluginLookup.instance(this.context, lakebase);
+        if (!lake)
+            return undefined;
+        logger.info("backend-lakebase", {
+            reason: "no Vector Search endpoint configured; using the Lakebase full-text fallback",
+        });
+        // `getPgConfig()` must be read OUTSIDE any asUser scope (as it is here at
+        // setup) so it carries the SP connection target + token-refresh callback.
+        return new LakebaseSearchBackend(() => lake.exports().getPgConfig());
+    }
+    /**
+     * 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.
+     */
+    async runEnsureOnSetup(config) {
+        const spec = config.ensureOnSetup;
+        if (!spec)
+            return;
+        const index = string.trimToNull(spec.index) ?? config.defaultIndex;
+        if (!index) {
+            logger.warn("ensure-skipped", {
+                reason: "no index name (set `index` or `ensureOnSetup.index`)",
+            });
+            return;
+        }
+        const documents = spec.documents ?? [];
+        // Infer a managed-direct-access schema from the first seed row when not given.
+        const schema = spec.schema ??
+            (documents.length > 0 && !spec.sourceTable
+                ? this.inferSchema(documents[0], spec.primaryKey ?? "id", spec.textColumn ?? "text")
+                : undefined);
+        try {
+            logger.info("ensure-start", { index });
+            const { client } = getSearchRuntime();
+            const info = await client.provision(index, {
+                ...(spec.endpoint ? { endpoint: spec.endpoint } : {}),
+                ...(spec.primaryKey ? { primaryKey: spec.primaryKey } : {}),
+                ...(spec.textColumn ? { embeddingSourceColumn: spec.textColumn } : {}),
+                ...(spec.embeddingModel ? { embeddingModel: spec.embeddingModel } : {}),
+                ...(spec.sourceTable ? { sourceTable: spec.sourceTable } : {}),
+                ...(schema ? { schema } : {}),
+                ...(spec.timeoutMs ? { timeoutMs: spec.timeoutMs } : {}),
+                ...(documents.length > 0 ? { seed: documents } : {}),
+            });
+            logger.info("ensure-ready", {
+                index: info.name,
+                ready: info.ready,
+                rowCount: info.rowCount ?? 0,
+            });
+        }
+        catch (cause) {
+            logger.warn("ensure-failed", { index, message: errorUtil.errorMessage(cause) });
+        }
+    }
+    /** Build a Vector Search `schema_json` map from a seed document's value types. */
+    inferSchema(doc, primaryKey, textColumn) {
+        const schema = { [primaryKey]: "string", [textColumn]: "string" };
+        for (const [key, value] of Object.entries(doc)) {
+            if (key in schema)
+                continue;
+            schema[key] =
+                typeof value === "number"
+                    ? Number.isInteger(value)
+                        ? "int"
+                        : "double"
+                    : typeof value === "boolean"
+                        ? "boolean"
+                        : "string";
+        }
+        return schema;
+    }
+    /** Drop the shared runtime so a restarted app re-resolves config. */
+    async shutdown() {
+        resetSearchRuntime();
+    }
+    abortActiveOperations() {
+        super.abortActiveOperations();
+        void this.shutdown();
+    }
+    /**
+     * 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) {
+        this.route(router, {
+            name: "search",
+            method: "post",
+            path: SEARCH_ROUTE,
+            handler: async (req, res) => {
+                await this.respond(res, "search", () => {
+                    const request = searchContract.searchRequestSchema.parse(req.body ?? {});
+                    return this.asUser(req).runSearch(request);
+                });
+            },
+        });
+        this.route(router, {
+            name: "universalSearch",
+            method: "post",
+            path: UNIVERSAL_ROUTE,
+            handler: async (req, res) => {
+                await this.respond(res, "universalSearch", () => {
+                    const request = searchContract.universalSearchRequestSchema.parse(req.body ?? {});
+                    return this.asUser(req).runUniversalSearch(request);
+                });
+            },
+        });
+        this.route(router, {
+            name: "indexes",
+            method: "get",
+            path: INDEXES_ROUTE,
+            handler: async (_req, res) => {
+                res.json(this.clientConfig());
+            },
+        });
+        this.route(router, {
+            name: "documents",
+            method: "post",
+            path: DOCUMENTS_ROUTE,
+            handler: async (req, res) => {
+                const { config } = getSearchRuntime();
+                if (!config.allowWrite) {
+                    res.status(403).json({ error: "the document write surface is disabled" });
+                    return;
+                }
+                await this.respond(res, "addDocuments", () => this.asUser(req).runAddDocuments(req.body ?? {}));
+            },
+        });
+        this.route(router, {
+            name: "createIndex",
+            method: "post",
+            path: INDEX_ROUTE,
+            handler: async (req, res) => {
+                const { config } = getSearchRuntime();
+                if (!config.allowWrite) {
+                    res.status(403).json({ error: "the index write surface is disabled" });
+                    return;
+                }
+                await this.respond(res, "createIndex", () => this.asUser(req).runCreateIndex(req.body ?? {}));
+            },
+        });
+        this.route(router, {
+            name: "syncIndex",
+            method: "post",
+            path: INDEX_SYNC_ROUTE,
+            handler: async (req, res) => {
+                const { config } = getSearchRuntime();
+                if (!config.allowWrite) {
+                    res.status(403).json({ error: "the index write surface is disabled" });
+                    return;
+                }
+                await this.respond(res, "syncIndex", () => this.asUser(req).runSyncIndex(req.body ?? {}));
+            },
+        });
+    }
+    /**
+     * 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.
+     */
+    async respond(res, operation, run) {
+        try {
+            res.json(await run());
+        }
+        catch (cause) {
+            const message = errorUtil.errorMessage(cause);
+            logger.warn("route-failed", { operation, message });
+            res.status(500).json({ error: message });
+        }
+    }
+    /** Surface the index catalogue + defaults so a search box needs no round-trip. */
+    clientConfig() {
+        const { config } = getSearchRuntime({ config: this.config });
+        const payload = {
+            indexes: config.indexes.map((index) => ({
+                name: index.name,
+                alias: index.alias,
+                ...(index.primaryKey ? { primaryKey: index.primaryKey } : {}),
+                ...(index.columns ? { columns: index.columns } : {}),
+                ...(index.name === config.defaultIndex ? { isDefault: true } : {}),
+            })),
+            ...(config.defaultIndex ? { defaultIndex: config.defaultIndex } : {}),
+            pageSize: config.pageSize,
+            basePath: this.basePath,
+        };
+        return payload;
+    }
+    /** AppKit `ToolProvider`: the tool definitions offered to an agent. */
+    getAgentTools() {
+        return toolsFromRegistry(this.tools);
+    }
+    /** AppKit `ToolProvider`: run one tool call, validating input against its schema. */
+    async executeAgentTool(name, args, signal) {
+        return executeFromRegistry(this.tools, name, args, signal);
+    }
+    exports() {
+        return {
+            /** Search one index (default when omitted). Runs as the current context user. */
+            search: (request, signal) => this.runSearch(request, signal),
+            /** Search across every configured index and merge the hits. */
+            universalSearch: (request, signal) => this.runUniversalSearch(request, signal),
+            /** Add or update documents in a direct-access index (throws when writes are disabled). */
+            addDocuments: (request, signal) => this.runAddDocuments(request, signal),
+            /** Create a Vector Search index (throws when writes are disabled). */
+            createIndex: (request, signal) => this.runCreateIndex(request, signal),
+            /** Sync a Delta Sync index from its source table (throws when writes are disabled). */
+            syncIndex: (request, signal) => this.runSyncIndex(request, signal),
+        };
+    }
+    async runSearch(args, signal) {
+        const request = searchContract.searchRequestSchema.parse(args);
+        const { client } = getSearchRuntime();
+        return client.search(request.query, {
+            ...(request.index ? { index: request.index } : {}),
+            ...(request.limit ? { limit: request.limit } : {}),
+            ...(request.mode ? { mode: request.mode } : {}),
+            ...(request.columns ? { columns: request.columns } : {}),
+            ...(request.filter ? { filter: request.filter } : {}),
+            ...(request.scoreThreshold !== undefined ? { scoreThreshold: request.scoreThreshold } : {}),
+            ...(signal ? { signal } : {}),
+        });
+    }
+    async runUniversalSearch(args, signal) {
+        const request = searchContract.universalSearchRequestSchema.parse(args);
+        const { client } = getSearchRuntime();
+        return client.universalSearch(request.query, {
+            ...(request.indexes ? { indexes: request.indexes } : {}),
+            ...(request.limit ? { limit: request.limit } : {}),
+            ...(request.mode ? { mode: request.mode } : {}),
+            ...(signal ? { signal } : {}),
+        });
+    }
+    async runAddDocuments(args, signal) {
+        const record = (args ?? {});
+        const { client, config } = getSearchRuntime();
+        const documents = toDocumentArray(record.documents);
+        const index = record.index ?? config.defaultIndex ?? "";
+        return client.addDocuments(index, documents, signal);
+    }
+    async runCreateIndex(args, signal) {
+        const request = searchContract.createIndexRequestSchema.parse(args);
+        const { client } = getSearchRuntime();
+        return client.createIndex(request.name, toCreateIndexOptions(request, signal));
+    }
+    async runSyncIndex(args, signal) {
+        const request = searchContract.syncIndexRequestSchema.parse(args);
+        const { client, config } = getSearchRuntime();
+        const index = request.index ?? config.defaultIndex ?? "";
+        await client.syncIndex(index, signal);
+        return { index, synced: true };
+    }
+}
+/**
+ * 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 const search = toPlugin(SearchPlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit plugin (registered name: `search`) that turns a Databricks AI\n * Search (Vector Search) index into a batteries-included search surface. It is\n * the \"shortcut\" half of this package: register it with nothing but an index\n * name and you get, all at once -\n *\n *   - a `search` / `universal_search` / (opt-in) `add_documents` tool set for\n *     both Mastra and AppKit agents (autocomplete is a small-`limit` search);\n *   - HTTP routes under `/api/search` a browser search box calls directly\n *     (`POST /` search, `POST /universal` federated, `GET /indexes` catalogue,\n *     and `POST /documents` when writes are enabled);\n *   - a `clientConfig()` payload so a UI knows the indexes, default, and page\n *     size at boot with no round-trip;\n *   - `exports()` so app code can `appkit.search.search(...)` directly.\n *\n * Everything runs under the caller's OBO identity (routes wrap in `asUser`),\n * so Unity Catalog ACLs on the index apply. Registering the plugin resolves\n * and logs the effective config (default index, known indexes, page size,\n * mode) so a misconfiguration shows up in the boot log rather than on the\n * first search.\n *\n * @module\n */\n\nimport {\n  lakebase,\n  Plugin,\n  ResourceType,\n  toPlugin,\n  type IAppRouter,\n  type PluginManifest,\n  type ResourceRequirement,\n} from \"@databricks/appkit\";\nimport {\n  defineTool,\n  executeFromRegistry,\n  toolsFromRegistry,\n  type AgentToolDefinition,\n  type ToolProvider,\n  type ToolRegistry,\n} from \"@databricks/appkit/beta\";\nimport { plugin as pluginLookup } from \"@dbx-tools/appkit\";\nimport { search as searchContract, type SearchClientConfig } from \"@dbx-tools/shared-search\";\nimport { error as errorUtil, log, string } from \"@dbx-tools/shared-core\";\nimport {\n  SEARCH_CONFIG_SCHEMA,\n  DATABRICKS_INDEX_ENV,\n  ENDPOINT_ENV,\n  INDEX_ENV,\n  resolveSearchConfig,\n  type SearchPluginConfig,\n} from \"./config.ts\";\nimport { LakebaseSearchBackend } from \"./lakebase.ts\";\nimport { toCreateIndexOptions } from \"./index-tools.ts\";\nimport { toDocumentArray } from \"./query.ts\";\nimport { getSearchRuntime, resetSearchRuntime } from \"./runtime.ts\";\nimport {\n  ADD_DOCUMENTS_TOOL_DESCRIPTION,\n  CREATE_INDEX_TOOL_DESCRIPTION,\n  SEARCH_TOOL_DESCRIPTION,\n  SYNC_INDEX_TOOL_DESCRIPTION,\n  UNIVERSAL_SEARCH_TOOL_DESCRIPTION,\n} from \"./schema.ts\";\n\nconst logger = log.logger(\"search\");\n\n/** Mount-relative route (under `/api/search`) for a single-index search. */\nconst SEARCH_ROUTE = \"/\";\n\n/** Mount-relative route for a universal (federated) search across indexes. */\nconst UNIVERSAL_ROUTE = \"/universal\";\n\n/** Mount-relative route serving the index catalogue a search box reads. */\nconst INDEXES_ROUTE = \"/indexes\";\n\n/** Mount-relative route for adding documents to a direct-access index. */\nconst DOCUMENTS_ROUTE = \"/documents\";\n\n/** Mount-relative route for creating a Vector Search index. */\nconst INDEX_ROUTE = \"/index\";\n\n/** Mount-relative route for syncing a Delta Sync index from its source table. */\nconst INDEX_SYNC_ROUTE = \"/index/sync\";\n\n/**\n * The AI Search index resource. Declared optional because the plugin is happy\n * with no default index (a caller can name one per request); it is promoted to\n * required once a deployment pins one. `SELECT` is the permission a query needs.\n */\nconst INDEX_RESOURCE = {\n  type: ResourceType.VECTOR_SEARCH_INDEX,\n  alias: \"AI Search Index\",\n  resourceKey: \"search-index\",\n  description:\n    \"Databricks AI Search (Vector Search) index the app searches by default \" +\n    \"(catalog.schema.index). Optional: a request may name any index the caller can read.\",\n  permission: \"SELECT\",\n  fields: {\n    name: {\n      env: INDEX_ENV,\n      description: `Default AI Search index. ${DATABRICKS_INDEX_ENV} is also honored.`,\n      discovery: {\n        type: \"cli\",\n        cliCommand:\n          \"databricks vector-search-indexes list-indexes --endpoint-name <ENDPOINT> --output json\",\n        selectField: \".name\",\n      },\n    },\n  },\n} satisfies Omit<ResourceRequirement, \"required\">;\n\n/**\n * AppKit plugin exposing AI Search as a search box, an agent tool set, and a\n * direct API.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as searchPlugin } from \"@dbx-tools/search\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     // zero-config: reads DATABRICKS_VECTOR_SEARCH_INDEX\n *     searchPlugin.search(),\n *     // or go deeper:\n *     // searchPlugin.search({\n *     //   index: \"main.support.docs\",\n *     //   indexes: [\"main.support.docs\", \"main.catalog.products\"],\n *     //   columns: [\"title\", \"url\", \"body\"],\n *     //   mode: \"hybrid\",\n *     // }),\n *   ],\n * });\n * ```\n */\nexport class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProvider {\n  static manifest = {\n    name: \"search\",\n    displayName: \"AI Search\",\n    description:\n      \"Search Databricks AI Search (Vector Search) indexes: agent tools, HTTP routes for a \" +\n      \"search box, universal search across indexes, and an opt-in document write surface.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [INDEX_RESOURCE],\n    },\n    config: { schema: SEARCH_CONFIG_SCHEMA },\n  } satisfies PluginManifest<\"search\">;\n\n  /** The base path AppKit mounts this plugin's routes under. */\n  private get basePath(): string {\n    return `/api/${SearchPlugin.manifest.name}`;\n  }\n\n  /**\n   * Promote the index to a required resource once a deployment pins a default,\n   * through plugin config or either environment name.\n   */\n  static getResourceRequirements(config: SearchPluginConfig): ResourceRequirement[] {\n    const pinned =\n      string.trimToNull(config.index) ??\n      string.trimToNull(process.env[INDEX_ENV]) ??\n      string.trimToNull(process.env[DATABRICKS_INDEX_ENV]);\n    return pinned === null ? [] : [{ ...INDEX_RESOURCE, required: true }];\n  }\n\n  /**\n   * The tools this plugin offers to an AppKit agent. `search` /\n   * `universal_search` are reads; `add_documents` / `create_index` /\n   * `sync_index` are only offered when the write surface is enabled. None is\n   * autoInheritable: every tool runs under the caller's identity, so it must be\n   * granted explicitly.\n   */\n  private get tools(): ToolRegistry {\n    const { config } = getSearchRuntime({ config: this.config });\n    const registry: ToolRegistry = {\n      search: defineTool({\n        description: SEARCH_TOOL_DESCRIPTION,\n        schema: searchContract.searchRequestSchema,\n        annotations: { effect: \"read\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: async (args, signal) => this.runSearch(args, signal),\n      }),\n      universal_search: defineTool({\n        description: UNIVERSAL_SEARCH_TOOL_DESCRIPTION,\n        schema: searchContract.universalSearchRequestSchema,\n        annotations: { effect: \"read\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: async (args, signal) => this.runUniversalSearch(args, signal),\n      }),\n    };\n    if (config.allowWrite) {\n      registry.add_documents = defineTool({\n        description: ADD_DOCUMENTS_TOOL_DESCRIPTION,\n        schema: searchContract.searchRequestSchema\n          .pick({ index: true })\n          .extend({ documents: searchContract.searchDocumentSchema.array() }),\n        annotations: { effect: \"write\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: async (args, signal) => this.runAddDocuments(args, signal),\n      });\n      registry.create_index = defineTool({\n        description: CREATE_INDEX_TOOL_DESCRIPTION,\n        schema: searchContract.createIndexRequestSchema,\n        annotations: { effect: \"write\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: async (args, signal) => this.runCreateIndex(args, signal),\n      });\n      registry.sync_index = defineTool({\n        description: SYNC_INDEX_TOOL_DESCRIPTION,\n        schema: searchContract.syncIndexRequestSchema,\n        annotations: { effect: \"write\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: async (args, signal) => this.runSyncIndex(args, signal),\n      });\n    }\n    return registry;\n  }\n\n  /** Prime the shared runtime from config and log the effective policy at boot. */\n  override async setup(): Promise<void> {\n    // Choose a backend. Vector Search is primary; when NO Vector Search\n    // endpoint is configured but the AppKit `lakebase` plugin is registered,\n    // fall back to a Postgres full-text index. Both answer with the identical\n    // shape, so this choice is invisible to tools, routes, and the UI.\n    const lakebaseBackend = this.resolveLakebaseBackend();\n    // The runtime may already have been built (config-only) when `tools()` ran\n    // during registration; rebuild it so it carries the chosen backend.\n    resetSearchRuntime();\n    const { config } = getSearchRuntime({\n      config: this.config,\n      ...(lakebaseBackend ? { lakebase: lakebaseBackend } : {}),\n    });\n    logger.info(\"ready\", {\n      backend: lakebaseBackend ? \"lakebase\" : \"vector-search\",\n      defaultIndex: config.defaultIndex ?? \"(none - pass per request)\",\n      indexes: config.indexes.map((i) => i.alias),\n      pageSize: config.pageSize,\n      mode: config.mode,\n      allowWrite: config.allowWrite,\n      basePath: this.basePath,\n      ensureOnSetup: config.ensureOnSetup\n        ? (config.ensureOnSetup.index ?? config.defaultIndex)\n        : \"off\",\n    });\n    // Provision a real index in the BACKGROUND so a slow first-time endpoint or\n    // index build never blocks the server from coming up.\n    if (config.ensureOnSetup) void this.runEnsureOnSetup(config);\n  }\n\n  /**\n   * Build the Lakebase FALLBACK backend, or return `undefined` when Vector\n   * Search should be used. Falls back only when there is NO Vector Search\n   * endpoint configured (plugin config or `SEARCH_ENDPOINT` /\n   * `DATABRICKS_VECTOR_SEARCH_ENDPOINT`) AND the sibling AppKit `lakebase`\n   * plugin is registered. The pg pool is built from that plugin's\n   * service-principal config exactly like `@dbx-tools/appkit-mastra`'s memory\n   * pool - no auth is re-implemented here.\n   */\n  private resolveLakebaseBackend(): LakebaseSearchBackend | undefined {\n    const config = resolveSearchConfig(this.config);\n    const hasEndpoint =\n      config.endpoint !== undefined ||\n      string.trimToNull(process.env[ENDPOINT_ENV]) !== null ||\n      string.trimToNull(process.env.DATABRICKS_VECTOR_SEARCH_ENDPOINT) !== null;\n    if (hasEndpoint) return undefined;\n    const lake = pluginLookup.instance(this.context, lakebase);\n    if (!lake) return undefined;\n    logger.info(\"backend-lakebase\", {\n      reason: \"no Vector Search endpoint configured; using the Lakebase full-text fallback\",\n    });\n    // `getPgConfig()` must be read OUTSIDE any asUser scope (as it is here at\n    // setup) so it carries the SP connection target + token-refresh callback.\n    return new LakebaseSearchBackend(() => lake.exports().getPgConfig());\n  }\n\n  /**\n   * Ensure the endpoint + index exist and seed them, honoring `ensureOnSetup`.\n   * Uses boot-time SDK auth (env / config profile) via the client's\n   * out-of-request fallback. Failures are logged, never thrown - a search app\n   * should still start even if provisioning is slow or a permission is missing.\n   */\n  private async runEnsureOnSetup(\n    config: ReturnType<typeof getSearchRuntime>[\"config\"],\n  ): Promise<void> {\n    const spec = config.ensureOnSetup;\n    if (!spec) return;\n    const index = string.trimToNull(spec.index) ?? config.defaultIndex;\n    if (!index) {\n      logger.warn(\"ensure-skipped\", {\n        reason: \"no index name (set `index` or `ensureOnSetup.index`)\",\n      });\n      return;\n    }\n    const documents = spec.documents ?? [];\n    // Infer a managed-direct-access schema from the first seed row when not given.\n    const schema =\n      spec.schema ??\n      (documents.length > 0 && !spec.sourceTable\n        ? this.inferSchema(documents[0], spec.primaryKey ?? \"id\", spec.textColumn ?? \"text\")\n        : undefined);\n    try {\n      logger.info(\"ensure-start\", { index });\n      const { client } = getSearchRuntime();\n      const info = await client.provision(index, {\n        ...(spec.endpoint ? { endpoint: spec.endpoint } : {}),\n        ...(spec.primaryKey ? { primaryKey: spec.primaryKey } : {}),\n        ...(spec.textColumn ? { embeddingSourceColumn: spec.textColumn } : {}),\n        ...(spec.embeddingModel ? { embeddingModel: spec.embeddingModel } : {}),\n        ...(spec.sourceTable ? { sourceTable: spec.sourceTable } : {}),\n        ...(schema ? { schema } : {}),\n        ...(spec.timeoutMs ? { timeoutMs: spec.timeoutMs } : {}),\n        ...(documents.length > 0 ? { seed: documents } : {}),\n      });\n      logger.info(\"ensure-ready\", {\n        index: info.name,\n        ready: info.ready,\n        rowCount: info.rowCount ?? 0,\n      });\n    } catch (cause) {\n      logger.warn(\"ensure-failed\", { index, message: errorUtil.errorMessage(cause) });\n    }\n  }\n\n  /** Build a Vector Search `schema_json` map from a seed document's value types. */\n  private inferSchema(\n    doc: Record<string, unknown>,\n    primaryKey: string,\n    textColumn: string,\n  ): Record<string, string> {\n    const schema: Record<string, string> = { [primaryKey]: \"string\", [textColumn]: \"string\" };\n    for (const [key, value] of Object.entries(doc)) {\n      if (key in schema) continue;\n      schema[key] =\n        typeof value === \"number\"\n          ? Number.isInteger(value)\n            ? \"int\"\n            : \"double\"\n          : typeof value === \"boolean\"\n            ? \"boolean\"\n            : \"string\";\n    }\n    return schema;\n  }\n\n  /** Drop the shared runtime so a restarted app re-resolves config. */\n  async shutdown(): Promise<void> {\n    resetSearchRuntime();\n  }\n\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\n    void this.shutdown();\n  }\n\n  /**\n   * Mount the search routes under `/api/search`. Each is wrapped in\n   * `asUser(req)` so the query runs as the requesting user and the index's\n   * Unity Catalog ACLs apply. `GET /indexes` needs no user scope - it just\n   * echoes the configured catalogue.\n   */\n  override injectRoutes(router: IAppRouter): void {\n    this.route(router, {\n      name: \"search\",\n      method: \"post\",\n      path: SEARCH_ROUTE,\n      handler: async (req, res) => {\n        await this.respond(res, \"search\", () => {\n          const request = searchContract.searchRequestSchema.parse(req.body ?? {});\n          return this.asUser(req).runSearch(request);\n        });\n      },\n    });\n    this.route(router, {\n      name: \"universalSearch\",\n      method: \"post\",\n      path: UNIVERSAL_ROUTE,\n      handler: async (req, res) => {\n        await this.respond(res, \"universalSearch\", () => {\n          const request = searchContract.universalSearchRequestSchema.parse(req.body ?? {});\n          return this.asUser(req).runUniversalSearch(request);\n        });\n      },\n    });\n    this.route(router, {\n      name: \"indexes\",\n      method: \"get\",\n      path: INDEXES_ROUTE,\n      handler: async (_req, res) => {\n        res.json(this.clientConfig());\n      },\n    });\n    this.route(router, {\n      name: \"documents\",\n      method: \"post\",\n      path: DOCUMENTS_ROUTE,\n      handler: async (req, res) => {\n        const { config } = getSearchRuntime();\n        if (!config.allowWrite) {\n          res.status(403).json({ error: \"the document write surface is disabled\" });\n          return;\n        }\n        await this.respond(res, \"addDocuments\", () =>\n          this.asUser(req).runAddDocuments(req.body ?? {}),\n        );\n      },\n    });\n    this.route(router, {\n      name: \"createIndex\",\n      method: \"post\",\n      path: INDEX_ROUTE,\n      handler: async (req, res) => {\n        const { config } = getSearchRuntime();\n        if (!config.allowWrite) {\n          res.status(403).json({ error: \"the index write surface is disabled\" });\n          return;\n        }\n        await this.respond(res, \"createIndex\", () =>\n          this.asUser(req).runCreateIndex(req.body ?? {}),\n        );\n      },\n    });\n    this.route(router, {\n      name: \"syncIndex\",\n      method: \"post\",\n      path: INDEX_SYNC_ROUTE,\n      handler: async (req, res) => {\n        const { config } = getSearchRuntime();\n        if (!config.allowWrite) {\n          res.status(403).json({ error: \"the index write surface is disabled\" });\n          return;\n        }\n        await this.respond(res, \"syncIndex\", () => this.asUser(req).runSyncIndex(req.body ?? {}));\n      },\n    });\n  }\n\n  /**\n   * Run a route body, turning a failure into a JSON error response.\n   *\n   * AppKit's `route()` registers the handler as-is, so a rejection escapes as\n   * an unhandled promise rejection and takes the whole process down rather than\n   * failing the one request. Every route here goes through this, so a bad index\n   * name or a Vector Search API error returns 500 with a message instead of\n   * killing the server.\n   */\n  private async respond(\n    res: Parameters<Parameters<IAppRouter[\"post\"]>[1]>[1],\n    operation: string,\n    run: () => Promise<unknown>,\n  ): Promise<void> {\n    try {\n      res.json(await run());\n    } catch (cause) {\n      const message = errorUtil.errorMessage(cause);\n      logger.warn(\"route-failed\", { operation, message });\n      res.status(500).json({ error: message });\n    }\n  }\n\n  /** Surface the index catalogue + defaults so a search box needs no round-trip. */\n  override clientConfig(): Record<string, unknown> {\n    const { config } = getSearchRuntime({ config: this.config });\n    const payload: SearchClientConfig = {\n      indexes: config.indexes.map((index) => ({\n        name: index.name,\n        alias: index.alias,\n        ...(index.primaryKey ? { primaryKey: index.primaryKey } : {}),\n        ...(index.columns ? { columns: index.columns } : {}),\n        ...(index.name === config.defaultIndex ? { isDefault: true } : {}),\n      })),\n      ...(config.defaultIndex ? { defaultIndex: config.defaultIndex } : {}),\n      pageSize: config.pageSize,\n      basePath: this.basePath,\n    };\n    return payload as unknown as Record<string, unknown>;\n  }\n\n  /** AppKit `ToolProvider`: the tool definitions offered to an agent. */\n  getAgentTools(): AgentToolDefinition[] {\n    return toolsFromRegistry(this.tools);\n  }\n\n  /** AppKit `ToolProvider`: run one tool call, validating input against its schema. */\n  async executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown> {\n    return executeFromRegistry(this.tools, name, args, signal);\n  }\n\n  override exports() {\n    return {\n      /** Search one index (default when omitted). Runs as the current context user. */\n      search: (request: searchContract.SearchRequest, signal?: AbortSignal) =>\n        this.runSearch(request, signal),\n      /** Search across every configured index and merge the hits. */\n      universalSearch: (request: searchContract.UniversalSearchRequest, signal?: AbortSignal) =>\n        this.runUniversalSearch(request, signal),\n      /** Add or update documents in a direct-access index (throws when writes are disabled). */\n      addDocuments: (request: { index?: string; documents: unknown }, signal?: AbortSignal) =>\n        this.runAddDocuments(request, signal),\n      /** Create a Vector Search index (throws when writes are disabled). */\n      createIndex: (request: searchContract.CreateIndexRequest, signal?: AbortSignal) =>\n        this.runCreateIndex(request, signal),\n      /** Sync a Delta Sync index from its source table (throws when writes are disabled). */\n      syncIndex: (request: searchContract.SyncIndexRequest, signal?: AbortSignal) =>\n        this.runSyncIndex(request, signal),\n    };\n  }\n\n  private async runSearch(args: unknown, signal?: AbortSignal) {\n    const request = searchContract.searchRequestSchema.parse(args);\n    const { client } = getSearchRuntime();\n    return client.search(request.query, {\n      ...(request.index ? { index: request.index } : {}),\n      ...(request.limit ? { limit: request.limit } : {}),\n      ...(request.mode ? { mode: request.mode } : {}),\n      ...(request.columns ? { columns: request.columns } : {}),\n      ...(request.filter ? { filter: request.filter } : {}),\n      ...(request.scoreThreshold !== undefined ? { scoreThreshold: request.scoreThreshold } : {}),\n      ...(signal ? { signal } : {}),\n    });\n  }\n\n  private async runUniversalSearch(args: unknown, signal?: AbortSignal) {\n    const request = searchContract.universalSearchRequestSchema.parse(args);\n    const { client } = getSearchRuntime();\n    return client.universalSearch(request.query, {\n      ...(request.indexes ? { indexes: request.indexes } : {}),\n      ...(request.limit ? { limit: request.limit } : {}),\n      ...(request.mode ? { mode: request.mode } : {}),\n      ...(signal ? { signal } : {}),\n    });\n  }\n\n  private async runAddDocuments(args: unknown, signal?: AbortSignal) {\n    const record = (args ?? {}) as { index?: string; documents: unknown };\n    const { client, config } = getSearchRuntime();\n    const documents = toDocumentArray(record.documents);\n    const index = record.index ?? config.defaultIndex ?? \"\";\n    return client.addDocuments(index, documents, signal);\n  }\n\n  private async runCreateIndex(args: unknown, signal?: AbortSignal) {\n    const request = searchContract.createIndexRequestSchema.parse(args);\n    const { client } = getSearchRuntime();\n    return client.createIndex(request.name, toCreateIndexOptions(request, signal));\n  }\n\n  private async runSyncIndex(args: unknown, signal?: AbortSignal) {\n    const request = searchContract.syncIndexRequestSchema.parse(args);\n    const { client, config } = getSearchRuntime();\n    const index = request.index ?? config.defaultIndex ?? \"\";\n    await client.syncIndex(index, signal);\n    return { index, synced: true };\n  }\n}\n\n/**\n * Register the AI Search plugin with AppKit.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as searchPlugin, tool as searchToolModule } from \"@dbx-tools/search\";\n * import { agents, plugin as mastraPlugin } from \"@dbx-tools/appkit-mastra\";\n *\n * const support = agents.createAgent({\n *   instructions: \"Answer from the docs; use `search` to find them.\",\n *   tools: () => ({ search: searchToolModule.searchTool() }),\n * });\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     searchPlugin.search({ index: \"main.support.docs\" }),\n *     mastraPlugin.mastra({ agents: support }),\n *   ],\n * });\n * ```\n */\nexport const search = toPlugin(SearchPlugin);\n"]}