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

package/lib/src/scrape.js

@@ -0,0 +1,113 @@
+/**
+ * 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 { log } from "@dbx-tools/shared-core";
+import { gotScraping } from "got-scraping";
+import { scrapeSearchExecuteDefaults, toCallSettings } from "./defaults.js";
+import { htmlFragmentToText } from "./html-text.js";
+import { executeRead } from "./runtime.js";
+const logger = log.logger("web-search/scrape");
+/** DuckDuckGo's no-JS HTML results endpoint (queried via GET). */
+const DDG_HTML_URL = "https://html.duckduckgo.com/html/";
+/**
+ * DDG wraps result URLs in a redirect (`//duckduckgo.com/l/?uddg=<encoded>`).
+ * Unwrap to the real destination; leave already-absolute URLs untouched.
+ */
+function unwrapDdgUrl(href) {
+    try {
+        const u = new URL(href, "https://duckduckgo.com");
+        const target = u.searchParams.get("uddg");
+        if (target)
+            return decodeURIComponent(target);
+        return u.protocol === "http:" || u.protocol === "https:" ? u.toString() : href;
+    }
+    catch {
+        return href;
+    }
+}
+/** Parse DDG HTML result blocks into citations (title, url, snippet). */
+function parseDdgHtml(html) {
+    const citations = [];
+    // Each result: an anchor with class result__a (title + href) and a snippet
+    // with class result__snippet. Match anchors, then the following snippet.
+    const anchorRe = /<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
+    const snippetRe = /<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/g;
+    const snippets = [];
+    let sm;
+    while ((sm = snippetRe.exec(html)) !== null)
+        snippets.push(htmlFragmentToText(sm[1] ?? ""));
+    let am;
+    let i = 0;
+    while ((am = anchorRe.exec(html)) !== null) {
+        const url = unwrapDdgUrl(am[1] ?? "");
+        const title = htmlFragmentToText(am[2] ?? "");
+        if (!url || !title)
+            continue;
+        const snippet = snippets[i] ?? "";
+        citations.push({ url, title, ...(snippet ? { snippet } : {}) });
+        i += 1;
+    }
+    return citations;
+}
+/**
+ * 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 async function runScrapeSearch(request, config, signal) {
+    const page = await executeRead("scrape-search", toCallSettings(scrapeSearchExecuteDefaults, config.timeoutMs, [
+        "web-search",
+        "scrape",
+        request.query,
+    ]), async (executeSignal) => {
+        const response = await gotScraping({
+            url: `${DDG_HTML_URL}?q=${encodeURIComponent(request.query)}`,
+            method: "GET",
+            // got's own timeout aborts the socket and reports which phase timed
+            // out; the interceptor timeout bounds the whole attempt around it.
+            timeout: { request: config.timeoutMs },
+            throwHttpErrors: false,
+            followRedirect: true,
+            ...(executeSignal ? { signal: executeSignal } : {}),
+        });
+        return {
+            body: typeof response.body === "string" ? response.body : String(response.body ?? ""),
+            statusCode: response.statusCode,
+        };
+    }, signal);
+    const all = parseDdgHtml(page.body);
+    const permitted = all.filter((c) => config.allowList.allows(c.url));
+    const citations = permitted.slice(0, config.maxCitations);
+    const answer = citations.length > 0
+        ? `Web results for "${request.query}" (no Databricks web-search model is deployed in this workspace, so these are unsynthesized search results - read the citations):\n\n` +
+            citations
+                .map((c, n) => `${n + 1}. ${c.title}${c.snippet ? ` - ${c.snippet}` : ""} (${c.url})`)
+                .join("\n")
+        : `No web results found for "${request.query}".`;
+    logger.debug("scraped", {
+        query: request.query,
+        found: all.length,
+        returned: citations.length,
+        status: page.statusCode,
+    });
+    return { query: request.query, answer, citations, model: "scrape:duckduckgo" };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scrape.js","sourceRoot":"","sources":["../../src/scrape.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Last-resort scraping fallback for `web_search`, used ONLY when the\n * workspace has no Databricks web-search-capable model deployed (no GPT /\n * Gemini serving endpoint). The native Databricks web-search tool is always\n * preferred (see `search.ts`); this exists so the tool still returns useful\n * results in an environment that can't run it, rather than erroring on every\n * call.\n *\n * It queries DuckDuckGo's no-JS HTML endpoint through `got-scraping`\n * (browser-like fingerprints so the request isn't blocked) via a GET with the\n * query in the query string - a POST to the same endpoint trips DDG's bot\n * challenge (HTTP 202), while the GET returns normal result markup. It then\n * parses the result anchors + snippets. Unlike the native tool there is no\n * model synthesizing an answer, so `answer` is a short lead-in over the top\n * snippets and the substance rides in `citations` - the calling agent reads\n * those and writes its own answer.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport { gotScraping } from \"got-scraping\";\nimport type { ResolvedWebSearchConfig } from \"./config\";\nimport { scrapeSearchExecuteDefaults, toCallSettings } from \"./defaults\";\nimport { htmlFragmentToText } from \"./html-text\";\nimport { executeRead } from \"./runtime\";\nimport type { WebSearchCitation, WebSearchRequest, WebSearchResult } from \"./schema\";\n\nconst logger = log.logger(\"web-search/scrape\");\n\n/** DuckDuckGo's no-JS HTML results endpoint (queried via GET). */\nconst DDG_HTML_URL = \"https://html.duckduckgo.com/html/\";\n\n/**\n * DDG wraps result URLs in a redirect (`//duckduckgo.com/l/?uddg=<encoded>`).\n * Unwrap to the real destination; leave already-absolute URLs untouched.\n */\nfunction unwrapDdgUrl(href: string): string {\n  try {\n    const u = new URL(href, \"https://duckduckgo.com\");\n    const target = u.searchParams.get(\"uddg\");\n    if (target) return decodeURIComponent(target);\n    return u.protocol === \"http:\" || u.protocol === \"https:\" ? u.toString() : href;\n  } catch {\n    return href;\n  }\n}\n\n/** Parse DDG HTML result blocks into citations (title, url, snippet). */\nfunction parseDdgHtml(html: string): WebSearchCitation[] {\n  const citations: WebSearchCitation[] = [];\n  // Each result: an anchor with class result__a (title + href) and a snippet\n  // with class result__snippet. Match anchors, then the following snippet.\n  const anchorRe = /<a[^>]*class=\"[^\"]*result__a[^\"]*\"[^>]*href=\"([^\"]+)\"[^>]*>([\\s\\S]*?)<\\/a>/g;\n  const snippetRe = /<a[^>]*class=\"[^\"]*result__snippet[^\"]*\"[^>]*>([\\s\\S]*?)<\\/a>/g;\n  const snippets: string[] = [];\n  let sm: RegExpExecArray | null;\n  while ((sm = snippetRe.exec(html)) !== null) snippets.push(htmlFragmentToText(sm[1] ?? \"\"));\n  let am: RegExpExecArray | null;\n  let i = 0;\n  while ((am = anchorRe.exec(html)) !== null) {\n    const url = unwrapDdgUrl(am[1] ?? \"\");\n    const title = htmlFragmentToText(am[2] ?? \"\");\n    if (!url || !title) continue;\n    const snippet = snippets[i] ?? \"\";\n    citations.push({ url, title, ...(snippet ? { snippet } : {}) });\n    i += 1;\n  }\n  return citations;\n}\n\n/**\n * Run a scraping search over DuckDuckGo. Returns the same\n * {@link WebSearchResult} shape as the native path, with `model` set to\n * `\"scrape:duckduckgo\"` so callers can tell how the result was produced.\n * Citations are filtered through the configured URL allow-list. `signal`\n * cancels the in-flight request.\n */\nexport async function runScrapeSearch(\n  request: WebSearchRequest,\n  config: ResolvedWebSearchConfig,\n  signal?: AbortSignal,\n): Promise<WebSearchResult> {\n  const page = await executeRead(\n    \"scrape-search\",\n    toCallSettings(scrapeSearchExecuteDefaults, config.timeoutMs, [\n      \"web-search\",\n      \"scrape\",\n      request.query,\n    ]),\n    async (executeSignal): Promise<{ body: string; statusCode: number }> => {\n      const response = await gotScraping({\n        url: `${DDG_HTML_URL}?q=${encodeURIComponent(request.query)}`,\n        method: \"GET\",\n        // got's own timeout aborts the socket and reports which phase timed\n        // out; the interceptor timeout bounds the whole attempt around it.\n        timeout: { request: config.timeoutMs },\n        throwHttpErrors: false,\n        followRedirect: true,\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      return {\n        body: typeof response.body === \"string\" ? response.body : String(response.body ?? \"\"),\n        statusCode: response.statusCode,\n      };\n    },\n    signal,\n  );\n  const all = parseDdgHtml(page.body);\n  const permitted = all.filter((c) => config.allowList.allows(c.url));\n  const citations = permitted.slice(0, config.maxCitations);\n  const answer =\n    citations.length > 0\n      ? `Web results for \"${request.query}\" (no Databricks web-search model is deployed in this workspace, so these are unsynthesized search results - read the citations):\\n\\n` +\n        citations\n          .map((c, n) => `${n + 1}. ${c.title}${c.snippet ? ` - ${c.snippet}` : \"\"} (${c.url})`)\n          .join(\"\\n\")\n      : `No web results found for \"${request.query}\".`;\n  logger.debug(\"scraped\", {\n    query: request.query,\n    found: all.length,\n    returned: citations.length,\n    status: page.statusCode,\n  });\n  return { query: request.query, answer, citations, model: \"scrape:duckduckgo\" };\n}\n"]}

