@dbx-tools/search 0.6.9

package/lib/src/query.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Translation between the browser-safe search contract and the Databricks
+ * Vector Search query API, kept in one place so the client, the tools, and the
+ * routes never hand-roll a `filters_json` string or unpack a `data_array` by
+ * hand.
+ *
+ *   - {@link toQueryType} maps the friendly {@link SearchMode} onto the API's
+ *     `query_type` (`HYBRID` / `ANN`). Keyword-only search rides on `ANN` with
+ *     text but no vector, which Databricks answers with its BM25 path.
+ *   - {@link compileFilter} turns the `{ column: value }` filter object (with
+ *     optional operator maps like `{ ">=": 10 }`) into the `filters_json`
+ *     string the API expects, so a caller never learns Databricks' filter
+ *     spelling.
+ *   - {@link toHits} unpacks the columnar `{ manifest, result }` response into
+ *     `{ id, score, fields }` hits, pulling the score out of the reserved
+ *     `__db_score` / `score` column and the id out of the primary-key column.
+ *
+ * @module
+ */
+import type { SearchHit, SearchMode } from "@dbx-tools/shared-search";
+/** Map a {@link SearchMode} onto the serving API `query_type`. */
+export declare function toQueryType(mode: SearchMode): string;
+/**
+ * Compile a `{ column: value }` filter object into the `filters_json` string
+ * the query API expects. A scalar becomes an equality; an array becomes an
+ * IN-style match; an operator map (`{ ">=": 10, "<": 20 }`) expands to the
+ * `column operator` keys Databricks uses. Returns `undefined` for an empty
+ * filter so the field is omitted rather than sent as `{}`.
+ */
+export declare function compileFilter(filter: Record<string, unknown> | undefined): string | undefined;
+/** A minimal structural view of the Vector Search query response. */
+export interface QueryResponseLike {
+    manifest?: {
+        columns?: Array<{
+            name?: string;
+        }>;
+    };
+    result?: {
+        data_array?: Array<Array<unknown>>;
+    };
+    next_page_token?: string;
+}
+/**
+ * Unpack a columnar query response into {@link SearchHit}s. The manifest names
+ * the columns in order; each row is a positional array. The score comes from
+ * the reserved score column and the id from `primaryKey` (falling back to the
+ * first column when the key is unknown). The score column is stripped from
+ * `fields` so a hit's fields are just the document.
+ */
+export declare function toHits(response: QueryResponseLike, primaryKey: string | undefined, indexName?: string): SearchHit[];
+/**
+ * The columns to request from an index for a search. When neither the request
+ * nor the index config names columns, the score column alone is requested and
+ * the primary key is appended so a hit always has an id. Callers that want the
+ * whole document should pass the index's own column list.
+ */
+export declare function toRequestColumns(requested: readonly string[] | undefined, fallback: readonly string[] | undefined, primaryKey: string | undefined): string[];
+/**
+ * Parse a JSON document payload the model / a route supplied for a write.
+ * Accepts an already-parsed array/object or a JSON string, and always returns
+ * an array so a single document and a batch are handled the same way. Throws a
+ * {@link ValidationError} on unparseable input so the caller can surface it.
+ */
+export declare function toDocumentArray(input: unknown): Array<Record<string, unknown>>;

package/lib/src/query.js

