@dbx-tools/search 0.6.87 → 0.6.89

package/src/config.ts

@@ -23,7 +23,7 @@
  */
 
 import { ConfigurationError, type BasePluginConfig } from "@databricks/appkit";
-import { config as runtimeConfig } from "@dbx-tools/core";
+import { config as coreConfig } from "@dbx-tools/core";
 import { object, string } from "@dbx-tools/shared-core";
 import type { SearchDocument, SearchMode } from "@dbx-tools/shared-search";
 import type { JSONSchema7 } from "json-schema";
@@ -238,7 +238,7 @@ function toResolvedIndex(entry: string | SearchIndexConfig): ResolvedIndexConfig
 
 /** Parse and validate a {@link SearchMode} from config or an env var. */
 function resolveMode(configured: SearchMode | undefined): SearchMode {
-  const raw = configured ?? runtimeConfig.text("SEARCH_MODE", runtimeConfig.ENV_ONLY);
+  const raw = configured ?? coreConfig.text("SEARCH_MODE", coreConfig.ENV_ONLY);
   if (raw === undefined) return DEFAULT_MODE;
   if (raw !== "hybrid" && raw !== "vector" && raw !== "keyword") {
     throw new ConfigurationError(
@@ -256,10 +256,10 @@ function resolveMode(configured: SearchMode | undefined): SearchMode {
  * and a bad mode throws a {@link ConfigurationError} naming the field.
  */
 export function resolveSearchConfig(config: SearchPluginConfig = {}): ResolvedSearchConfig {
-  const defaultIndexRaw = runtimeConfig.string(
+  const defaultIndexRaw = coreConfig.string(
     config.index,
     [INDEX_ENV, DATABRICKS_INDEX_ENV],
-    runtimeConfig.ENV_ONLY,
+    coreConfig.ENV_ONLY,
   );
 
   const configured = (config.indexes ?? [])
@@ -268,11 +268,11 @@ export function resolveSearchConfig(config: SearchPluginConfig = {}): ResolvedSe
 
   // Ensure the default index is represented in the known set.
   if (defaultIndexRaw && !configured.some((i) => i.name === defaultIndexRaw)) {
-    const envColumns = runtimeConfig.list(
+    const envColumns = coreConfig.list(
       undefined,
       "SEARCH_COLUMNS",
       undefined,
-      runtimeConfig.ENV_ONLY,
+      coreConfig.ENV_ONLY,
     );
     configured.unshift({
       name: defaultIndexRaw,
@@ -290,11 +290,11 @@ export function resolveSearchConfig(config: SearchPluginConfig = {}): ResolvedSe
   });
 
   const defaultIndex = defaultIndexRaw ?? indexes[0]?.name;
-  const columns = runtimeConfig.list(
+  const columns = coreConfig.list(
     config.columns,
     "SEARCH_COLUMNS",
     undefined,
-    runtimeConfig.ENV_ONLY,
+    coreConfig.ENV_ONLY,
   );
 
   return {
@@ -302,29 +302,29 @@ export function resolveSearchConfig(config: SearchPluginConfig = {}): ResolvedSe
     indexes,
     ...object.optional(
       "endpoint",
-      runtimeConfig.string(config.endpoint, ENDPOINT_ENV, runtimeConfig.ENV_ONLY),
+      coreConfig.string(config.endpoint, ENDPOINT_ENV, coreConfig.ENV_ONLY),
     ),
     ...(columns.length > 0 ? { columns } : {}),
-    pageSize: runtimeConfig.positiveInt(
+    pageSize: coreConfig.positiveInt(
       config.pageSize,
       "SEARCH_PAGE_SIZE",
       DEFAULT_PAGE_SIZE,
-      runtimeConfig.ENV_ONLY,
+      coreConfig.ENV_ONLY,
     ),
     mode: resolveMode(config.mode),
     ...object.optional(
       "embeddingModel",
-      runtimeConfig.string(config.embeddingModel, "SEARCH_EMBEDDING_MODEL", runtimeConfig.ENV_ONLY),
+      coreConfig.string(config.embeddingModel, "SEARCH_EMBEDDING_MODEL", coreConfig.ENV_ONLY),
     ),
     basePath: DEFAULT_BASE_PATH,
-    timeoutMs: runtimeConfig.positiveInt(
+    timeoutMs: coreConfig.positiveInt(
       config.timeoutMs,
       "SEARCH_TIMEOUT_MS",
       DEFAULT_TIMEOUT_MS,
-      runtimeConfig.ENV_ONLY,
+      coreConfig.ENV_ONLY,
     ),
     allowWrite:
-      runtimeConfig.boolean(config.allowWrite, "SEARCH_WRITE", runtimeConfig.ENV_ONLY) ?? false,
+      coreConfig.boolean(config.allowWrite, "SEARCH_WRITE", coreConfig.ENV_ONLY) ?? false,
     ...(config.ensureOnSetup ? { ensureOnSetup: config.ensureOnSetup } : {}),
   };
 }

package/src/plugin.ts

@@ -39,9 +39,9 @@ import {
   type ToolProvider,
   type ToolRegistry,
 } from "@databricks/appkit/beta";
-import { plugin as pluginLookup } from "@dbx-tools/appkit";
-import { error as errorUtil, log, string } from "@dbx-tools/shared-core";
-import { search as searchContract, type SearchClientConfig } from "@dbx-tools/shared-search";
+import { plugin as appkitPlugin } from "@dbx-tools/appkit";
+import { error as sharedError, log, string } from "@dbx-tools/shared-core";
+import { search as sharedSearch, type SearchClientConfig } from "@dbx-tools/shared-search";
 import {
   SEARCH_CONFIG_SCHEMA,
   DATABRICKS_INDEX_ENV,
@@ -178,14 +178,14 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
     const registry: ToolRegistry = {
       search: defineTool({
         description: SEARCH_TOOL_DESCRIPTION,
-        schema: searchContract.searchRequestSchema,
+        schema: sharedSearch.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,
+        schema: sharedSearch.universalSearchRequestSchema,
         annotations: { effect: "read", requiresUserContext: true },
         autoInheritable: false,
         execute: async (args, signal) => this.runUniversalSearch(args, signal),
@@ -194,23 +194,23 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
     if (config.allowWrite) {
       registry.add_documents = defineTool({
         description: ADD_DOCUMENTS_TOOL_DESCRIPTION,
-        schema: searchContract.searchRequestSchema
+        schema: sharedSearch.searchRequestSchema
           .pick({ index: true })
-          .extend({ documents: searchContract.searchDocumentSchema.array() }),
+          .extend({ documents: sharedSearch.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,
+        schema: sharedSearch.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,
+        schema: sharedSearch.syncIndexRequestSchema,
         annotations: { effect: "write", requiresUserContext: true },
         autoInheritable: false,
         execute: async (args, signal) => this.runSyncIndex(args, signal),
@@ -266,7 +266,7 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
       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);
+    const lake = appkitPlugin.instance(this.context, lakebase);
     if (!lake) return undefined;
     logger.info("backend-lakebase", {
       reason: "no Vector Search endpoint configured; using the Lakebase full-text fallback",
@@ -320,7 +320,7 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
         rowCount: info.rowCount ?? 0,
       });
     } catch (cause) {
-      logger.warn("ensure-failed", { index, message: errorUtil.errorMessage(cause) });
+      logger.warn("ensure-failed", { index, message: sharedError.errorMessage(cause) });
     }
   }
 
@@ -368,7 +368,7 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
       path: SEARCH_ROUTE,
       handler: async (req, res) => {
         await this.respond(res, "search", () => {
-          const request = searchContract.searchRequestSchema.parse(req.body ?? {});
+          const request = sharedSearch.searchRequestSchema.parse(req.body ?? {});
           return this.asUser(req).runSearch(request);
         });
       },
@@ -379,7 +379,7 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
       path: UNIVERSAL_ROUTE,
       handler: async (req, res) => {
         await this.respond(res, "universalSearch", () => {
-          const request = searchContract.universalSearchRequestSchema.parse(req.body ?? {});
+          const request = sharedSearch.universalSearchRequestSchema.parse(req.body ?? {});
           return this.asUser(req).runUniversalSearch(request);
         });
       },
@@ -454,7 +454,7 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
     try {
       res.json(await run());
     } catch (cause) {
-      const message = errorUtil.errorMessage(cause);
+      const message = sharedError.errorMessage(cause);
       logger.warn("route-failed", { operation, message });
       res.status(500).json({ error: message });
     }
@@ -491,25 +491,25 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
   override exports() {
     return {
       /** Search one index (default when omitted). Runs as the current context user. */
-      search: (request: searchContract.SearchRequest, signal?: AbortSignal) =>
+      search: (request: sharedSearch.SearchRequest, signal?: AbortSignal) =>
         this.runSearch(request, signal),
       /** Search across every configured index and merge the hits. */
-      universalSearch: (request: searchContract.UniversalSearchRequest, signal?: AbortSignal) =>
+      universalSearch: (request: sharedSearch.UniversalSearchRequest, signal?: AbortSignal) =>
         this.runUniversalSearch(request, signal),
       /** Add or update documents in a direct-access index (throws when writes are disabled). */
       addDocuments: (request: { index?: string; documents: unknown }, signal?: AbortSignal) =>
         this.runAddDocuments(request, signal),
       /** Create a Vector Search index (throws when writes are disabled). */
-      createIndex: (request: searchContract.CreateIndexRequest, signal?: AbortSignal) =>
+      createIndex: (request: sharedSearch.CreateIndexRequest, signal?: AbortSignal) =>
         this.runCreateIndex(request, signal),
       /** Sync a Delta Sync index from its source table (throws when writes are disabled). */
-      syncIndex: (request: searchContract.SyncIndexRequest, signal?: AbortSignal) =>
+      syncIndex: (request: sharedSearch.SyncIndexRequest, signal?: AbortSignal) =>
         this.runSyncIndex(request, signal),
     };
   }
 
   private async runSearch(args: unknown, signal?: AbortSignal) {
-    const request = searchContract.searchRequestSchema.parse(args);
+    const request = sharedSearch.searchRequestSchema.parse(args);
     const { client } = getSearchRuntime();
     return client.search(request.query, {
       ...(request.index ? { index: request.index } : {}),
@@ -523,7 +523,7 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
   }
 
   private async runUniversalSearch(args: unknown, signal?: AbortSignal) {
-    const request = searchContract.universalSearchRequestSchema.parse(args);
+    const request = sharedSearch.universalSearchRequestSchema.parse(args);
     const { client } = getSearchRuntime();
     return client.universalSearch(request.query, {
       ...(request.indexes ? { indexes: request.indexes } : {}),
@@ -542,13 +542,13 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
   }
 
   private async runCreateIndex(args: unknown, signal?: AbortSignal) {
-    const request = searchContract.createIndexRequestSchema.parse(args);
+    const request = sharedSearch.createIndexRequestSchema.parse(args);
     const { client } = getSearchRuntime();
     return client.createIndex(request.name, toCreateIndexOptions(request, signal));
   }
 
   private async runSyncIndex(args: unknown, signal?: AbortSignal) {
-    const request = searchContract.syncIndexRequestSchema.parse(args);
+    const request = sharedSearch.syncIndexRequestSchema.parse(args);
     const { client, config } = getSearchRuntime();
     const index = request.index ?? config.defaultIndex ?? "";
     await client.syncIndex(index, signal);
@@ -562,12 +562,12 @@ export class SearchPlugin extends Plugin<SearchPluginConfig> implements ToolProv
  * @example
  * ```ts
  * import { createApp, server } from "@databricks/appkit";
- * import { plugin as searchPlugin, tool as searchToolModule } from "@dbx-tools/search";
+ * import { plugin as searchPlugin, tool as searchToolApi } 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() }),
+ *   tools: () => ({ search: searchToolApi.searchTool() }),
  * });
  *
  * await createApp({

package/src/tool.ts

@@ -14,7 +14,7 @@
  * @module
  */
 
-import { search as searchContract, type UpsertResult } from "@dbx-tools/shared-search";
+import { search as sharedSearch, type UpsertResult } from "@dbx-tools/shared-search";
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 import { toCreateIndexOptions } from "./index-tools.ts";
@@ -102,16 +102,16 @@ export function universalSearchTool(options: SearchToolOptions = {}) {
  * Only install it when the plugin's write surface is enabled.
  */
 export function addDocumentsTool(options: SearchToolOptions = {}) {
-  const inputSchema = searchContract.searchDocumentSchema
+  const inputSchema = sharedSearch.searchDocumentSchema
     .array()
     .describe("Documents to add or update. Each must include the index primary key.");
   return createTool({
     id: options.id ?? "add_documents",
     description: ADD_DOCUMENTS_TOOL_DESCRIPTION,
-    inputSchema: searchContract.searchRequestSchema
+    inputSchema: sharedSearch.searchRequestSchema
       .pick({ index: true })
       .extend({ documents: inputSchema }),
-    outputSchema: searchContract.upsertResultSchema,
+    outputSchema: sharedSearch.upsertResultSchema,
     execute: async (input, context): Promise<UpsertResult> => {
       const { client, config } = getSearchRuntime();
       const record = input as { index?: string; documents: unknown };