package/lib/src/search.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Web search backed by the Databricks Model Serving native web-search tool.
+ *
+ * Unlike a scraping client, the search runs *inside* a model call: we POST the
+ * query to the workspace's serving endpoint with the provider's web-search
+ * tool spec attached, and the model searches the web and writes the answer.
+ * {@link runWebSearch}:
+ *
+ *   1. Resolves a web-search-capable model INDEPENDENTLY of the calling
+ *      agent's chat model (the agent may run on a model without web search).
+ *      A pinned `model` (request or config) is fuzzy-matched; otherwise the
+ *      configured fallback order (Gemini, then GPT) is walked to the first
+ *      web-search-capable endpoint that exists. An explicit but unsupported
+ *      model is a hard error, not a silent fallback.
+ *   2. POSTs to the provider's REST surface (`/serving-endpoints/responses`
+ *      for OpenAI, `/serving-endpoints/chat/completions` for Gemini) with the
+ *      mapped tool spec, authenticated as the OBO caller.
+ *   3. Returns the synthesized answer plus the cited sources, with citations
+ *      silently filtered through the configured URL allow-list.
+ *
+ * @module
+ */
+import { serving } from "@dbx-tools/model";
+import { type ResolvedWebSearchConfig } from "./config.js";
+import type { WebSearchRequest, WebSearchResult } from "./schema.js";
+type WorkspaceClientLike = serving.WorkspaceClientLike;
+/** Context a search needs from the caller: the OBO client + workspace host. */
+export interface WebSearchContext {
+    client: WorkspaceClientLike;
+    host: string;
+}
+/**
+ * Resolve the OBO workspace client + host from the active AppKit execution
+ * context. Inside `agent.stream`'s `asUser(req)` scope this hits the serving
+ * endpoint as the requesting user; outside a user context AppKit falls back to
+ * the service principal.
+ */
+export declare function resolveWebSearchContext(): Promise<WebSearchContext>;
+/**
+ * Run a web search. Prefers the Databricks native web-search tool on a
+ * deployed GPT/Gemini endpoint (synthesized answer + citations); when the
+ * workspace has no such endpoint AND the scrape fallback is enabled, falls
+ * back to a DuckDuckGo scrape so the tool still returns results instead of
+ * erroring. Citations are filtered through the configured URL allow-list.
+ *
+ * `signal` cancels the whole call, including the in-flight serving request.
+ */
+export declare function runWebSearch(request: WebSearchRequest, config: ResolvedWebSearchConfig, ctx: WebSearchContext, signal?: AbortSignal): Promise<WebSearchResult>;
+export {};