@@ -0,0 +1,109 @@
+/**
+ * Translation between the browser-safe search contract and the Databricks
+ * Vector Search query API, kept in one place so the client, the tools, and the
+ * routes never hand-roll a `filters_json` string or unpack a `data_array` by
+ * hand.
+ *
+ *   - {@link toQueryType} maps the friendly {@link SearchMode} onto the API's
+ *     `query_type` (`HYBRID` / `ANN`). Keyword-only search rides on `ANN` with
+ *     text but no vector, which Databricks answers with its BM25 path.
+ *   - {@link compileFilter} turns the `{ column: value }` filter object (with
+ *     optional operator maps like `{ ">=": 10 }`) into the `filters_json`
+ *     string the API expects, so a caller never learns Databricks' filter
+ *     spelling.
+ *   - {@link toHits} unpacks the columnar `{ manifest, result }` response into
+ *     `{ id, score, fields }` hits, pulling the score out of the reserved
+ *     `__db_score` / `score` column and the id out of the primary-key column.
+ *
+ * @module
+ */
+import { ValidationError } from "@databricks/appkit";
+import { json, object } from "@dbx-tools/shared-core";
+/** The column name Databricks Vector Search returns the relevance score under. */
+const SCORE_COLUMN = "__db_score";
+/** Map a {@link SearchMode} onto the serving API `query_type`. */
+export function toQueryType(mode) {
+    return mode === "hybrid" ? "HYBRID" : "ANN";
+}
+/**
+ * Compile a `{ column: value }` filter object into the `filters_json` string
+ * the query API expects. A scalar becomes an equality; an array becomes an
+ * IN-style match; an operator map (`{ ">=": 10, "<": 20 }`) expands to the
+ * `column operator` keys Databricks uses. Returns `undefined` for an empty
+ * filter so the field is omitted rather than sent as `{}`.
+ */
+export function compileFilter(filter) {
+    if (!filter || Object.keys(filter).length === 0)
+        return undefined;
+    const compiled = {};
+    for (const [column, value] of Object.entries(filter)) {
+        if (object.isRecord(value)) {
+            for (const [op, operand] of Object.entries(value)) {
+                compiled[`${column} ${op}`] = operand;
+            }
+        }
+        else {
+            compiled[column] = value;
+        }
+    }
+    return JSON.stringify(compiled);
+}
+/**
+ * Unpack a columnar query response into {@link SearchHit}s. The manifest names
+ * the columns in order; each row is a positional array. The score comes from
+ * the reserved score column and the id from `primaryKey` (falling back to the
+ * first column when the key is unknown). The score column is stripped from
+ * `fields` so a hit's fields are just the document.
+ */
+export function toHits(response, primaryKey, indexName) {
+    const columns = (response.manifest?.columns ?? []).map((c) => c.name ?? "");
+    const rows = response.result?.data_array ?? [];
+    const scoreIdx = columns.indexOf(SCORE_COLUMN);
+    const keyIdx = primaryKey ? columns.indexOf(primaryKey) : -1;
+    return rows.map((row, rowIndex) => {
+        const fields = {};
+        columns.forEach((name, i) => {
+            if (i === scoreIdx || !name)
+                return;
+            fields[name] = row[i];
+        });
+        const scoreRaw = scoreIdx >= 0 ? Number(row[scoreIdx]) : NaN;
+        const idRaw = keyIdx >= 0 ? row[keyIdx] : primaryKey ? fields[primaryKey] : (row[0] ?? rowIndex);
+        return {
+            id: String(idRaw ?? rowIndex),
+            score: Number.isFinite(scoreRaw) ? scoreRaw : 0,
+            fields,
+            ...(indexName ? { index: indexName } : {}),
+        };
+    });
+}
+/**
+ * The columns to request from an index for a search. When neither the request
+ * nor the index config names columns, the score column alone is requested and
+ * the primary key is appended so a hit always has an id. Callers that want the
+ * whole document should pass the index's own column list.
+ */
+export function toRequestColumns(requested, fallback, primaryKey) {
+    const base = requested && requested.length > 0 ? requested : (fallback ?? []);
+    const columns = new Set(base);
+    if (primaryKey)
+        columns.add(primaryKey);
+    if (columns.size === 0 && primaryKey)
+        columns.add(primaryKey);
+    return [...columns];
+}
+/**
+ * Parse a JSON document payload the model / a route supplied for a write.
+ * Accepts an already-parsed array/object or a JSON string, and always returns
+ * an array so a single document and a batch are handled the same way. Throws a
+ * {@link ValidationError} on unparseable input so the caller can surface it.
+ */
+export function toDocumentArray(input) {
+    const value = typeof input === "string" ? json.parse(input, undefined) : input;
+    if (value === undefined) {
+        throw new ValidationError("documents must be a JSON object, array, or string");
+    }
+    const list = Array.isArray(value) ? value : [value];
+    return list.filter(object.isRecord);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/query.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Translation between the browser-safe search contract and the Databricks\n * Vector Search query API, kept in one place so the client, the tools, and the\n * routes never hand-roll a `filters_json` string or unpack a `data_array` by\n * hand.\n *\n *   - {@link toQueryType} maps the friendly {@link SearchMode} onto the API's\n *     `query_type` (`HYBRID` / `ANN`). Keyword-only search rides on `ANN` with\n *     text but no vector, which Databricks answers with its BM25 path.\n *   - {@link compileFilter} turns the `{ column: value }` filter object (with\n *     optional operator maps like `{ \">=\": 10 }`) into the `filters_json`\n *     string the API expects, so a caller never learns Databricks' filter\n *     spelling.\n *   - {@link toHits} unpacks the columnar `{ manifest, result }` response into\n *     `{ id, score, fields }` hits, pulling the score out of the reserved\n *     `__db_score` / `score` column and the id out of the primary-key column.\n *\n * @module\n */\n\nimport { ValidationError } from \"@databricks/appkit\";\nimport type { SearchHit, SearchMode } from \"@dbx-tools/shared-search\";\nimport { json, object } from \"@dbx-tools/shared-core\";\n\n/** The column name Databricks Vector Search returns the relevance score under. */\nconst SCORE_COLUMN = \"__db_score\";\n\n/** Map a {@link SearchMode} onto the serving API `query_type`. */\nexport function toQueryType(mode: SearchMode): string {\n  return mode === \"hybrid\" ? \"HYBRID\" : \"ANN\";\n}\n\n/**\n * Compile a `{ column: value }` filter object into the `filters_json` string\n * the query API expects. A scalar becomes an equality; an array becomes an\n * IN-style match; an operator map (`{ \">=\": 10, \"<\": 20 }`) expands to the\n * `column operator` keys Databricks uses. Returns `undefined` for an empty\n * filter so the field is omitted rather than sent as `{}`.\n */\nexport function compileFilter(filter: Record<string, unknown> | undefined): string | undefined {\n  if (!filter || Object.keys(filter).length === 0) return undefined;\n  const compiled: Record<string, unknown> = {};\n  for (const [column, value] of Object.entries(filter)) {\n    if (object.isRecord(value)) {\n      for (const [op, operand] of Object.entries(value)) {\n        compiled[`${column} ${op}`] = operand;\n      }\n    } else {\n      compiled[column] = value;\n    }\n  }\n  return JSON.stringify(compiled);\n}\n\n/** A minimal structural view of the Vector Search query response. */\nexport interface QueryResponseLike {\n  manifest?: { columns?: Array<{ name?: string }> };\n  result?: { data_array?: Array<Array<unknown>> };\n  next_page_token?: string;\n}\n\n/**\n * Unpack a columnar query response into {@link SearchHit}s. The manifest names\n * the columns in order; each row is a positional array. The score comes from\n * the reserved score column and the id from `primaryKey` (falling back to the\n * first column when the key is unknown). The score column is stripped from\n * `fields` so a hit's fields are just the document.\n */\nexport function toHits(\n  response: QueryResponseLike,\n  primaryKey: string | undefined,\n  indexName?: string,\n): SearchHit[] {\n  const columns = (response.manifest?.columns ?? []).map((c) => c.name ?? \"\");\n  const rows = response.result?.data_array ?? [];\n  const scoreIdx = columns.indexOf(SCORE_COLUMN);\n  const keyIdx = primaryKey ? columns.indexOf(primaryKey) : -1;\n  return rows.map((row, rowIndex) => {\n    const fields: Record<string, unknown> = {};\n    columns.forEach((name, i) => {\n      if (i === scoreIdx || !name) return;\n      fields[name] = row[i];\n    });\n    const scoreRaw = scoreIdx >= 0 ? Number(row[scoreIdx]) : NaN;\n    const idRaw =\n      keyIdx >= 0 ? row[keyIdx] : primaryKey ? fields[primaryKey] : (row[0] ?? rowIndex);\n    return {\n      id: String(idRaw ?? rowIndex),\n      score: Number.isFinite(scoreRaw) ? scoreRaw : 0,\n      fields,\n      ...(indexName ? { index: indexName } : {}),\n    };\n  });\n}\n\n/**\n * The columns to request from an index for a search. When neither the request\n * nor the index config names columns, the score column alone is requested and\n * the primary key is appended so a hit always has an id. Callers that want the\n * whole document should pass the index's own column list.\n */\nexport function toRequestColumns(\n  requested: readonly string[] | undefined,\n  fallback: readonly string[] | undefined,\n  primaryKey: string | undefined,\n): string[] {\n  const base = requested && requested.length > 0 ? requested : (fallback ?? []);\n  const columns = new Set<string>(base);\n  if (primaryKey) columns.add(primaryKey);\n  if (columns.size === 0 && primaryKey) columns.add(primaryKey);\n  return [...columns];\n}\n\n/**\n * Parse a JSON document payload the model / a route supplied for a write.\n * Accepts an already-parsed array/object or a JSON string, and always returns\n * an array so a single document and a batch are handled the same way. Throws a\n * {@link ValidationError} on unparseable input so the caller can surface it.\n */\nexport function toDocumentArray(input: unknown): Array<Record<string, unknown>> {\n  const value = typeof input === \"string\" ? json.parse(input, undefined) : input;\n  if (value === undefined) {\n    throw new ValidationError(\"documents must be a JSON object, array, or string\");\n  }\n  const list = Array.isArray(value) ? value : [value];\n  return list.filter(object.isRecord);\n}\n"]}

