@dbx-tools/appkit-web-search 0.3.44 → 0.4.0

package/lib/src/provider.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Provider detection + web-search tool-spec mapping for the Databricks
+ * Model Serving native web-search tool.
+ *
+ * Databricks exposes web search as a first-party tool that runs *inside* a
+ * model call: the model searches the web and folds the results into its
+ * answer. The tool spec is provider-specific (see the Databricks docs,
+ * `machine-learning/model-serving/web-search`):
+ *
+ * - OpenAI GPT models, via the Responses API (`/serving-endpoints/responses`):
+ *   `tools: [{ "type": "web_search" }]`
+ * - Google Gemini models, via Chat Completions
+ *   (`/serving-endpoints/chat/completions`): `tools: [{ "google_search": {} }]`
+ *
+ * (Anthropic exposes it over MCP, which needs a different call shape; only
+ * GPT + Gemini are wired here, matching what the platform supports today.)
+ *
+ * The provider family is detected from the endpoint id the same way
+ * `@dbx-tools/shared-model`'s `classifyByFamily` keys off name substrings
+ * (`gpt` / `gemini` / `claude`), so a resolved endpoint like
+ * `databricks-gpt-5` or `databricks-gemini-3-pro` maps to its API shape.
+ *
+ * @module
+ */
+/** A web-search-capable model provider family. */
+export type WebSearchProvider = "openai" | "gemini";
+/** How a provider's native web-search call is shaped. */
+export interface WebSearchProviderSpec {
+    /**
+     * Which serving REST surface to call. `"responses"` posts to
+     * `/serving-endpoints/responses` (OpenAI Responses API); `"chat"` posts to
+     * `/serving-endpoints/chat/completions`.
+     */
+    api: "responses" | "chat";
+    /** The tool entry appended to the request's `tools` array. */
+    tool: Record<string, unknown>;
+}
+/**
+ * Built-in provider -> tool-spec map. Operators can override or extend this
+ * per provider via the plugin's `webSearchTools` config (env
+ * `WEB_SEARCH_TOOLS`), which is merged over these defaults.
+ */
+export declare const WEB_SEARCH_PROVIDERS: Readonly<Record<WebSearchProvider, WebSearchProviderSpec>>;
+/**
+ * Detect the web-search provider family for an endpoint id, or `null` when
+ * the model is not one of the web-search-capable families. Anthropic
+ * (`opus`/`sonnet`/`haiku`) is intentionally excluded - it needs an MCP call
+ * shape this module doesn't implement - so a Claude endpoint returns `null`
+ * and is treated as unsupported.
+ */
+export declare function detectWebSearchProvider(modelId: string): WebSearchProvider | null;
+/** Whether `modelId` is a web-search-capable model. */
+export declare function supportsWebSearch(modelId: string): boolean;
+/**
+ * Resolve the effective {@link WebSearchProviderSpec} for a provider: the
+ * built-in default, with any operator override (the `webSearchTools` map,
+ * keyed by provider) shallow-merged over it. An override may replace just the
+ * `tool` (the common case - a new tool type) or also the `api`. An override
+ * that is not one of those two fields is a deployment mistake that would
+ * otherwise be silently dropped, so it throws.
+ */
+export declare function webSearchToolSpec(provider: WebSearchProvider, overrides?: Record<string, unknown>): WebSearchProviderSpec;

package/lib/src/provider.js