package/lib/src/search.js

@@ -0,0 +1,252 @@
+/**
+ * Web search backed by the Databricks Model Serving native web-search tool.
+ *
+ * Unlike a scraping client, the search runs *inside* a model call: we POST the
+ * query to the workspace's serving endpoint with the provider's web-search
+ * tool spec attached, and the model searches the web and writes the answer.
+ * {@link runWebSearch}:
+ *
+ *   1. Resolves a web-search-capable model INDEPENDENTLY of the calling
+ *      agent's chat model (the agent may run on a model without web search).
+ *      A pinned `model` (request or config) is fuzzy-matched; otherwise the
+ *      configured fallback order (Gemini, then GPT) is walked to the first
+ *      web-search-capable endpoint that exists. An explicit but unsupported
+ *      model is a hard error, not a silent fallback.
+ *   2. POSTs to the provider's REST surface (`/serving-endpoints/responses`
+ *      for OpenAI, `/serving-endpoints/chat/completions` for Gemini) with the
+ *      mapped tool spec, authenticated as the OBO caller.
+ *   3. Returns the synthesized answer plus the cited sources, with citations
+ *      silently filtered through the configured URL allow-list.
+ *
+ * @module
+ */
+import { ConfigurationError, ConnectionError, ExecutionError, getExecutionContext, ValidationError, } from "@databricks/appkit";
+import { invoke, resolve, serving } from "@dbx-tools/model";
+import { log, object, string } from "@dbx-tools/shared-core";
+import { openaiChat, openaiResponses } from "@dbx-tools/shared-model";
+import { MODEL_ENV, SERVING_ENDPOINT_ENV } from "./config.js";
+import { toCallSettings, webSearchExecuteDefaults } from "./defaults.js";
+import { detectWebSearchProvider, supportsWebSearch, webSearchToolSpec } from "./provider.js";
+import { executeRead } from "./runtime.js";
+import { runScrapeSearch } from "./scrape.js";
+const logger = log.logger("web-search/search");
+const { resolveModel } = resolve;
+const { listServingEndpoints } = serving;
+/**
+ * How deep the grounding-metadata walk descends. Gemini nests its sources a
+ * handful of levels down and the shape varies by model version, so the walk
+ * is generic; the bound is what keeps a pathological payload from turning it
+ * into a full traversal of the response.
+ */
+const MAX_GROUNDING_WALK_DEPTH = 6;
+/** Lowest HTTP status treated as a server-side (retryable) serving failure. */
+const SERVER_ERROR_STATUS = 500;
+/** Status Model Serving uses to shed load; retryable like a 5xx. */
+const RATE_LIMITED_STATUS = 429;
+/**
+ * Resolve the OBO workspace client + host from the active AppKit execution
+ * context. Inside `agent.stream`'s `asUser(req)` scope this hits the serving
+ * endpoint as the requesting user; outside a user context AppKit falls back to
+ * the service principal.
+ */
+export async function resolveWebSearchContext() {
+    const ctx = getExecutionContext();
+    const host = (await ctx.client.config.getHost()).toString();
+    return { client: ctx.client, host };
+}
+/**
+ * Resolve a web-search-capable model against the LIVE workspace catalogue - so
+ * we never return an endpoint id that isn't actually deployed (the "endpoint
+ * does not exist" failure a hardcoded fallback id would cause). Reuses
+ * `@dbx-tools/model`'s existing catalogue + resolver rather than a custom
+ * lookup: {@link listServingEndpoints} lists the endpoints (cached), and we
+ * restrict the candidate set to the {@link supportsWebSearch} ones before
+ * {@link resolveModel} fuzzy-picks within it.
+ *
+ * Returns the chosen endpoint id, or `null` when the workspace has no
+ * web-search-capable model deployed (the caller then uses the scrape
+ * fallback). A pin the caller chose deliberately - the request's `model`, the
+ * plugin's `model`, or `WEB_SEARCH_MODEL` - throws when it resolves to an
+ * unsupported / absent endpoint, so a bad pin surfaces rather than silently
+ * degrading. A pin inherited from the shared `DATABRICKS_SERVING_ENDPOINT_NAME`
+ * binding is only a preference: that endpoint is the app's serving endpoint,
+ * not necessarily a web-search-capable one, so an unusable value falls through
+ * to the fallback order.
+ */
+async function resolveWebSearchModel(ctx, config, requested) {
+    const endpoints = await listServingEndpoints(ctx.client, ctx.host);
+    // Only deployed, web-search-capable endpoints are candidates.
+    const capable = endpoints.filter((e) => supportsWebSearch(e.name));
+    const pinned = requested ?? config.model;
+    const pinIsDeliberate = requested !== undefined || config.modelSource === "config" || config.modelSource === MODEL_ENV;
+    if (pinned) {
+        // Resolve the explicit ask within the capable set only.
+        const { modelId } = resolveModel(capable, {
+            explicit: pinned,
+            fuzzy: config.fuzzy,
+            threshold: config.fuzzyThreshold,
+        });
+        // resolveModel returns the input verbatim on no match; require it to be a
+        // real capable endpoint so a bad pin is a clear error, not a phantom call.
+        const usable = capable.some((e) => e.name === modelId) && supportsWebSearch(modelId);
+        if (usable)
+            return modelId;
+        const deployed = capable.map((e) => e.name).join(", ") || "none";
+        if (!pinIsDeliberate) {
+            logger.info("shared-endpoint-not-web-capable", {
+                envVar: SERVING_ENDPOINT_ENV,
+                deployed,
+            });
+        }
+        else if (requested !== undefined) {
+            throw ValidationError.invalidValue("model", pinned, `a deployed web-search-capable endpoint (deployed: ${deployed})`);
+        }
+        else {
+            throw ConfigurationError.resourceNotFound("Web-search-capable serving endpoint", `Deployed web-search-capable endpoints: ${deployed}. Set model or ${MODEL_ENV} to one of them.`);
+        }
+    }
+    if (capable.length === 0)
+        return null;
+    // Nothing usable pinned: prefer the configured fallback order (Gemini, then
+    // GPT) when those ids are actually deployed; else take the best capable
+    // endpoint.
+    const { modelId } = resolveModel(capable, {
+        fallbacks: config.modelFallbacks,
+        fuzzy: config.fuzzy,
+        threshold: config.fuzzyThreshold,
+    });
+    return capable.some((e) => e.name === modelId) ? modelId : (capable[0]?.name ?? null);
+}
+/**
+ * POST a serving request as the OBO caller and return the parsed JSON body.
+ *
+ * Auth headers are minted per call from the OBO client's SDK config, which
+ * refreshes the token when it is close to expiry, so the request carries the
+ * requesting user's identity.
+ *
+ * This is the one Databricks call in the repo that does not go through
+ * `apiClient.request` + `databricks.toContext` (which does forward
+ * cancellation). Retry classification here has to distinguish a load-shed or
+ * server fault from this request's own 4xx, and `fetch` exposes the HTTP status
+ * directly; the SDK raises an `ApiError` that carries the status under
+ * inconsistent keys, which is guesswork by comparison.
+ */
+async function postServing(ctx, url, body, config, cacheKey, signal) {
+    const payload = await executeRead("serving-request", toCallSettings(webSearchExecuteDefaults, config.timeoutMs, cacheKey), async (executeSignal) => {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                ...(await invoke.authHeaders(ctx.client)),
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+            ...(executeSignal ? { signal: executeSignal } : {}),
+        });
+        if (!response.ok) {
+            // Load-shedding and server faults are worth another attempt; a 4xx is
+            // this request's own problem, so it must not be retried.
+            const retryable = response.status >= SERVER_ERROR_STATUS || response.status === RATE_LIMITED_STATUS;
+            const message = `web-search: Model Serving rejected the search request (HTTP ${response.status})`;
+            throw retryable
+                ? new ConnectionError(message, { context: { status: response.status } })
+                : new ExecutionError(message, { context: { status: response.status } });
+        }
+        return response.json();
+    }, signal);
+    return object.isRecord(payload) ? payload : {};
+}
+/* --------------------------- response extraction --------------------------- */
+/**
+ * Extract answer text + citations from an OpenAI Responses API payload, via the
+ * shared reader in `@dbx-tools/shared-model` (the same module the model-proxy
+ * uses to translate the Responses wire format in the other direction).
+ */
+function fromResponsesPayload(payload) {
+    const { text, citations } = openaiResponses.readResponsesOutput(payload);
+    return { answer: text, citations };
+}
+/**
+ * Extract answer text + citations from a Chat Completions payload (Gemini via
+ * `google_search`). The answer is `choices[0].message.content`; grounding
+ * sources, when present, surface under `choices[0].message` grounding
+ * metadata (best-effort - shapes vary, so we scan for url-bearing entries).
+ */
+function fromChatPayload(payload) {
+    const choices = Array.isArray(payload.choices) ? payload.choices : [];
+    const first = choices[0];
+    const message = object.isRecord(first) && object.isRecord(first.message) ? first.message : {};
+    const answer = openaiChat.chatContentToText(message.content);
+    const citations = [];
+    // Best-effort grounding extraction: walk any nested object for {uri|url,title}.
+    const seen = new Set();
+    const visit = (v, depth) => {
+        if (depth > MAX_GROUNDING_WALK_DEPTH || !object.isRecord(v))
+            return;
+        const url = string.trimToEmpty(v.url) || string.trimToEmpty(v.uri);
+        if (url && !seen.has(url)) {
+            seen.add(url);
+            const title = string.trimToEmpty(v.title);
+            citations.push({ url, ...(title ? { title } : {}) });
+        }
+        for (const val of Object.values(v)) {
+            if (Array.isArray(val))
+                val.forEach((x) => visit(x, depth + 1));
+            else if (val && typeof val === "object")
+                visit(val, depth + 1);
+        }
+    };
+    visit(message.grounding_metadata ?? message.groundingMetadata, 0);
+    return { answer, citations };
+}
+/**
+ * Run a web search. Prefers the Databricks native web-search tool on a
+ * deployed GPT/Gemini endpoint (synthesized answer + citations); when the
+ * workspace has no such endpoint AND the scrape fallback is enabled, falls
+ * back to a DuckDuckGo scrape so the tool still returns results instead of
+ * erroring. Citations are filtered through the configured URL allow-list.
+ *
+ * `signal` cancels the whole call, including the in-flight serving request.
+ */
+export async function runWebSearch(request, config, ctx, signal) {
+    const modelId = await resolveWebSearchModel(ctx, config, request.model);
+    if (modelId === null) {
+        // No native web-search model deployed in this workspace.
+        if (config.scrapeFallback) {
+            logger.info("no-native-model:scrape-fallback", { query: request.query });
+            return runScrapeSearch(request, config, signal);
+        }
+        throw ConfigurationError.resourceNotFound("Web-search-capable serving endpoint", "No GPT/Gemini endpoint is deployed in this workspace and the scrape fallback is " +
+            `disabled. Deploy a supported endpoint, set model or ${MODEL_ENV}, or enable the ` +
+            "fallback (WEB_SEARCH_SCRAPE_FALLBACK=1).");
+    }
+    const provider = detectWebSearchProvider(modelId); // guaranteed by resolve step
+    const spec = webSearchToolSpec(provider, config.webSearchTools);
+    const url = spec.api === "responses" ? invoke.responsesUrl(ctx.host) : invoke.chatCompletionsUrl(ctx.host);
+    const body = spec.api === "responses"
+        ? {
+            model: modelId,
+            input: [{ role: "user", content: request.query }],
+            tools: [spec.tool],
+        }
+        : {
+            model: modelId,
+            messages: [{ role: "user", content: request.query }],
+            tools: [spec.tool],
+        };
+    const payload = await postServing(ctx, url, body, config, ["web-search", "serving", spec.api, modelId, request.query], signal);
+    const { answer, citations } = spec.api === "responses" ? fromResponsesPayload(payload) : fromChatPayload(payload);
+    const permitted = citations.filter((c) => config.allowList.allows(c.url));
+    const dropped = citations.length - permitted.length;
+    const trimmed = permitted.slice(0, config.maxCitations);
+    logger.debug("searched", {
+        query: request.query,
+        model: modelId,
+        provider,
+        citations: citations.length,
+        ...(dropped > 0 ? { filtered: dropped } : {}),
+        returned: trimmed.length,
+    });
+    return { query: request.query, answer, citations: trimmed, model: modelId };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.js","sourceRoot":"","sources":["../../src/search.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Web search backed by the Databricks Model Serving native web-search tool.\n *\n * Unlike a scraping client, the search runs *inside* a model call: we POST the\n * query to the workspace's serving endpoint with the provider's web-search\n * tool spec attached, and the model searches the web and writes the answer.\n * {@link runWebSearch}:\n *\n *   1. Resolves a web-search-capable model INDEPENDENTLY of the calling\n *      agent's chat model (the agent may run on a model without web search).\n *      A pinned `model` (request or config) is fuzzy-matched; otherwise the\n *      configured fallback order (Gemini, then GPT) is walked to the first\n *      web-search-capable endpoint that exists. An explicit but unsupported\n *      model is a hard error, not a silent fallback.\n *   2. POSTs to the provider's REST surface (`/serving-endpoints/responses`\n *      for OpenAI, `/serving-endpoints/chat/completions` for Gemini) with the\n *      mapped tool spec, authenticated as the OBO caller.\n *   3. Returns the synthesized answer plus the cited sources, with citations\n *      silently filtered through the configured URL allow-list.\n *\n * @module\n */\n\nimport {\n  ConfigurationError,\n  ConnectionError,\n  ExecutionError,\n  getExecutionContext,\n  ValidationError,\n} from \"@databricks/appkit\";\nimport { invoke, resolve, serving } from \"@dbx-tools/model\";\nimport { log, object, string } from \"@dbx-tools/shared-core\";\nimport { openaiChat, openaiResponses } from \"@dbx-tools/shared-model\";\nimport { MODEL_ENV, SERVING_ENDPOINT_ENV, type ResolvedWebSearchConfig } from \"./config\";\nimport { toCallSettings, webSearchExecuteDefaults } from \"./defaults\";\nimport { detectWebSearchProvider, supportsWebSearch, webSearchToolSpec } from \"./provider\";\nimport { executeRead } from \"./runtime\";\nimport type { WebSearchCitation, WebSearchRequest, WebSearchResult } from \"./schema\";\nimport { runScrapeSearch } from \"./scrape\";\n\ntype WorkspaceClientLike = serving.WorkspaceClientLike;\nconst logger = log.logger(\"web-search/search\");\nconst { resolveModel } = resolve;\nconst { listServingEndpoints } = serving;\n\n/**\n * How deep the grounding-metadata walk descends. Gemini nests its sources a\n * handful of levels down and the shape varies by model version, so the walk\n * is generic; the bound is what keeps a pathological payload from turning it\n * into a full traversal of the response.\n */\nconst MAX_GROUNDING_WALK_DEPTH = 6;\n\n/** Lowest HTTP status treated as a server-side (retryable) serving failure. */\nconst SERVER_ERROR_STATUS = 500;\n\n/** Status Model Serving uses to shed load; retryable like a 5xx. */\nconst RATE_LIMITED_STATUS = 429;\n\n/** Context a search needs from the caller: the OBO client + workspace host. */\nexport interface WebSearchContext {\n  client: WorkspaceClientLike;\n  host: string;\n}\n\n/**\n * Resolve the OBO workspace client + host from the active AppKit execution\n * context. Inside `agent.stream`'s `asUser(req)` scope this hits the serving\n * endpoint as the requesting user; outside a user context AppKit falls back to\n * the service principal.\n */\nexport async function resolveWebSearchContext(): Promise<WebSearchContext> {\n  const ctx = getExecutionContext();\n  const host = (await ctx.client.config.getHost()).toString();\n  return { client: ctx.client, host };\n}\n\n/**\n * Resolve a web-search-capable model against the LIVE workspace catalogue - so\n * we never return an endpoint id that isn't actually deployed (the \"endpoint\n * does not exist\" failure a hardcoded fallback id would cause). Reuses\n * `@dbx-tools/model`'s existing catalogue + resolver rather than a custom\n * lookup: {@link listServingEndpoints} lists the endpoints (cached), and we\n * restrict the candidate set to the {@link supportsWebSearch} ones before\n * {@link resolveModel} fuzzy-picks within it.\n *\n * Returns the chosen endpoint id, or `null` when the workspace has no\n * web-search-capable model deployed (the caller then uses the scrape\n * fallback). A pin the caller chose deliberately - the request's `model`, the\n * plugin's `model`, or `WEB_SEARCH_MODEL` - throws when it resolves to an\n * unsupported / absent endpoint, so a bad pin surfaces rather than silently\n * degrading. A pin inherited from the shared `DATABRICKS_SERVING_ENDPOINT_NAME`\n * binding is only a preference: that endpoint is the app's serving endpoint,\n * not necessarily a web-search-capable one, so an unusable value falls through\n * to the fallback order.\n */\nasync function resolveWebSearchModel(\n  ctx: WebSearchContext,\n  config: ResolvedWebSearchConfig,\n  requested: string | undefined,\n): Promise<string | null> {\n  const endpoints = await listServingEndpoints(ctx.client, ctx.host);\n  // Only deployed, web-search-capable endpoints are candidates.\n  const capable = endpoints.filter((e) => supportsWebSearch(e.name));\n  const pinned = requested ?? config.model;\n  const pinIsDeliberate =\n    requested !== undefined || config.modelSource === \"config\" || config.modelSource === MODEL_ENV;\n\n  if (pinned) {\n    // Resolve the explicit ask within the capable set only.\n    const { modelId } = resolveModel(capable, {\n      explicit: pinned,\n      fuzzy: config.fuzzy,\n      threshold: config.fuzzyThreshold,\n    });\n    // resolveModel returns the input verbatim on no match; require it to be a\n    // real capable endpoint so a bad pin is a clear error, not a phantom call.\n    const usable = capable.some((e) => e.name === modelId) && supportsWebSearch(modelId);\n    if (usable) return modelId;\n    const deployed = capable.map((e) => e.name).join(\", \") || \"none\";\n    if (!pinIsDeliberate) {\n      logger.info(\"shared-endpoint-not-web-capable\", {\n        envVar: SERVING_ENDPOINT_ENV,\n        deployed,\n      });\n    } else if (requested !== undefined) {\n      throw ValidationError.invalidValue(\n        \"model\",\n        pinned,\n        `a deployed web-search-capable endpoint (deployed: ${deployed})`,\n      );\n    } else {\n      throw ConfigurationError.resourceNotFound(\n        \"Web-search-capable serving endpoint\",\n        `Deployed web-search-capable endpoints: ${deployed}. Set model or ${MODEL_ENV} to one of them.`,\n      );\n    }\n  }\n\n  if (capable.length === 0) return null;\n\n  // Nothing usable pinned: prefer the configured fallback order (Gemini, then\n  // GPT) when those ids are actually deployed; else take the best capable\n  // endpoint.\n  const { modelId } = resolveModel(capable, {\n    fallbacks: config.modelFallbacks,\n    fuzzy: config.fuzzy,\n    threshold: config.fuzzyThreshold,\n  });\n  return capable.some((e) => e.name === modelId) ? modelId : (capable[0]?.name ?? null);\n}\n\n/**\n * POST a serving request as the OBO caller and return the parsed JSON body.\n *\n * Auth headers are minted per call from the OBO client's SDK config, which\n * refreshes the token when it is close to expiry, so the request carries the\n * requesting user's identity.\n *\n * This is the one Databricks call in the repo that does not go through\n * `apiClient.request` + `databricks.toContext` (which does forward\n * cancellation). Retry classification here has to distinguish a load-shed or\n * server fault from this request's own 4xx, and `fetch` exposes the HTTP status\n * directly; the SDK raises an `ApiError` that carries the status under\n * inconsistent keys, which is guesswork by comparison.\n */\nasync function postServing(\n  ctx: WebSearchContext,\n  url: string,\n  body: unknown,\n  config: ResolvedWebSearchConfig,\n  cacheKey: readonly (string | number)[],\n  signal?: AbortSignal,\n): Promise<Record<string, unknown>> {\n  const payload = await executeRead(\n    \"serving-request\",\n    toCallSettings(webSearchExecuteDefaults, config.timeoutMs, cacheKey),\n    async (executeSignal): Promise<unknown> => {\n      const response = await fetch(url, {\n        method: \"POST\",\n        headers: {\n          ...(await invoke.authHeaders(ctx.client)),\n          Accept: \"application/json\",\n          \"Content-Type\": \"application/json\",\n        },\n        body: JSON.stringify(body),\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      if (!response.ok) {\n        // Load-shedding and server faults are worth another attempt; a 4xx is\n        // this request's own problem, so it must not be retried.\n        const retryable =\n          response.status >= SERVER_ERROR_STATUS || response.status === RATE_LIMITED_STATUS;\n        const message = `web-search: Model Serving rejected the search request (HTTP ${response.status})`;\n        throw retryable\n          ? new ConnectionError(message, { context: { status: response.status } })\n          : new ExecutionError(message, { context: { status: response.status } });\n      }\n      return response.json();\n    },\n    signal,\n  );\n  return object.isRecord(payload) ? payload : {};\n}\n\n/* --------------------------- response extraction --------------------------- */\n\n/**\n * Extract answer text + citations from an OpenAI Responses API payload, via the\n * shared reader in `@dbx-tools/shared-model` (the same module the model-proxy\n * uses to translate the Responses wire format in the other direction).\n */\nfunction fromResponsesPayload(payload: Record<string, unknown>): {\n  answer: string;\n  citations: WebSearchCitation[];\n} {\n  const { text, citations } = openaiResponses.readResponsesOutput(payload);\n  return { answer: text, citations };\n}\n\n/**\n * Extract answer text + citations from a Chat Completions payload (Gemini via\n * `google_search`). The answer is `choices[0].message.content`; grounding\n * sources, when present, surface under `choices[0].message` grounding\n * metadata (best-effort - shapes vary, so we scan for url-bearing entries).\n */\nfunction fromChatPayload(payload: Record<string, unknown>): {\n  answer: string;\n  citations: WebSearchCitation[];\n} {\n  const choices = Array.isArray(payload.choices) ? payload.choices : [];\n  const first = choices[0];\n  const message = object.isRecord(first) && object.isRecord(first.message) ? first.message : {};\n  const answer = openaiChat.chatContentToText(message.content);\n  const citations: WebSearchCitation[] = [];\n  // Best-effort grounding extraction: walk any nested object for {uri|url,title}.\n  const seen = new Set<string>();\n  const visit = (v: unknown, depth: number): void => {\n    if (depth > MAX_GROUNDING_WALK_DEPTH || !object.isRecord(v)) return;\n    const url = string.trimToEmpty(v.url) || string.trimToEmpty(v.uri);\n    if (url && !seen.has(url)) {\n      seen.add(url);\n      const title = string.trimToEmpty(v.title);\n      citations.push({ url, ...(title ? { title } : {}) });\n    }\n    for (const val of Object.values(v)) {\n      if (Array.isArray(val)) val.forEach((x) => visit(x, depth + 1));\n      else if (val && typeof val === \"object\") visit(val, depth + 1);\n    }\n  };\n  visit(message.grounding_metadata ?? message.groundingMetadata, 0);\n  return { answer, citations };\n}\n\n/**\n * Run a web search. Prefers the Databricks native web-search tool on a\n * deployed GPT/Gemini endpoint (synthesized answer + citations); when the\n * workspace has no such endpoint AND the scrape fallback is enabled, falls\n * back to a DuckDuckGo scrape so the tool still returns results instead of\n * erroring. Citations are filtered through the configured URL allow-list.\n *\n * `signal` cancels the whole call, including the in-flight serving request.\n */\nexport async function runWebSearch(\n  request: WebSearchRequest,\n  config: ResolvedWebSearchConfig,\n  ctx: WebSearchContext,\n  signal?: AbortSignal,\n): Promise<WebSearchResult> {\n  const modelId = await resolveWebSearchModel(ctx, config, request.model);\n\n  if (modelId === null) {\n    // No native web-search model deployed in this workspace.\n    if (config.scrapeFallback) {\n      logger.info(\"no-native-model:scrape-fallback\", { query: request.query });\n      return runScrapeSearch(request, config, signal);\n    }\n    throw ConfigurationError.resourceNotFound(\n      \"Web-search-capable serving endpoint\",\n      \"No GPT/Gemini endpoint is deployed in this workspace and the scrape fallback is \" +\n        `disabled. Deploy a supported endpoint, set model or ${MODEL_ENV}, or enable the ` +\n        \"fallback (WEB_SEARCH_SCRAPE_FALLBACK=1).\",\n    );\n  }\n\n  const provider = detectWebSearchProvider(modelId)!; // guaranteed by resolve step\n  const spec = webSearchToolSpec(provider, config.webSearchTools);\n\n  const url =\n    spec.api === \"responses\" ? invoke.responsesUrl(ctx.host) : invoke.chatCompletionsUrl(ctx.host);\n  const body =\n    spec.api === \"responses\"\n      ? {\n          model: modelId,\n          input: [{ role: \"user\", content: request.query }],\n          tools: [spec.tool],\n        }\n      : {\n          model: modelId,\n          messages: [{ role: \"user\", content: request.query }],\n          tools: [spec.tool],\n        };\n\n  const payload = await postServing(\n    ctx,\n    url,\n    body,\n    config,\n    [\"web-search\", \"serving\", spec.api, modelId, request.query],\n    signal,\n  );\n\n  const { answer, citations } =\n    spec.api === \"responses\" ? fromResponsesPayload(payload) : fromChatPayload(payload);\n\n  const permitted = citations.filter((c) => config.allowList.allows(c.url));\n  const dropped = citations.length - permitted.length;\n  const trimmed = permitted.slice(0, config.maxCitations);\n  logger.debug(\"searched\", {\n    query: request.query,\n    model: modelId,\n    provider,\n    citations: citations.length,\n    ...(dropped > 0 ? { filtered: dropped } : {}),\n    returned: trimmed.length,\n  });\n\n  return { query: request.query, answer, citations: trimmed, model: modelId };\n}\n"]}