package/lib/src/runtime.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The shared AI Search runtime: the resolved config plus a single
+ * {@link SearchClient} instance the plugin, the Mastra tools, and the routes
+ * all read. Mirrors the web-search / email runtime pattern - the plugin primes
+ * it from its config at setup, and everything else reads the same instance so
+ * a tool invoked outside the agent still sees the deployment's config.
+ *
+ * @module
+ */
+import { SearchClient } from "./client.ts";
+import { type SearchPluginConfig, type ResolvedSearchConfig } from "./config.ts";
+import { LakebaseSearchBackend } from "./lakebase.ts";
+/**
+ * How the runtime is built. `lakebase` (when present) is the Postgres full-text
+ * FALLBACK backend the plugin wires up when no Vector Search endpoint is
+ * configured but the AppKit `lakebase` plugin is registered. Every read/write
+ * returns the same shape either way.
+ */
+export interface SearchRuntimeOptions {
+    config?: SearchPluginConfig;
+    lakebase?: LakebaseSearchBackend;
+}
+/** The shared resolved config plus the client reads run through. */
+export interface SearchRuntime {
+    config: ResolvedSearchConfig;
+    client: SearchClient;
+    /** The Lakebase fallback backend, when the runtime is backed by Postgres. */
+    lakebase?: LakebaseSearchBackend;
+}
+/**
+ * Return the shared runtime, building it on first use from the supplied config
+ * layered over environment defaults. Overrides are only read when the runtime
+ * is first created, so prime it from the plugin's config at setup; subsequent
+ * calls pass nothing and get the same instance.
+ */
+export declare function getSearchRuntime(options?: SearchRuntimeOptions): SearchRuntime;
+/** Drop the memoized runtime so the next {@link getSearchRuntime} rebuilds it. */
+export declare function resetSearchRuntime(): void;