@@ -0,0 +1,89 @@
+/**
+ * Provider detection + web-search tool-spec mapping for the Databricks
+ * Model Serving native web-search tool.
+ *
+ * Databricks exposes web search as a first-party tool that runs *inside* a
+ * model call: the model searches the web and folds the results into its
+ * answer. The tool spec is provider-specific (see the Databricks docs,
+ * `machine-learning/model-serving/web-search`):
+ *
+ * - OpenAI GPT models, via the Responses API (`/serving-endpoints/responses`):
+ *   `tools: [{ "type": "web_search" }]`
+ * - Google Gemini models, via Chat Completions
+ *   (`/serving-endpoints/chat/completions`): `tools: [{ "google_search": {} }]`
+ *
+ * (Anthropic exposes it over MCP, which needs a different call shape; only
+ * GPT + Gemini are wired here, matching what the platform supports today.)
+ *
+ * The provider family is detected from the endpoint id the same way
+ * `@dbx-tools/shared-model`'s `classifyByFamily` keys off name substrings
+ * (`gpt` / `gemini` / `claude`), so a resolved endpoint like
+ * `databricks-gpt-5` or `databricks-gemini-3-pro` maps to its API shape.
+ *
+ * @module
+ */
+import { ValidationError } from "@databricks/appkit";
+import { z } from "zod";
+/**
+ * Built-in provider -> tool-spec map. Operators can override or extend this
+ * per provider via the plugin's `webSearchTools` config (env
+ * `WEB_SEARCH_TOOLS`), which is merged over these defaults.
+ */
+export const WEB_SEARCH_PROVIDERS = {
+    openai: { api: "responses", tool: { type: "web_search" } },
+    gemini: { api: "chat", tool: { google_search: {} } },
+};
+/**
+ * Detect the web-search provider family for an endpoint id, or `null` when
+ * the model is not one of the web-search-capable families. Anthropic
+ * (`opus`/`sonnet`/`haiku`) is intentionally excluded - it needs an MCP call
+ * shape this module doesn't implement - so a Claude endpoint returns `null`
+ * and is treated as unsupported.
+ */
+export function detectWebSearchProvider(modelId) {
+    const n = modelId.toLowerCase();
+    // gpt-oss open-weights don't carry the hosted web-search tool; only the
+    // hosted GPT family (Responses API) does. Both contain "gpt", so exclude
+    // the open-weights explicitly.
+    if (n.includes("gpt") && !n.includes("gpt-oss"))
+        return "openai";
+    if (n.includes("gemini"))
+        return "gemini";
+    return null;
+}
+/** Whether `modelId` is a web-search-capable model. */
+export function supportsWebSearch(modelId) {
+    return detectWebSearchProvider(modelId) !== null;
+}
+/**
+ * Runtime shape of one entry in the operator override map. The map arrives as
+ * parsed JSON (config or `WEB_SEARCH_TOOLS`), so it is validated rather than
+ * asserted.
+ */
+const providerOverrideSchema = z.object({
+    api: z.enum(["responses", "chat"]).optional(),
+    tool: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Resolve the effective {@link WebSearchProviderSpec} for a provider: the
+ * built-in default, with any operator override (the `webSearchTools` map,
+ * keyed by provider) shallow-merged over it. An override may replace just the
+ * `tool` (the common case - a new tool type) or also the `api`. An override
+ * that is not one of those two fields is a deployment mistake that would
+ * otherwise be silently dropped, so it throws.
+ */
+export function webSearchToolSpec(provider, overrides) {
+    const base = WEB_SEARCH_PROVIDERS[provider];
+    const raw = overrides?.[provider];
+    if (raw === undefined)
+        return base;
+    const parsed = providerOverrideSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw ValidationError.invalidValue(`webSearchTools.${provider}`, raw, 'an object with an optional "api" ("responses" | "chat") and an optional "tool" object');
+    }
+    return {
+        api: parsed.data.api ?? base.api,
+        tool: parsed.data.tool ?? base.tool,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAA+D;IAC9F,MAAM,EAAE,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE;IAC1D,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,EAAE;CACrD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAe;IACrD,MAAM,CAAC,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAChC,wEAAwE;IACxE,yEAAyE;IACzE,+BAA+B;IAC/B,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO,QAAQ,CAAC;IACjE,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC1C,OAAO,IAAI,CAAC;AACd,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,iBAAiB,CAAC,OAAe;IAC/C,OAAO,uBAAuB,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;AACnD,CAAC;AAED;;;;GAIG;AACH,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC7C,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACnD,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,QAA2B,EAC3B,SAAmC;IAEnC,MAAM,IAAI,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC5C,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC,QAAQ,CAAC,CAAC;IAClC,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACnC,MAAM,MAAM,GAAG,sBAAsB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACrD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,eAAe,CAAC,YAAY,CAChC,kBAAkB,QAAQ,EAAE,EAC5B,GAAG,EACH,uFAAuF,CACxF,CAAC;IACJ,CAAC;IACD,OAAO;QACL,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG;QAChC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI;KACpC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Provider detection + web-search tool-spec mapping for the Databricks\n * Model Serving native web-search tool.\n *\n * Databricks exposes web search as a first-party tool that runs *inside* a\n * model call: the model searches the web and folds the results into its\n * answer. The tool spec is provider-specific (see the Databricks docs,\n * `machine-learning/model-serving/web-search`):\n *\n * - OpenAI GPT models, via the Responses API (`/serving-endpoints/responses`):\n *   `tools: [{ \"type\": \"web_search\" }]`\n * - Google Gemini models, via Chat Completions\n *   (`/serving-endpoints/chat/completions`): `tools: [{ \"google_search\": {} }]`\n *\n * (Anthropic exposes it over MCP, which needs a different call shape; only\n * GPT + Gemini are wired here, matching what the platform supports today.)\n *\n * The provider family is detected from the endpoint id the same way\n * `@dbx-tools/shared-model`'s `classifyByFamily` keys off name substrings\n * (`gpt` / `gemini` / `claude`), so a resolved endpoint like\n * `databricks-gpt-5` or `databricks-gemini-3-pro` maps to its API shape.\n *\n * @module\n */\n\nimport { ValidationError } from \"@databricks/appkit\";\nimport { z } from \"zod\";\n\n/** A web-search-capable model provider family. */\nexport type WebSearchProvider = \"openai\" | \"gemini\";\n\n/** How a provider's native web-search call is shaped. */\nexport interface WebSearchProviderSpec {\n  /**\n   * Which serving REST surface to call. `\"responses\"` posts to\n   * `/serving-endpoints/responses` (OpenAI Responses API); `\"chat\"` posts to\n   * `/serving-endpoints/chat/completions`.\n   */\n  api: \"responses\" | \"chat\";\n  /** The tool entry appended to the request's `tools` array. */\n  tool: Record<string, unknown>;\n}\n\n/**\n * Built-in provider -> tool-spec map. Operators can override or extend this\n * per provider via the plugin's `webSearchTools` config (env\n * `WEB_SEARCH_TOOLS`), which is merged over these defaults.\n */\nexport const WEB_SEARCH_PROVIDERS: Readonly<Record<WebSearchProvider, WebSearchProviderSpec>> = {\n  openai: { api: \"responses\", tool: { type: \"web_search\" } },\n  gemini: { api: \"chat\", tool: { google_search: {} } },\n};\n\n/**\n * Detect the web-search provider family for an endpoint id, or `null` when\n * the model is not one of the web-search-capable families. Anthropic\n * (`opus`/`sonnet`/`haiku`) is intentionally excluded - it needs an MCP call\n * shape this module doesn't implement - so a Claude endpoint returns `null`\n * and is treated as unsupported.\n */\nexport function detectWebSearchProvider(modelId: string): WebSearchProvider | null {\n  const n = modelId.toLowerCase();\n  // gpt-oss open-weights don't carry the hosted web-search tool; only the\n  // hosted GPT family (Responses API) does. Both contain \"gpt\", so exclude\n  // the open-weights explicitly.\n  if (n.includes(\"gpt\") && !n.includes(\"gpt-oss\")) return \"openai\";\n  if (n.includes(\"gemini\")) return \"gemini\";\n  return null;\n}\n\n/** Whether `modelId` is a web-search-capable model. */\nexport function supportsWebSearch(modelId: string): boolean {\n  return detectWebSearchProvider(modelId) !== null;\n}\n\n/**\n * Runtime shape of one entry in the operator override map. The map arrives as\n * parsed JSON (config or `WEB_SEARCH_TOOLS`), so it is validated rather than\n * asserted.\n */\nconst providerOverrideSchema = z.object({\n  api: z.enum([\"responses\", \"chat\"]).optional(),\n  tool: z.record(z.string(), z.unknown()).optional(),\n});\n\n/**\n * Resolve the effective {@link WebSearchProviderSpec} for a provider: the\n * built-in default, with any operator override (the `webSearchTools` map,\n * keyed by provider) shallow-merged over it. An override may replace just the\n * `tool` (the common case - a new tool type) or also the `api`. An override\n * that is not one of those two fields is a deployment mistake that would\n * otherwise be silently dropped, so it throws.\n */\nexport function webSearchToolSpec(\n  provider: WebSearchProvider,\n  overrides?: Record<string, unknown>,\n): WebSearchProviderSpec {\n  const base = WEB_SEARCH_PROVIDERS[provider];\n  const raw = overrides?.[provider];\n  if (raw === undefined) return base;\n  const parsed = providerOverrideSchema.safeParse(raw);\n  if (!parsed.success) {\n    throw ValidationError.invalidValue(\n      `webSearchTools.${provider}`,\n      raw,\n      'an object with an optional \"api\" (\"responses\" | \"chat\") and an optional \"tool\" object',\n    );\n  }\n  return {\n    api: parsed.data.api ?? base.api,\n    tool: parsed.data.tool ?? base.tool,\n  };\n}\n"]}

package/lib/src/runtime.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The web-search runtime: a lazily-resolved, process-wide config shared by
+ * the plugin and the `web_search` / `web_fetch` tools, so both read one
+ * resolved allow-list / cap / timeout set. The first caller (normally the
+ * plugin at setup) primes it from the plugin's config; later callers (the
+ * tools' `execute`) reuse it.
+ *
+ * The runtime also carries the {@link WebSearchExecutor} every outbound call
+ * runs through. The plugin installs its own `execute()` there at setup, which
+ * is how the tools - plain functions with no plugin instance in scope - still
+ * get AppKit's cache / retry / timeout / telemetry chain. Without a
+ * registered plugin (a direct call from a script or a test) the calls still
+ * run, just without interceptors.
+ *
+ * Unlike the email runtime there is no connection to pool - the backend is
+ * stateless HTTP per call - so the runtime holds only the resolved config and
+ * that executor.
+ *
+ * @module
+ */
+import { type ExecutionResult } from "@databricks/appkit";
+import { type ResolvedWebSearchConfig, type WebSearchPluginConfig } from "./config.js";
+import type { WebSearchExecutionSettings } from "./defaults.js";
+/**
+ * Runs one outbound call through AppKit's interceptor chain. Matches
+ * `Plugin.execute()`, which never throws: a failure comes back as
+ * `{ ok: false }`.
+ */
+export type WebSearchExecutor = <T>(fn: (signal?: AbortSignal) => Promise<T>, settings: WebSearchExecutionSettings) => Promise<ExecutionResult<T>>;
+/** The shared resolved config plus the executor outbound calls run through. */
+export interface WebSearchRuntime {
+    config: ResolvedWebSearchConfig;
+    execute: WebSearchExecutor;
+}
+/**
+ * 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 (the tools' `execute`) pass nothing and get the same
+ * instance.
+ */
+export declare function getWebSearchRuntime(overrides?: WebSearchPluginConfig): WebSearchRuntime;
+/**
+ * Install the executor outbound calls run through. The plugin calls this at
+ * setup with its own `execute()`; a second call replaces the previous one, so
+ * a re-registered plugin does not leave the tools bound to a dead instance.
+ */
+export declare function setWebSearchExecutor(execute: WebSearchExecutor): void;
+/** Drop the memoized runtime so the next {@link getWebSearchRuntime} rebuilds it. */
+export declare function resetWebSearchRuntime(): void;
+/**
+ * Run one idempotent read through the shared executor and unwrap it.
+ *
+ * `execute()` never throws, so a failed call arrives as `{ ok: false }` with
+ * a status the interceptors already sanitized; it is logged here and re-raised
+ * as a stable {@link ExecutionError} so an upstream message never becomes the
+ * caller's error text. `signal` is the caller's own cancellation (an agent
+ * run, a request teardown); it is merged with the signal the timeout
+ * interceptor supplies so either one unwinds the I/O.
+ */
+export declare function executeRead<T>(operation: string, settings: WebSearchExecutionSettings, fn: (signal?: AbortSignal) => Promise<T>, signal?: AbortSignal): Promise<T>;

package/lib/src/runtime.js

@@ -0,0 +1,95 @@
+/**
+ * The web-search runtime: a lazily-resolved, process-wide config shared by
+ * the plugin and the `web_search` / `web_fetch` tools, so both read one
+ * resolved allow-list / cap / timeout set. The first caller (normally the
+ * plugin at setup) primes it from the plugin's config; later callers (the
+ * tools' `execute`) reuse it.
+ *
+ * The runtime also carries the {@link WebSearchExecutor} every outbound call
+ * runs through. The plugin installs its own `execute()` there at setup, which
+ * is how the tools - plain functions with no plugin instance in scope - still
+ * get AppKit's cache / retry / timeout / telemetry chain. Without a
+ * registered plugin (a direct call from a script or a test) the calls still
+ * run, just without interceptors.
+ *
+ * Unlike the email runtime there is no connection to pool - the backend is
+ * stateless HTTP per call - so the runtime holds only the resolved config and
+ * that executor.
+ *
+ * @module
+ */
+import { AppKitError, ExecutionError } from "@databricks/appkit";
+import { async, error, log } from "@dbx-tools/shared-core";
+import { resolveWebSearchConfig, } from "./config.js";
+const logger = log.logger("web-search/runtime");
+/**
+ * Executor used until (or unless) the plugin installs its own: run the call
+ * directly, mapping a throw onto the same {@link ExecutionResult} shape so
+ * call sites branch on `ok` either way.
+ */
+const directExecute = async (fn) => {
+    try {
+        return { ok: true, data: await fn() };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: err instanceof AppKitError ? err.statusCode : 500,
+            message: error.errorMessage(err),
+        };
+    }
+};
+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 (the tools' `execute`) pass nothing and get the same
+ * instance.
+ */
+export function getWebSearchRuntime(overrides) {
+    if (!runtime) {
+        runtime = { config: resolveWebSearchConfig(overrides), execute: directExecute };
+    }
+    return runtime;
+}
+/**
+ * Install the executor outbound calls run through. The plugin calls this at
+ * setup with its own `execute()`; a second call replaces the previous one, so
+ * a re-registered plugin does not leave the tools bound to a dead instance.
+ */
+export function setWebSearchExecutor(execute) {
+    getWebSearchRuntime().execute = execute;
+}
+/** Drop the memoized runtime so the next {@link getWebSearchRuntime} rebuilds it. */
+export function resetWebSearchRuntime() {
+    runtime = undefined;
+}
+/**
+ * Run one idempotent read through the shared executor and unwrap it.
+ *
+ * `execute()` never throws, so a failed call arrives as `{ ok: false }` with
+ * a status the interceptors already sanitized; it is logged here and re-raised
+ * as a stable {@link ExecutionError} so an upstream message never becomes the
+ * caller's error text. `signal` is the caller's own cancellation (an agent
+ * run, a request teardown); it is merged with the signal the timeout
+ * interceptor supplies so either one unwinds the I/O.
+ */
+export async function executeRead(operation, settings, fn, signal) {
+    const { execute } = getWebSearchRuntime();
+    const result = await execute((executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)), settings);
+    if (result.ok)
+        return result.data;
+    // A caller that cancelled is not a failure worth reporting as one.
+    if (signal?.aborted)
+        throw ExecutionError.canceled();
+    logger.warn("execution-failed", {
+        operation,
+        status: result.status,
+        error: result.message,
+    });
+    throw new ExecutionError(`web-search: ${operation} failed`, {
+        context: { operation, status: result.status },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAwB,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,sBAAsB,GAGvB,MAAM,UAAU,CAAC;AAGlB,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAkBhD;;;;GAIG;AACH,MAAM,aAAa,GAAsB,KAAK,EAAE,EAAE,EAAE,EAAE;IACpD,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IACxC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,GAAG,YAAY,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG;YACzD,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC;SACjC,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF,IAAI,OAAqC,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,SAAiC;IACnE,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,EAAE,MAAM,EAAE,sBAAsB,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;IAClF,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAA0B;IAC7D,mBAAmB,EAAE,CAAC,OAAO,GAAG,OAAO,CAAC;AAC1C,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,qBAAqB;IACnC,OAAO,GAAG,SAAS,CAAC;AACtB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,SAAiB,EACjB,QAAoC,EACpC,EAAwC,EACxC,MAAoB;IAEpB,MAAM,EAAE,OAAO,EAAE,GAAG,mBAAmB,EAAE,CAAC;IAC1C,MAAM,MAAM,GAAG,MAAM,OAAO,CAC1B,CAAC,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,mBAAmB,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,EACvE,QAAQ,CACT,CAAC;IACF,IAAI,MAAM,CAAC,EAAE;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC;IAClC,mEAAmE;IACnE,IAAI,MAAM,EAAE,OAAO;QAAE,MAAM,cAAc,CAAC,QAAQ,EAAE,CAAC;IACrD,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE;QAC9B,SAAS;QACT,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,KAAK,EAAE,MAAM,CAAC,OAAO;KACtB,CAAC,CAAC;IACH,MAAM,IAAI,cAAc,CAAC,eAAe,SAAS,SAAS,EAAE;QAC1D,OAAO,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;KAC9C,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * The web-search runtime: a lazily-resolved, process-wide config shared by\n * the plugin and the `web_search` / `web_fetch` tools, so both read one\n * resolved allow-list / cap / timeout set. The first caller (normally the\n * plugin at setup) primes it from the plugin's config; later callers (the\n * tools' `execute`) reuse it.\n *\n * The runtime also carries the {@link WebSearchExecutor} every outbound call\n * runs through. The plugin installs its own `execute()` there at setup, which\n * is how the tools - plain functions with no plugin instance in scope - still\n * get AppKit's cache / retry / timeout / telemetry chain. Without a\n * registered plugin (a direct call from a script or a test) the calls still\n * run, just without interceptors.\n *\n * Unlike the email runtime there is no connection to pool - the backend is\n * stateless HTTP per call - so the runtime holds only the resolved config and\n * that executor.\n *\n * @module\n */\n\nimport { AppKitError, ExecutionError, type ExecutionResult } from \"@databricks/appkit\";\nimport { async, error, log } from \"@dbx-tools/shared-core\";\nimport {\n  resolveWebSearchConfig,\n  type ResolvedWebSearchConfig,\n  type WebSearchPluginConfig,\n} from \"./config\";\nimport type { WebSearchExecutionSettings } from \"./defaults\";\n\nconst logger = log.logger(\"web-search/runtime\");\n\n/**\n * Runs one outbound call through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type WebSearchExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: WebSearchExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared resolved config plus the executor outbound calls run through. */\nexport interface WebSearchRuntime {\n  config: ResolvedWebSearchConfig;\n  execute: WebSearchExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the call\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute: WebSearchExecutor = async (fn) => {\n  try {\n    return { ok: true, data: await fn() };\n  } catch (err) {\n    return {\n      ok: false,\n      status: err instanceof AppKitError ? err.statusCode : 500,\n      message: error.errorMessage(err),\n    };\n  }\n};\n\nlet runtime: WebSearchRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use from the supplied\n * config layered over environment defaults. Overrides are only read when the\n * runtime is first created, so prime it from the plugin's config at setup;\n * subsequent calls (the tools' `execute`) pass nothing and get the same\n * instance.\n */\nexport function getWebSearchRuntime(overrides?: WebSearchPluginConfig): WebSearchRuntime {\n  if (!runtime) {\n    runtime = { config: resolveWebSearchConfig(overrides), execute: directExecute };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor outbound calls run through. The plugin calls this at\n * setup with its own `execute()`; a second call replaces the previous one, so\n * a re-registered plugin does not leave the tools bound to a dead instance.\n */\nexport function setWebSearchExecutor(execute: WebSearchExecutor): void {\n  getWebSearchRuntime().execute = execute;\n}\n\n/** Drop the memoized runtime so the next {@link getWebSearchRuntime} rebuilds it. */\nexport function resetWebSearchRuntime(): void {\n  runtime = undefined;\n}\n\n/**\n * Run one idempotent read through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed call arrives as `{ ok: false }` with\n * a status the interceptors already sanitized; it is logged here and re-raised\n * as a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text. `signal` is the caller's own cancellation (an agent\n * run, a request teardown); it is merged with the signal the timeout\n * interceptor supplies so either one unwinds the I/O.\n */\nexport async function executeRead<T>(\n  operation: string,\n  settings: WebSearchExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getWebSearchRuntime();\n  const result = await execute(\n    (executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)),\n    settings,\n  );\n  if (result.ok) return result.data;\n  // A caller that cancelled is not a failure worth reporting as one.\n  if (signal?.aborted) throw ExecutionError.canceled();\n  logger.warn(\"execution-failed\", {\n    operation,\n    status: result.status,\n    error: result.message,\n  });\n  throw new ExecutionError(`web-search: ${operation} failed`, {\n    context: { operation, status: result.status },\n  });\n}\n"]}

package/lib/src/schema.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Wire-format contract for the web-search add-on: the two tool inputs a
+ * model fills in (`web_search`, `web_fetch`) and the results handed back.
+ * Pure zod + inferred types (no Node-only imports) so the tool layer, the
+ * plugin, and any future UI validate / type against one definition.
+ *
+ * `web_search` is backed by the Databricks Model Serving native web-search
+ * tool (see `provider.ts`): the model searches the web server-side and
+ * returns a synthesized answer plus the sources it used. `web_fetch` reads a
+ * single page's contents via got-scraping.
+ *
+ * Array fields intentionally avoid `.min()` / `.nonempty()`: those emit
+ * `minItems` in the JSON schema, which some Model Serving endpoints reject
+ * ("array types do not support minItems") when the schema is forwarded as a
+ * tool definition - the same constraint the email add-on documents.
+ *
+ * @module
+ */
+import { z } from "zod";
+/**
+ * Description the model reads for `web_search`. Shared by the Mastra tool and
+ * the AppKit tool provider so both hosts describe the tool identically.
+ */
+export declare const WEB_SEARCH_TOOL_DESCRIPTION: string;
+/** Description the model reads for `web_fetch`. Shared like {@link WEB_SEARCH_TOOL_DESCRIPTION}. */
+export declare const WEB_FETCH_TOOL_DESCRIPTION: string;
+/** Schema for the `web_search` tool input. */
+export declare const webSearchRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A validated `web_search` request. */
+export type WebSearchRequest = z.infer<typeof webSearchRequestSchema>;
+/** Schema for a single source the model cited while answering. */
+export declare const webSearchCitationSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    snippet: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A single cited source ({@link webSearchCitationSchema}). */
+export type WebSearchCitation = z.infer<typeof webSearchCitationSchema>;
+/** Schema for the `web_search` tool output. */
+export declare const webSearchResultSchema: z.ZodObject<{
+    query: z.ZodString;
+    answer: z.ZodString;
+    citations: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        snippet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    model: z.ZodString;
+}, z.core.$strip>;
+/** The outcome of a `web_search` call ({@link webSearchResultSchema}). */
+export type WebSearchResult = z.infer<typeof webSearchResultSchema>;
+/** Schema for the `web_fetch` tool input. */
+export declare const webFetchRequestSchema: z.ZodObject<{
+    url: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        html: "html";
+    }>>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** A validated `web_fetch` request. */
+export type WebFetchRequest = z.infer<typeof webFetchRequestSchema>;
+/** Schema for the `web_fetch` tool output. */
+export declare const webFetchResultSchema: z.ZodObject<{
+    url: z.ZodString;
+    status: z.ZodNumber;
+    contentType: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+/** The outcome of a `web_fetch` call ({@link webFetchResultSchema}). */
+export type WebFetchResult = z.infer<typeof webFetchResultSchema>;

package/lib/src/schema.js

@@ -0,0 +1,102 @@
+/**
+ * Wire-format contract for the web-search add-on: the two tool inputs a
+ * model fills in (`web_search`, `web_fetch`) and the results handed back.
+ * Pure zod + inferred types (no Node-only imports) so the tool layer, the
+ * plugin, and any future UI validate / type against one definition.
+ *
+ * `web_search` is backed by the Databricks Model Serving native web-search
+ * tool (see `provider.ts`): the model searches the web server-side and
+ * returns a synthesized answer plus the sources it used. `web_fetch` reads a
+ * single page's contents via got-scraping.
+ *
+ * Array fields intentionally avoid `.min()` / `.nonempty()`: those emit
+ * `minItems` in the JSON schema, which some Model Serving endpoints reject
+ * ("array types do not support minItems") when the schema is forwarded as a
+ * tool definition - the same constraint the email add-on documents.
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+import { z } from "zod";
+/**
+ * Description the model reads for `web_search`. Shared by the Mastra tool and
+ * the AppKit tool provider so both hosts describe the tool identically.
+ */
+export const WEB_SEARCH_TOOL_DESCRIPTION = string.toDescription(`
+  Search the web for current information and get an answer synthesized from
+  live results, with the sources it used. Pass a natural-language query;
+  the search runs inside a web-search-capable model (chosen independently
+  of your own model). Optionally pass a model name to use a specific
+  web-search model. Use it whenever a question needs up-to-date or external
+  information you don't already have.
+`);
+/** Description the model reads for `web_fetch`. Shared like {@link WEB_SEARCH_TOOL_DESCRIPTION}. */
+export const WEB_FETCH_TOOL_DESCRIPTION = string.toDescription(`
+  Fetch a single web page and return its readable contents. Pass an
+  absolute URL (including https://); set format to "html" for raw markup
+  instead of extracted text. Use it to read a page returned by web_search
+  or provided by the user. Content is length-capped; fetching a URL outside
+  the configured allow-list is refused.
+`);
+/** Schema for the `web_search` tool input. */
+export const webSearchRequestSchema = z.object({
+    query: z
+        .string()
+        .describe("What to search the web for, phrased as a natural-language question or request. The model searches and answers in one step."),
+    model: z
+        .string()
+        .optional()
+        .describe(string.toDescription(`
+        Optional web-search-capable model to use (a Databricks serving
+        endpoint name like "databricks-gemini-3-pro", a loose name like "gpt"
+        or "gemini", or a capability class). Defaults to the plugin's
+        configured web-search model. The web-search tool resolves its own
+        model independently of the calling agent's chat model, since not
+        every chat model supports web search.
+      `)),
+});
+/** Schema for a single source the model cited while answering. */
+export const webSearchCitationSchema = z.object({
+    url: z.string().describe("The source URL the answer drew on."),
+    title: z.string().optional().describe("The source page title, when available."),
+    snippet: z.string().optional().describe("A short excerpt from the source, when available."),
+});
+/** Schema for the `web_search` tool output. */
+export const webSearchResultSchema = z.object({
+    query: z.string().describe("Echo of the query that was searched."),
+    answer: z.string().describe("The model's answer, synthesized from live web results."),
+    citations: z
+        .array(webSearchCitationSchema)
+        .describe("Sources the answer drew on. When an allow-list is configured, citations whose URL is not permitted are silently omitted."),
+    model: z.string().describe("The serving endpoint that produced the answer."),
+});
+/** Schema for the `web_fetch` tool input. */
+export const webFetchRequestSchema = z.object({
+    url: z
+        .string()
+        .describe("The absolute URL to fetch (must include the scheme, e.g. https://). When an allow-list is configured, a URL it does not permit is refused."),
+    format: z
+        .enum(["text", "html"])
+        .optional()
+        .describe(string.toDescription(`
+        Return format: "text" (default) strips the page to readable plain
+        text; "html" returns the raw response body. Prefer "text" unless you
+        need the markup.
+      `)),
+    maxLength: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Truncate the returned content to at most this many characters (the plugin caps this at its configured limit)."),
+});
+/** Schema for the `web_fetch` tool output. */
+export const webFetchResultSchema = z.object({
+    url: z.string().describe("The final URL fetched (after redirects)."),
+    status: z.number().describe("HTTP status code of the response."),
+    contentType: z.string().optional().describe("Response `Content-Type`, when the server sent one."),
+    title: z.string().optional().describe("The page <title>, when one was present."),
+    content: z.string().describe("The page content in the requested format (text or html)."),
+    truncated: z.boolean().describe("True when `content` was cut off at the length cap."),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Wire-format contract for the web-search add-on: the two tool inputs a\n * model fills in (`web_search`, `web_fetch`) and the results handed back.\n * Pure zod + inferred types (no Node-only imports) so the tool layer, the\n * plugin, and any future UI validate / type against one definition.\n *\n * `web_search` is backed by the Databricks Model Serving native web-search\n * tool (see `provider.ts`): the model searches the web server-side and\n * returns a synthesized answer plus the sources it used. `web_fetch` reads a\n * single page's contents via got-scraping.\n *\n * Array fields intentionally avoid `.min()` / `.nonempty()`: those emit\n * `minItems` in the JSON schema, which some Model Serving endpoints reject\n * (\"array types do not support minItems\") when the schema is forwarded as a\n * tool definition - the same constraint the email add-on documents.\n *\n * @module\n */\n\nimport { string } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\n\n/**\n * Description the model reads for `web_search`. Shared by the Mastra tool and\n * the AppKit tool provider so both hosts describe the tool identically.\n */\nexport const WEB_SEARCH_TOOL_DESCRIPTION = string.toDescription(`\n  Search the web for current information and get an answer synthesized from\n  live results, with the sources it used. Pass a natural-language query;\n  the search runs inside a web-search-capable model (chosen independently\n  of your own model). Optionally pass a model name to use a specific\n  web-search model. Use it whenever a question needs up-to-date or external\n  information you don't already have.\n`);\n\n/** Description the model reads for `web_fetch`. Shared like {@link WEB_SEARCH_TOOL_DESCRIPTION}. */\nexport const WEB_FETCH_TOOL_DESCRIPTION = string.toDescription(`\n  Fetch a single web page and return its readable contents. Pass an\n  absolute URL (including https://); set format to \"html\" for raw markup\n  instead of extracted text. Use it to read a page returned by web_search\n  or provided by the user. Content is length-capped; fetching a URL outside\n  the configured allow-list is refused.\n`);\n\n/** Schema for the `web_search` tool input. */\nexport const webSearchRequestSchema = z.object({\n  query: z\n    .string()\n    .describe(\n      \"What to search the web for, phrased as a natural-language question or request. The model searches and answers in one step.\",\n    ),\n  model: z\n    .string()\n    .optional()\n    .describe(\n      string.toDescription(`\n        Optional web-search-capable model to use (a Databricks serving\n        endpoint name like \"databricks-gemini-3-pro\", a loose name like \"gpt\"\n        or \"gemini\", or a capability class). Defaults to the plugin's\n        configured web-search model. The web-search tool resolves its own\n        model independently of the calling agent's chat model, since not\n        every chat model supports web search.\n      `),\n    ),\n});\n\n/** A validated `web_search` request. */\nexport type WebSearchRequest = z.infer<typeof webSearchRequestSchema>;\n\n/** Schema for a single source the model cited while answering. */\nexport const webSearchCitationSchema = z.object({\n  url: z.string().describe(\"The source URL the answer drew on.\"),\n  title: z.string().optional().describe(\"The source page title, when available.\"),\n  snippet: z.string().optional().describe(\"A short excerpt from the source, when available.\"),\n});\n\n/** A single cited source ({@link webSearchCitationSchema}). */\nexport type WebSearchCitation = z.infer<typeof webSearchCitationSchema>;\n\n/** Schema for the `web_search` tool output. */\nexport const webSearchResultSchema = z.object({\n  query: z.string().describe(\"Echo of the query that was searched.\"),\n  answer: z.string().describe(\"The model's answer, synthesized from live web results.\"),\n  citations: z\n    .array(webSearchCitationSchema)\n    .describe(\n      \"Sources the answer drew on. When an allow-list is configured, citations whose URL is not permitted are silently omitted.\",\n    ),\n  model: z.string().describe(\"The serving endpoint that produced the answer.\"),\n});\n\n/** The outcome of a `web_search` call ({@link webSearchResultSchema}). */\nexport type WebSearchResult = z.infer<typeof webSearchResultSchema>;\n\n/** Schema for the `web_fetch` tool input. */\nexport const webFetchRequestSchema = z.object({\n  url: z\n    .string()\n    .describe(\n      \"The absolute URL to fetch (must include the scheme, e.g. https://). When an allow-list is configured, a URL it does not permit is refused.\",\n    ),\n  format: z\n    .enum([\"text\", \"html\"])\n    .optional()\n    .describe(\n      string.toDescription(`\n        Return format: \"text\" (default) strips the page to readable plain\n        text; \"html\" returns the raw response body. Prefer \"text\" unless you\n        need the markup.\n      `),\n    ),\n  maxLength: z\n    .number()\n    .int()\n    .positive()\n    .optional()\n    .describe(\n      \"Truncate the returned content to at most this many characters (the plugin caps this at its configured limit).\",\n    ),\n});\n\n/** A validated `web_fetch` request. */\nexport type WebFetchRequest = z.infer<typeof webFetchRequestSchema>;\n\n/** Schema for the `web_fetch` tool output. */\nexport const webFetchResultSchema = z.object({\n  url: z.string().describe(\"The final URL fetched (after redirects).\"),\n  status: z.number().describe(\"HTTP status code of the response.\"),\n  contentType: z.string().optional().describe(\"Response `Content-Type`, when the server sent one.\"),\n  title: z.string().optional().describe(\"The page <title>, when one was present.\"),\n  content: z.string().describe(\"The page content in the requested format (text or html).\"),\n  truncated: z.boolean().describe(\"True when `content` was cut off at the length cap.\"),\n});\n\n/** The outcome of a `web_fetch` call ({@link webFetchResultSchema}). */\nexport type WebFetchResult = z.infer<typeof webFetchResultSchema>;\n"]}

package/lib/src/scrape.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Last-resort scraping fallback for `web_search`, used ONLY when the
+ * workspace has no Databricks web-search-capable model deployed (no GPT /
+ * Gemini serving endpoint). The native Databricks web-search tool is always
+ * preferred (see `search.ts`); this exists so the tool still returns useful
+ * results in an environment that can't run it, rather than erroring on every
+ * call.
+ *
+ * It queries DuckDuckGo's no-JS HTML endpoint through `got-scraping`
+ * (browser-like fingerprints so the request isn't blocked) via a GET with the
+ * query in the query string - a POST to the same endpoint trips DDG's bot
+ * challenge (HTTP 202), while the GET returns normal result markup. It then
+ * parses the result anchors + snippets. Unlike the native tool there is no
+ * model synthesizing an answer, so `answer` is a short lead-in over the top
+ * snippets and the substance rides in `citations` - the calling agent reads
+ * those and writes its own answer.
+ *
+ * @module
+ */
+import type { ResolvedWebSearchConfig } from "./config.js";
+import type { WebSearchRequest, WebSearchResult } from "./schema.js";
+/**
+ * Run a scraping search over DuckDuckGo. Returns the same
+ * {@link WebSearchResult} shape as the native path, with `model` set to
+ * `"scrape:duckduckgo"` so callers can tell how the result was produced.
+ * Citations are filtered through the configured URL allow-list. `signal`
+ * cancels the in-flight request.
+ */
+export declare function runScrapeSearch(request: WebSearchRequest, config: ResolvedWebSearchConfig, signal?: AbortSignal): Promise<WebSearchResult>;