package/lib/src/tool.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The `web_search` and `web_fetch` Mastra tools.
+ *
+ * `web_search` is backed by the Databricks Model Serving native web-search
+ * tool: it resolves its own web-search-capable model (see `search.ts`) and
+ * calls the workspace serving endpoint under the caller's OBO scope, so the
+ * search runs as the requesting user and independently of the agent's chat
+ * model. `web_fetch` reads a page via got-scraping.
+ *
+ * Both are read-only and run without approval by default; each accepts an
+ * optional {@link ApprovalGate} (`approval`) that maps onto Mastra's
+ * `requireApproval`. `true` gates every call; a URL-pattern (or {@link OneOrMany}
+ * list) gates only calls whose URL matches - for `web_fetch` that is evaluated
+ * against the target URL, while `web_search` (whose result URLs aren't known
+ * before the call) treats a pattern gate as "always gate". `approval` falls
+ * back to the plugin's `approval` config when a tool omits its own.
+ *
+ * The same two tools are exposed to AppKit's own agents through the plugin's
+ * `ToolProvider` (see `plugin.ts`); this module is the Mastra half.
+ *
+ * @module
+ */
+import { type ApprovalGate, type ApprovalPolicy } from "./config.js";
+/** Options shared by both web tools. */
+export interface WebSearchToolOptions {
+    /** Override the tool id. */
+    id?: string;
+    /**
+     * Approval gate for this tool, overriding the plugin's `approval`. `true`
+     * gates every call; a URL-pattern (or list) gates only matching calls;
+     * omit / `false` for no approval. See {@link ApprovalGate}.
+     */
+    approval?: ApprovalGate | ApprovalPolicy;
+}
+/**
+ * Build the `web_search` tool. Spread it into the agents that should be able
+ * to search the web.
+ *
+ * @example
+ * ```ts
+ * import { webSearchTool } from "@dbx-tools/appkit-web-search";
+ * import { createAgent } from "@dbx-tools/appkit-mastra";
+ *
+ * const researcher = createAgent({
+ *   instructions: "...",
+ *   tools: () => ({ web_search: webSearchTool() }),
+ * });
+ * ```
+ */
+export declare function webSearchTool(opts?: WebSearchToolOptions): import("@mastra/core/tools").Tool<{
+    query: string;
+    model?: string | undefined;
+}, {
+    query: string;
+    answer: string;
+    citations: {
+        url: string;
+        title?: string | undefined;
+        snippet?: string | undefined;
+    }[];
+    model: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;
+/**
+ * Build the `web_fetch` tool. Spread it into the agents that should be able
+ * to read a page's contents.
+ *
+ * @example
+ * ```ts
+ * import { webFetchTool } from "@dbx-tools/appkit-web-search";
+ *
+ * tools: () => ({ web_fetch: webFetchTool({ approval: "*.internal.example.com" }) })
+ * ```
+ */
+export declare function webFetchTool(opts?: WebSearchToolOptions): import("@mastra/core/tools").Tool<{
+    url: string;
+    format?: "text" | "html" | undefined;
+    maxLength?: number | undefined;
+}, {
+    url: string;
+    status: number;
+    content: string;
+    truncated: boolean;
+    contentType?: string | undefined;
+    title?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;