package/lib/src/runtime.js

@@ -0,0 +1,38 @@
+/**
+ * The shared AI Search runtime: the resolved config plus a single
+ * {@link SearchClient} instance the plugin, the Mastra tools, and the routes
+ * all read. Mirrors the web-search / email runtime pattern - the plugin primes
+ * it from its config at setup, and everything else reads the same instance so
+ * a tool invoked outside the agent still sees the deployment's config.
+ *
+ * @module
+ */
+import { createSearchClient } from "./client.js";
+import { resolveSearchConfig, } from "./config.js";
+let runtime;
+/**
+ * Return the shared runtime, building it on first use from the supplied config
+ * layered over environment defaults. Overrides are only read when the runtime
+ * is first created, so prime it from the plugin's config at setup; subsequent
+ * calls pass nothing and get the same instance.
+ */
+export function getSearchRuntime(options) {
+    if (!runtime) {
+        const config = resolveSearchConfig(options?.config);
+        const lakebase = options?.lakebase;
+        runtime = {
+            config,
+            client: createSearchClient(config, undefined, lakebase),
+            ...(lakebase ? { lakebase } : {}),
+        };
+    }
+    return runtime;
+}
+/** Drop the memoized runtime so the next {@link getSearchRuntime} rebuilds it. */
+export function resetSearchRuntime() {
+    const backend = runtime?.lakebase;
+    runtime = undefined;
+    if (backend)
+        void backend.close();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/schema.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Tool-facing descriptions and the request schemas the Mastra tools + AppKit
+ * tool provider validate against. The wire shapes themselves live in
+ * `@dbx-tools/shared-search`; this module adds the model-readable
+ * descriptions so both hosts describe the tools identically.
+ *
+ * @module
+ */
+/** Description the model reads for the `search` tool. */
+export declare const SEARCH_TOOL_DESCRIPTION: string;
+/** Description the model reads for the `universal_search` tool. */
+export declare const UNIVERSAL_SEARCH_TOOL_DESCRIPTION: string;
+/** Description the model reads for the `add_documents` tool. */
+export declare const ADD_DOCUMENTS_TOOL_DESCRIPTION: string;
+/** Description the model reads for the `create_index` tool. */
+export declare const CREATE_INDEX_TOOL_DESCRIPTION: string;
+/** Description the model reads for the `sync_index` tool. */
+export declare const SYNC_INDEX_TOOL_DESCRIPTION: string;
+/** Schema for the `search` tool input (the shared request schema). */
+export declare const searchToolSchema: import("zod").ZodObject<{
+    query: import("zod").ZodString;
+    index: import("zod").ZodOptional<import("zod").ZodString>;
+    limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+        hybrid: "hybrid";
+        vector: "vector";
+        keyword: "keyword";
+    }>>;
+    columns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    filter: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    scoreThreshold: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>;
+/** Schema for the `universal_search` tool input. */
+export declare const universalSearchToolSchema: import("zod").ZodObject<{
+    query: import("zod").ZodString;
+    indexes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+        hybrid: "hybrid";
+        vector: "vector";
+        keyword: "keyword";
+    }>>;
+}, import("zod/v4/core").$strip>;
+/** Schema for the `search` / `universal_search` tool output. */
+export declare const searchResultSchema: import("zod").ZodObject<{
+    query: import("zod").ZodString;
+    hits: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        score: import("zod").ZodNumber;
+        fields: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        index: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    index: import("zod").ZodOptional<import("zod").ZodString>;
+    count: import("zod").ZodNumber;
+}, import("zod/v4/core").$strip>;
+/** Schema for the `create_index` tool input. */
+export declare const createIndexToolSchema: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    sourceTable: import("zod").ZodOptional<import("zod").ZodString>;
+    primaryKey: import("zod").ZodOptional<import("zod").ZodString>;
+    embeddingSourceColumn: import("zod").ZodOptional<import("zod").ZodString>;
+    embeddingModel: import("zod").ZodOptional<import("zod").ZodString>;
+    endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+    embeddingDimension: import("zod").ZodOptional<import("zod").ZodNumber>;
+    pipelineType: import("zod").ZodOptional<import("zod").ZodEnum<{
+        TRIGGERED: "TRIGGERED";
+        CONTINUOUS: "CONTINUOUS";
+    }>>;
+    columnsToSync: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>;
+/** Schema for the `create_index` tool output (a resolved index definition). */
+export declare const indexInfoSchema: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+    primaryKey: import("zod").ZodOptional<import("zod").ZodString>;
+    columns: import("zod").ZodArray<import("zod").ZodString>;
+    ready: import("zod").ZodBoolean;
+    rowCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>;
+/** Schema for the `sync_index` tool input. */
+export declare const syncIndexToolSchema: import("zod").ZodObject<{
+    index: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;

package/lib/src/schema.js

@@ -0,0 +1,64 @@
+/**
+ * Tool-facing descriptions and the request schemas the Mastra tools + AppKit
+ * tool provider validate against. The wire shapes themselves live in
+ * `@dbx-tools/shared-search`; this module adds the model-readable
+ * descriptions so both hosts describe the tools identically.
+ *
+ * @module
+ */
+import { search } from "@dbx-tools/shared-search";
+import { string } from "@dbx-tools/shared-core";
+/** Description the model reads for the `search` tool. */
+export const SEARCH_TOOL_DESCRIPTION = string.toDescription(`
+  Search a Databricks AI Search (Vector Search) index for the documents most
+  relevant to a query. Pass a natural-language question or keywords; hybrid
+  matching combines semantic similarity with keyword ranking, so exact terms
+  (product names, error codes) and paraphrases both work. Optionally name an
+  index (defaults to the app's configured index), a result limit, and attribute
+  filters. Use it to look up docs, knowledge-base articles, products, or any
+  indexed content before answering.
+`);
+/** Description the model reads for the `universal_search` tool. */
+export const UNIVERSAL_SEARCH_TOOL_DESCRIPTION = string.toDescription(`
+  Search across every configured AI Search index at once and return the best
+  matches from all of them, merged and ranked. Use it when the right index
+  isn't known in advance or when an answer may live in any of several
+  collections (docs, tickets, products).
+`);
+/** Description the model reads for the `add_documents` tool. */
+export const ADD_DOCUMENTS_TOOL_DESCRIPTION = string.toDescription(`
+  Add or update documents in a direct-access AI Search index. Pass an array of
+  documents as JSON objects; each MUST include the index's primary-key column.
+  Only available when the app enables the write surface. Use it to index new
+  content the user provides.
+`);
+/** Description the model reads for the `create_index` tool. */
+export const CREATE_INDEX_TOOL_DESCRIPTION = string.toDescription(`
+  Create a Databricks AI Search (Vector Search) index. For the common case pass
+  a Delta source table (catalog.schema.table): Databricks computes embeddings
+  from its text column and keeps the index synced. To create a direct-access
+  index you write vectors to yourself, pass an embedding dimension instead of a
+  source table. The endpoint, embedding model, primary key, and text column are
+  inferred when omitted. Only available when the app enables the write surface.
+  Creating an index provisions infrastructure - do this only when the user
+  explicitly asks to set up a new index.
+`);
+/** Description the model reads for the `sync_index` tool. */
+export const SYNC_INDEX_TOOL_DESCRIPTION = string.toDescription(`
+  Refresh a Delta Sync AI Search index from its source table so newly added or
+  changed rows become searchable. Optionally name the index (defaults to the
+  app's default index). Only available when the app enables the write surface.
+`);
+/** Schema for the `search` tool input (the shared request schema). */
+export const searchToolSchema = search.searchRequestSchema;
+/** Schema for the `universal_search` tool input. */
+export const universalSearchToolSchema = search.universalSearchRequestSchema;
+/** Schema for the `search` / `universal_search` tool output. */
+export const searchResultSchema = search.searchResultSchema;
+/** Schema for the `create_index` tool input. */
+export const createIndexToolSchema = search.createIndexRequestSchema;
+/** Schema for the `create_index` tool output (a resolved index definition). */
+export const indexInfoSchema = search.indexInfoSchema;
+/** Schema for the `sync_index` tool input. */
+export const syncIndexToolSchema = search.syncIndexRequestSchema;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/tool.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The `search`, `universal_search`, and (opt-in) `add_documents`,
+ * `create_index`, and `sync_index` Mastra tools.
+ *
+ * All three read the shared runtime primed by the plugin, so a tool spread
+ * into an agent uses the deployment's default index, columns, page size, and
+ * mode without any per-tool wiring. They run under the caller's OBO scope (the
+ * client resolves the execution context's workspace client), so search runs as
+ * the requesting user and Unity Catalog ACLs apply.
+ *
+ * The same tools are exposed to AppKit's own agents through the plugin's
+ * `ToolProvider` (see `plugin.ts`); this module is the Mastra half.
+ *
+ * @module
+ */
+/** Common option accepted by every tool factory: override the tool id. */
+export interface SearchToolOptions {
+    /** Override the tool id (defaults per tool). */
+    id?: string;
+}
+/**
+ * Build the `search` tool. Spread it into any agent that should be able to look
+ * things up in an index.
+ *
+ * @example
+ * ```ts
+ * import { searchTool } from "@dbx-tools/search";
+ * import { createAgent } from "@dbx-tools/appkit-mastra";
+ *
+ * const support = createAgent({
+ *   instructions: "Answer from the docs. Use `search` to find them.",
+ *   tools: () => ({ search: searchTool() }),
+ * });
+ * ```
+ */
+export declare function searchTool(options?: SearchToolOptions): import("@mastra/core/tools").Tool<{
+    query: string;
+    index?: string | undefined;
+    limit?: number | undefined;
+    mode?: "hybrid" | "vector" | "keyword" | undefined;
+    columns?: string[] | undefined;
+    filter?: Record<string, unknown> | undefined;
+    scoreThreshold?: number | undefined;
+}, {
+    query: string;
+    hits: {
+        id: string;
+        score: number;
+        fields: Record<string, unknown>;
+        index?: string | undefined;
+    }[];
+    count: number;
+    index?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;
+/** Build the `universal_search` tool (federated search across every index). */
+export declare function universalSearchTool(options?: SearchToolOptions): import("@mastra/core/tools").Tool<{
+    query: string;
+    indexes?: string[] | undefined;
+    limit?: number | undefined;
+    mode?: "hybrid" | "vector" | "keyword" | undefined;
+}, {
+    query: string;
+    hits: {
+        id: string;
+        score: number;
+        fields: Record<string, unknown>;
+        index?: string | undefined;
+    }[];
+    count: number;
+    index?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;
+/**
+ * Build the opt-in `add_documents` tool (write into a direct-access index).
+ * Only install it when the plugin's write surface is enabled.
+ */
+export declare function addDocumentsTool(options?: SearchToolOptions): import("@mastra/core/tools").Tool<{
+    documents: Record<string, unknown>[];
+    index?: string | undefined;
+}, {
+    index: string;
+    count: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;
+/**
+ * Build the opt-in `create_index` tool (provision a Vector Search index).
+ * Only install it when the plugin's write surface is enabled. Delegates to
+ * {@link SearchClient.createIndex}, inferring the endpoint, embedding model,
+ * key, and columns from the request + plugin config.
+ */
+export declare function createIndexTool(options?: SearchToolOptions): import("@mastra/core/tools").Tool<{
+    name: string;
+    sourceTable?: string | undefined;
+    primaryKey?: string | undefined;
+    embeddingSourceColumn?: string | undefined;
+    embeddingModel?: string | undefined;
+    endpoint?: string | undefined;
+    embeddingDimension?: number | undefined;
+    pipelineType?: "TRIGGERED" | "CONTINUOUS" | undefined;
+    columnsToSync?: string[] | undefined;
+}, {
+    name: string;
+    columns: string[];
+    ready: boolean;
+    endpoint?: string | undefined;
+    primaryKey?: string | undefined;
+    rowCount?: number | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;
+/**
+ * Build the opt-in `sync_index` tool (refresh a Delta Sync index from its
+ * source table). Only install it when the plugin's write surface is enabled.
+ */
+export declare function syncIndexTool(options?: SearchToolOptions): import("@mastra/core/tools").Tool<{
+    index?: string | undefined;
+}, {
+    index: string;
+    synced: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;