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

package/lib/src/fetch.js

@@ -0,0 +1,86 @@
+/**
+ * Page fetching over {@link https://www.npmjs.com/package/got-scraping | got-scraping}
+ * - a `got` wrapper that generates browser-like TLS + header fingerprints, so
+ * fetches survive the bot walls a plain `fetch` trips. {@link runWebFetch}
+ * enforces the URL allow-list (an explicit fetch of a disallowed URL is
+ * refused, not silently emptied), fetches with the plugin's timeout, and
+ * returns either the raw HTML or a readable plain-text reduction, capped at
+ * the configured length.
+ *
+ * The HTML-to-text reduction is deliberately dependency-free (strip
+ * script/style, unwrap tags, decode a handful of entities, collapse
+ * whitespace): good enough to feed a model, and it keeps the add-on's
+ * dependency surface to the two libraries the task called for.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+import { gotScraping } from "got-scraping";
+import { assertUrlAllowed } from "./allowlist.js";
+import { toCallSettings, webFetchExecuteDefaults } from "./defaults.js";
+import { decodeHtmlEntities, htmlToText } from "./html-text.js";
+import { executeRead } from "./runtime.js";
+const logger = log.logger("web-search/fetch");
+/** Pull the <title> text out of an HTML document, when present. */
+function extractTitle(html) {
+    const match = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    const title = match?.[1] ? decodeHtmlEntities(match[1]).trim() : "";
+    return title.length > 0 ? title : undefined;
+}
+/** Truncate `text` to `max` chars, reporting whether it was cut. */
+function truncate(text, max) {
+    if (text.length <= max)
+        return { content: text, truncated: false };
+    return { content: text.slice(0, max), truncated: true };
+}
+/**
+ * Fetch a single URL and return its content in the requested format.
+ *
+ * Throws when the URL is not permitted by the allow-list (the visible,
+ * correctable failure the design calls for on the fetch path). The request's
+ * `maxLength` narrows (never widens) the plugin's `fetchMaxLength` cap.
+ * `signal` cancels the in-flight fetch.
+ */
+export async function runWebFetch(request, config, signal) {
+    assertUrlAllowed(request.url, config.allowList);
+    const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);
+    // The response is cached before the format reduction, so the same page read
+    // as text and as html shares one network round trip.
+    const page = await executeRead("page-fetch", toCallSettings(webFetchExecuteDefaults, config.timeoutMs, ["web-search", "fetch", request.url]), async (executeSignal) => {
+        const response = await gotScraping({
+            url: request.url,
+            // 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 {
+            url: response.url ?? request.url,
+            statusCode: response.statusCode,
+            contentType: response.headers["content-type"],
+            body: typeof response.body === "string" ? response.body : String(response.body ?? ""),
+        };
+    }, signal);
+    const isHtml = !page.contentType || /html|xml/i.test(page.contentType);
+    const rawContent = request.format === "html" || !isHtml ? page.body : htmlToText(page.body);
+    const { content, truncated } = truncate(rawContent, cap);
+    const title = isHtml ? extractTitle(page.body) : undefined;
+    logger.debug("fetched", {
+        url: page.url,
+        status: page.statusCode,
+        bytes: page.body.length,
+        returned: content.length,
+        ...(truncated ? { truncated: true } : {}),
+    });
+    return {
+        url: page.url,
+        status: page.statusCode,
+        ...(page.contentType ? { contentType: page.contentType } : {}),
+        ...(title ? { title } : {}),
+        content,
+        truncated,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch.js","sourceRoot":"","sources":["../../src/fetch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Page fetching over {@link https://www.npmjs.com/package/got-scraping | got-scraping}\n * - a `got` wrapper that generates browser-like TLS + header fingerprints, so\n * fetches survive the bot walls a plain `fetch` trips. {@link runWebFetch}\n * enforces the URL allow-list (an explicit fetch of a disallowed URL is\n * refused, not silently emptied), fetches with the plugin's timeout, and\n * returns either the raw HTML or a readable plain-text reduction, capped at\n * the configured length.\n *\n * The HTML-to-text reduction is deliberately dependency-free (strip\n * script/style, unwrap tags, decode a handful of entities, collapse\n * whitespace): good enough to feed a model, and it keeps the add-on's\n * dependency surface to the two libraries the task called for.\n *\n * @module\n */\n\nimport { log } from \"@dbx-tools/shared-core\";\nimport { gotScraping } from \"got-scraping\";\nimport { assertUrlAllowed } from \"./allowlist\";\nimport type { ResolvedWebSearchConfig } from \"./config\";\nimport { toCallSettings, webFetchExecuteDefaults } from \"./defaults\";\nimport { decodeHtmlEntities, htmlToText } from \"./html-text\";\nimport { executeRead } from \"./runtime\";\nimport type { WebFetchRequest, WebFetchResult } from \"./schema\";\n\nconst logger = log.logger(\"web-search/fetch\");\n\n/** The slice of a got-scraping response this module reads. */\ninterface FetchedPage {\n  url: string;\n  statusCode: number;\n  contentType: string | undefined;\n  body: string;\n}\n\n/** Pull the <title> text out of an HTML document, when present. */\nfunction extractTitle(html: string): string | undefined {\n  const match = /<title[^>]*>([\\s\\S]*?)<\\/title>/i.exec(html);\n  const title = match?.[1] ? decodeHtmlEntities(match[1]).trim() : \"\";\n  return title.length > 0 ? title : undefined;\n}\n\n/** Truncate `text` to `max` chars, reporting whether it was cut. */\nfunction truncate(text: string, max: number): { content: string; truncated: boolean } {\n  if (text.length <= max) return { content: text, truncated: false };\n  return { content: text.slice(0, max), truncated: true };\n}\n\n/**\n * Fetch a single URL and return its content in the requested format.\n *\n * Throws when the URL is not permitted by the allow-list (the visible,\n * correctable failure the design calls for on the fetch path). The request's\n * `maxLength` narrows (never widens) the plugin's `fetchMaxLength` cap.\n * `signal` cancels the in-flight fetch.\n */\nexport async function runWebFetch(\n  request: WebFetchRequest,\n  config: ResolvedWebSearchConfig,\n  signal?: AbortSignal,\n): Promise<WebFetchResult> {\n  assertUrlAllowed(request.url, config.allowList);\n  const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);\n\n  // The response is cached before the format reduction, so the same page read\n  // as text and as html shares one network round trip.\n  const page = await executeRead(\n    \"page-fetch\",\n    toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [\"web-search\", \"fetch\", request.url]),\n    async (executeSignal): Promise<FetchedPage> => {\n      const response = await gotScraping({\n        url: request.url,\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        url: response.url ?? request.url,\n        statusCode: response.statusCode,\n        contentType: response.headers[\"content-type\"],\n        body: typeof response.body === \"string\" ? response.body : String(response.body ?? \"\"),\n      };\n    },\n    signal,\n  );\n\n  const isHtml = !page.contentType || /html|xml/i.test(page.contentType);\n  const rawContent = request.format === \"html\" || !isHtml ? page.body : htmlToText(page.body);\n  const { content, truncated } = truncate(rawContent, cap);\n  const title = isHtml ? extractTitle(page.body) : undefined;\n\n  logger.debug(\"fetched\", {\n    url: page.url,\n    status: page.statusCode,\n    bytes: page.body.length,\n    returned: content.length,\n    ...(truncated ? { truncated: true } : {}),\n  });\n\n  return {\n    url: page.url,\n    status: page.statusCode,\n    ...(page.contentType ? { contentType: page.contentType } : {}),\n    ...(title ? { title } : {}),\n    content,\n    truncated,\n  };\n}\n"]}

package/lib/src/html-text.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Turning fetched HTML into the plain text a model can read.
+ *
+ * Both scraping paths need this: `runWebFetch`'s full-page read and
+ * `runScrapeSearch`'s title/snippet extraction. The entity table is shared so
+ * the two cannot drift apart.
+ *
+ * This is deliberately regex-based rather than a DOM parse. The inputs are
+ * whole pages fetched for summarization, not documents to be queried, so the
+ * cost of a real parser buys nothing - and a malformed page still degrades to
+ * readable text instead of throwing.
+ *
+ * @module
+ */
+/** Decode the HTML entities that survive tag-stripping. */
+export declare function decodeHtmlEntities(text: string): string;
+/**
+ * Strip tags and decode entities from a short HTML fragment, collapsing all
+ * whitespace to single spaces. For inline snippets (a search result title or
+ * summary), where layout carries no meaning.
+ */
+export declare function htmlFragmentToText(html: string): string;
+/**
+ * Reduce a full HTML document to readable plain text: drop `<script>` /
+ * `<style>` / `<noscript>` blocks and comments, turn block-level tags into
+ * newlines, strip the remaining tags, decode entities, and collapse runs of
+ * blank lines / trailing spaces. Unlike {@link htmlFragmentToText}, this
+ * preserves line structure because paragraph breaks carry meaning in a page.
+ */
+export declare function htmlToText(html: string): string;

package/lib/src/html-text.js

@@ -0,0 +1,66 @@
+/**
+ * Turning fetched HTML into the plain text a model can read.
+ *
+ * Both scraping paths need this: `runWebFetch`'s full-page read and
+ * `runScrapeSearch`'s title/snippet extraction. The entity table is shared so
+ * the two cannot drift apart.
+ *
+ * This is deliberately regex-based rather than a DOM parse. The inputs are
+ * whole pages fetched for summarization, not documents to be queried, so the
+ * cost of a real parser buys nothing - and a malformed page still degrades to
+ * readable text instead of throwing.
+ *
+ * @module
+ */
+/**
+ * The named entities that survive tag-stripping in practice, plus numeric
+ * escapes. Not a complete HTML entity table - anything rarer passes through
+ * as-is, which reads acceptably in model input.
+ */
+const NAMED_ENTITIES = {
+    " ": " ",
+    "&": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&#x27;": "'",
+    "&apos;": "'",
+};
+const NAMED_ENTITY_REGEXP = new RegExp(Object.keys(NAMED_ENTITIES).join("|"), "g");
+const NUMERIC_ENTITY_REGEXP = /&#(\d+);/g;
+const TAG_REGEXP = /<[^>]+>/g;
+/** Decode the HTML entities that survive tag-stripping. */
+export function decodeHtmlEntities(text) {
+    return text
+        .replace(NAMED_ENTITY_REGEXP, (entity) => NAMED_ENTITIES[entity] ?? entity)
+        .replace(NUMERIC_ENTITY_REGEXP, (_, code) => String.fromCodePoint(Number(code)));
+}
+/**
+ * Strip tags and decode entities from a short HTML fragment, collapsing all
+ * whitespace to single spaces. For inline snippets (a search result title or
+ * summary), where layout carries no meaning.
+ */
+export function htmlFragmentToText(html) {
+    return decodeHtmlEntities(html.replace(TAG_REGEXP, "")).replace(/\s+/g, " ").trim();
+}
+/**
+ * Reduce a full HTML document to readable plain text: drop `<script>` /
+ * `<style>` / `<noscript>` blocks and comments, turn block-level tags into
+ * newlines, strip the remaining tags, decode entities, and collapse runs of
+ * blank lines / trailing spaces. Unlike {@link htmlFragmentToText}, this
+ * preserves line structure because paragraph breaks carry meaning in a page.
+ */
+export function htmlToText(html) {
+    return decodeHtmlEntities(html
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/<(script|style|noscript)[^>]*>[\s\S]*?<\/\1>/gi, "")
+        .replace(/<\/(p|div|section|article|li|tr|h[1-6]|header|footer|br)>/gi, "\n")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(TAG_REGEXP, ""))
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/[ \t]{2,}/g, " ")
+        .trim();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/plugin.d.ts

@@ -0,0 +1,162 @@
+/**
+ * AppKit plugin (registered name: `web-search`) that owns the resolved
+ * web-search runtime - the URL policy, result / length caps, timeout, and
+ * default approval gate the {@link webSearchTool} / {@link webFetchTool}
+ * read. Registering it resolves and logs the effective config (which URL
+ * policy is in force, the caps) so a misconfiguration is visible in the boot
+ * logs rather than on the first search, and installs the plugin's
+ * `execute()` as the runtime's executor so every outbound call picks up
+ * AppKit's cache / retry / timeout / telemetry chain.
+ *
+ * The plugin also implements AppKit's `ToolProvider`, so an AppKit agent gets
+ * `web_search` / `web_fetch` without going through Mastra; the Mastra tools in
+ * `tool.ts` are the other half and share the same runtime.
+ *
+ * @module
+ */
+import { Plugin, ResourceType, type ResourceRequirement } from "@databricks/appkit";
+import { type AgentToolDefinition, type ToolProvider } from "@databricks/appkit/beta";
+import { type WebSearchPluginConfig } from "./config.js";
+import type { WebFetchRequest, WebFetchResult, WebSearchRequest, WebSearchResult } from "./schema.js";
+/**
+ * AppKit plugin that resolves and holds the web-search runtime config used
+ * by the `web_search` / `web_fetch` tools.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as webSearchPlugin } from "@dbx-tools/appkit-web-search";
+ *
+ * await createApp({
+ *   plugins: [
+ *     server(),
+ *     webSearchPlugin.webSearch({
+ *       model: "gemini",
+ *       urlPolicy: "allowlist",
+ *       allowedUrls: ["*.databricks.com"],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare class WebSearchPlugin extends Plugin<WebSearchPluginConfig> implements ToolProvider {
+    static manifest: {
+        name: "web-search";
+        displayName: string;
+        description: string;
+        stability: "beta";
+        resources: {
+            required: never[];
+            optional: {
+                type: ResourceType.SERVING_ENDPOINT;
+                alias: string;
+                resourceKey: string;
+                description: string;
+                permission: "CAN_QUERY";
+                fields: {
+                    name: {
+                        env: string;
+                        description: string;
+                        discovery: {
+                            type: "cli";
+                            cliCommand: string;
+                            selectField: string;
+                        };
+                    };
+                };
+            }[];
+        };
+        config: {
+            schema: import("json-schema").JSONSchema7;
+        };
+    };
+    /**
+     * Promote the serving endpoint to a required resource once a deployment
+     * pins one, through plugin config or either environment name. Left optional
+     * otherwise, because the plugin picks a web-search-capable endpoint out of
+     * the live catalogue on its own.
+     */
+    static getResourceRequirements(config: WebSearchPluginConfig): ResourceRequirement[];
+    /**
+     * The tools this plugin offers to an AppKit agent. Both are reads and both
+     * run under the caller's identity.
+     *
+     * Neither is `autoInheritable`. `web_fetch` reaches a URL the model chose,
+     * which is reachable from inside the workspace network, so it must only
+     * appear in an agent that asked for it and accepted the URL policy that
+     * comes with it. `web_search` is safer but still spends serving tokens on
+     * every call, so it is opt-in for cost rather than for safety.
+     *
+     * `execute` re-parses its arguments with the local schema: AppKit validates
+     * against the same schema first, but re-parsing is what gives the body typed
+     * arguments instead of `unknown`.
+     */
+    private readonly tools;
+    /**
+     * Prime the shared runtime from this plugin's config (over env), route the
+     * tools' outbound calls through this plugin's interceptor chain, and log the
+     * effective policy so an active allow-list / caps are obvious at boot.
+     */
+    setup(): Promise<void>;
+    /**
+     * Drop the shared runtime so a restarted app re-resolves config and does not
+     * keep calling through a torn-down plugin's `execute()`. Bounded and
+     * idempotent: there is no connection to drain, only the memo to clear.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Abort in-flight work. AppKit's graceful shutdown only invokes this hook -
+     * it never calls {@link shutdown} - so the runtime memo is dropped from here
+     * to keep a restarted app from calling through a torn-down `execute()`. The
+     * teardown is synchronous and idempotent, so the un-awaited call costs
+     * nothing.
+     */
+    abortActiveOperations(): void;
+    /** AppKit `ToolProvider`: the tool definitions offered to an agent. */
+    getAgentTools(): AgentToolDefinition[];
+    /**
+     * AppKit `ToolProvider`: run one tool call. Arguments are validated against
+     * the tool's schema first, and a validation failure comes back as an
+     * LLM-friendly string so the model can correct itself on the next turn.
+     */
+    executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown>;
+    exports(): {
+        /**
+         * Run a web search directly (bypassing the agent tool). Resolves the
+         * OBO client from the active execution context and reads the shared
+         * runtime config primed at setup.
+         */
+        search: (request: WebSearchRequest, signal?: AbortSignal) => Promise<WebSearchResult>;
+        /**
+         * Fetch one URL directly (bypassing the agent tool). Enforces the
+         * configured URL policy. Reads the shared runtime config.
+         */
+        fetch: (request: WebFetchRequest, signal?: AbortSignal) => Promise<WebFetchResult>;
+    };
+    private search;
+    private fetch;
+}
+/**
+ * Register the web-search runtime with AppKit.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as webSearchPlugin, tool as webTool } from "@dbx-tools/appkit-web-search";
+ * import { agents, plugin as mastraPlugin } from "@dbx-tools/appkit-mastra";
+ *
+ * const researcher = agents.createAgent({
+ *   instructions: "Research questions with web_search, then read sources with web_fetch.",
+ *   tools: () => ({ web_search: webTool.webSearchTool(), web_fetch: webTool.webFetchTool() }),
+ * });
+ *
+ * await createApp({
+ *   plugins: [
+ *     server(),
+ *     webSearchPlugin.webSearch({ model: "gemini" }),
+ *     mastraPlugin.mastra({ agents: researcher }),
+ *   ],
+ * });
+ * ```
+ */
+export declare const webSearch: import("@databricks/appkit").ToPlugin<typeof WebSearchPlugin, WebSearchPluginConfig, "web-search">;

package/lib/src/plugin.js

@@ -0,0 +1,225 @@
+/**
+ * AppKit plugin (registered name: `web-search`) that owns the resolved
+ * web-search runtime - the URL policy, result / length caps, timeout, and
+ * default approval gate the {@link webSearchTool} / {@link webFetchTool}
+ * read. Registering it resolves and logs the effective config (which URL
+ * policy is in force, the caps) so a misconfiguration is visible in the boot
+ * logs rather than on the first search, and installs the plugin's
+ * `execute()` as the runtime's executor so every outbound call picks up
+ * AppKit's cache / retry / timeout / telemetry chain.
+ *
+ * The plugin also implements AppKit's `ToolProvider`, so an AppKit agent gets
+ * `web_search` / `web_fetch` without going through Mastra; the Mastra tools in
+ * `tool.ts` are the other half and share the same runtime.
+ *
+ * @module
+ */
+import { Plugin, ResourceType, toPlugin, } from "@databricks/appkit";
+import { defineTool, executeFromRegistry, toolsFromRegistry, } from "@databricks/appkit/beta";
+import { log, string } from "@dbx-tools/shared-core";
+import { MODEL_ENV, SERVING_ENDPOINT_ENV, WEB_SEARCH_CONFIG_SCHEMA, } from "./config.js";
+import { runWebFetch } from "./fetch.js";
+import { getWebSearchRuntime, resetWebSearchRuntime, setWebSearchExecutor } from "./runtime.js";
+import { webFetchRequestSchema, webSearchRequestSchema, WEB_FETCH_TOOL_DESCRIPTION, WEB_SEARCH_TOOL_DESCRIPTION, } from "./schema.js";
+import { resolveWebSearchContext, runWebSearch } from "./search.js";
+const logger = log.logger("web-search");
+/**
+ * The Model Serving endpoint the native web-search tool runs on. Declared
+ * optional because the plugin resolves a web-search-capable endpoint from the
+ * live catalogue when nothing is pinned; {@link WebSearchPlugin.getResourceRequirements}
+ * promotes it to required once a deployment names one. `CAN_QUERY` is the
+ * weakest permission that can invoke an endpoint.
+ */
+const SERVING_ENDPOINT_RESOURCE = {
+    type: ResourceType.SERVING_ENDPOINT,
+    alias: "Web Search Endpoint",
+    resourceKey: "web-search-endpoint",
+    description: "Model Serving endpoint running the native web-search tool. Optional: resolved from the " +
+        "workspace catalogue (Gemini, then GPT) when no endpoint is pinned.",
+    permission: "CAN_QUERY",
+    fields: {
+        name: {
+            env: SERVING_ENDPOINT_ENV,
+            description: `Serving endpoint name for web search. ${MODEL_ENV} overrides it.`,
+            discovery: {
+                type: "cli",
+                cliCommand: "databricks serving-endpoints list --profile <PROFILE> --output json",
+                selectField: ".name",
+            },
+        },
+    },
+};
+/**
+ * AppKit plugin that resolves and holds the web-search runtime config used
+ * by the `web_search` / `web_fetch` tools.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as webSearchPlugin } from "@dbx-tools/appkit-web-search";
+ *
+ * await createApp({
+ *   plugins: [
+ *     server(),
+ *     webSearchPlugin.webSearch({
+ *       model: "gemini",
+ *       urlPolicy: "allowlist",
+ *       allowedUrls: ["*.databricks.com"],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export class WebSearchPlugin extends Plugin {
+    static manifest = {
+        name: "web-search",
+        displayName: "Web Search",
+        description: "Searches the web through the Databricks native web-search tool on its own " +
+            "web-capable serving endpoint, and fetches pages via got-scraping, behind an " +
+            "optional URL allow-list and per-tool approval gating.",
+        stability: "beta",
+        resources: {
+            required: [],
+            optional: [SERVING_ENDPOINT_RESOURCE],
+        },
+        config: { schema: WEB_SEARCH_CONFIG_SCHEMA },
+    };
+    /**
+     * Promote the serving endpoint to a required resource once a deployment
+     * pins one, through plugin config or either environment name. Left optional
+     * otherwise, because the plugin picks a web-search-capable endpoint out of
+     * the live catalogue on its own.
+     */
+    static getResourceRequirements(config) {
+        const pinned = string.trimToNull(config.model) ??
+            string.trimToNull(process.env[MODEL_ENV]) ??
+            string.trimToNull(process.env[SERVING_ENDPOINT_ENV]);
+        return pinned === null ? [] : [{ ...SERVING_ENDPOINT_RESOURCE, required: true }];
+    }
+    /**
+     * The tools this plugin offers to an AppKit agent. Both are reads and both
+     * run under the caller's identity.
+     *
+     * Neither is `autoInheritable`. `web_fetch` reaches a URL the model chose,
+     * which is reachable from inside the workspace network, so it must only
+     * appear in an agent that asked for it and accepted the URL policy that
+     * comes with it. `web_search` is safer but still spends serving tokens on
+     * every call, so it is opt-in for cost rather than for safety.
+     *
+     * `execute` re-parses its arguments with the local schema: AppKit validates
+     * against the same schema first, but re-parsing is what gives the body typed
+     * arguments instead of `unknown`.
+     */
+    tools = {
+        web_search: defineTool({
+            description: WEB_SEARCH_TOOL_DESCRIPTION,
+            schema: webSearchRequestSchema,
+            annotations: { effect: "read", requiresUserContext: true },
+            autoInheritable: false,
+            execute: async (args, signal) => this.search(webSearchRequestSchema.parse(args), signal),
+        }),
+        web_fetch: defineTool({
+            description: WEB_FETCH_TOOL_DESCRIPTION,
+            schema: webFetchRequestSchema,
+            annotations: { effect: "read", requiresUserContext: true },
+            autoInheritable: false,
+            execute: async (args, signal) => this.fetch(webFetchRequestSchema.parse(args), signal),
+        }),
+    };
+    /**
+     * Prime the shared runtime from this plugin's config (over env), route the
+     * tools' outbound calls through this plugin's interceptor chain, and log the
+     * effective policy so an active allow-list / caps are obvious at boot.
+     */
+    async setup() {
+        const { config } = getWebSearchRuntime(this.config);
+        setWebSearchExecutor((fn, settings) => this.execute(fn, settings));
+        logger.info("ready", {
+            model: config.model ?? `fallbacks:[${config.modelFallbacks.join(", ")}]`,
+            modelSource: config.modelSource,
+            urlPolicy: config.urlPolicy,
+            ...(config.allowList.restricted ? { allowedUrls: config.allowList.patterns } : {}),
+            maxCitations: config.maxCitations,
+            fetchMaxLength: config.fetchMaxLength,
+            approval: config.approval.mode,
+            scrapeFallback: config.scrapeFallback,
+        });
+    }
+    /**
+     * Drop the shared runtime so a restarted app re-resolves config and does not
+     * keep calling through a torn-down plugin's `execute()`. Bounded and
+     * idempotent: there is no connection to drain, only the memo to clear.
+     */
+    async shutdown() {
+        resetWebSearchRuntime();
+    }
+    /**
+     * Abort in-flight work. AppKit's graceful shutdown only invokes this hook -
+     * it never calls {@link shutdown} - so the runtime memo is dropped from here
+     * to keep a restarted app from calling through a torn-down `execute()`. The
+     * teardown is synchronous and idempotent, so the un-awaited call costs
+     * nothing.
+     */
+    abortActiveOperations() {
+        super.abortActiveOperations();
+        void this.shutdown();
+    }
+    /** AppKit `ToolProvider`: the tool definitions offered to an agent. */
+    getAgentTools() {
+        return toolsFromRegistry(this.tools);
+    }
+    /**
+     * AppKit `ToolProvider`: run one tool call. Arguments are validated against
+     * the tool's schema first, and a validation failure comes back as an
+     * LLM-friendly string so the model can correct itself on the next turn.
+     */
+    async executeAgentTool(name, args, signal) {
+        return executeFromRegistry(this.tools, name, args, signal);
+    }
+    exports() {
+        return {
+            /**
+             * Run a web search directly (bypassing the agent tool). Resolves the
+             * OBO client from the active execution context and reads the shared
+             * runtime config primed at setup.
+             */
+            search: (request, signal) => this.search(request, signal),
+            /**
+             * Fetch one URL directly (bypassing the agent tool). Enforces the
+             * configured URL policy. Reads the shared runtime config.
+             */
+            fetch: (request, signal) => this.fetch(request, signal),
+        };
+    }
+    async search(request, signal) {
+        return runWebSearch(request, getWebSearchRuntime().config, await resolveWebSearchContext(), signal);
+    }
+    async fetch(request, signal) {
+        return runWebFetch(request, getWebSearchRuntime().config, signal);
+    }
+}
+/**
+ * Register the web-search runtime with AppKit.
+ *
+ * @example
+ * ```ts
+ * import { createApp, server } from "@databricks/appkit";
+ * import { plugin as webSearchPlugin, tool as webTool } from "@dbx-tools/appkit-web-search";
+ * import { agents, plugin as mastraPlugin } from "@dbx-tools/appkit-mastra";
+ *
+ * const researcher = agents.createAgent({
+ *   instructions: "Research questions with web_search, then read sources with web_fetch.",
+ *   tools: () => ({ web_search: webTool.webSearchTool(), web_fetch: webTool.webFetchTool() }),
+ * });
+ *
+ * await createApp({
+ *   plugins: [
+ *     server(),
+ *     webSearchPlugin.webSearch({ model: "gemini" }),
+ *     mastraPlugin.mastra({ agents: researcher }),
+ *   ],
+ * });
+ * ```
+ */
+export const webSearch = toPlugin(WebSearchPlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit plugin (registered name: `web-search`) that owns the resolved\n * web-search runtime - the URL policy, result / length caps, timeout, and\n * default approval gate the {@link webSearchTool} / {@link webFetchTool}\n * read. Registering it resolves and logs the effective config (which URL\n * policy is in force, the caps) so a misconfiguration is visible in the boot\n * logs rather than on the first search, and installs the plugin's\n * `execute()` as the runtime's executor so every outbound call picks up\n * AppKit's cache / retry / timeout / telemetry chain.\n *\n * The plugin also implements AppKit's `ToolProvider`, so an AppKit agent gets\n * `web_search` / `web_fetch` without going through Mastra; the Mastra tools in\n * `tool.ts` are the other half and share the same runtime.\n *\n * @module\n */\n\nimport {\n  Plugin,\n  ResourceType,\n  toPlugin,\n  type PluginManifest,\n  type ResourceRequirement,\n} from \"@databricks/appkit\";\nimport {\n  defineTool,\n  executeFromRegistry,\n  toolsFromRegistry,\n  type AgentToolDefinition,\n  type ToolProvider,\n  type ToolRegistry,\n} from \"@databricks/appkit/beta\";\nimport { log, string } from \"@dbx-tools/shared-core\";\nimport {\n  MODEL_ENV,\n  SERVING_ENDPOINT_ENV,\n  WEB_SEARCH_CONFIG_SCHEMA,\n  type WebSearchPluginConfig,\n} from \"./config\";\nimport { runWebFetch } from \"./fetch\";\nimport { getWebSearchRuntime, resetWebSearchRuntime, setWebSearchExecutor } from \"./runtime\";\nimport {\n  webFetchRequestSchema,\n  webSearchRequestSchema,\n  WEB_FETCH_TOOL_DESCRIPTION,\n  WEB_SEARCH_TOOL_DESCRIPTION,\n} from \"./schema\";\nimport type { WebFetchRequest, WebFetchResult, WebSearchRequest, WebSearchResult } from \"./schema\";\nimport { resolveWebSearchContext, runWebSearch } from \"./search\";\n\nconst logger = log.logger(\"web-search\");\n\n/**\n * The Model Serving endpoint the native web-search tool runs on. Declared\n * optional because the plugin resolves a web-search-capable endpoint from the\n * live catalogue when nothing is pinned; {@link WebSearchPlugin.getResourceRequirements}\n * promotes it to required once a deployment names one. `CAN_QUERY` is the\n * weakest permission that can invoke an endpoint.\n */\nconst SERVING_ENDPOINT_RESOURCE = {\n  type: ResourceType.SERVING_ENDPOINT,\n  alias: \"Web Search Endpoint\",\n  resourceKey: \"web-search-endpoint\",\n  description:\n    \"Model Serving endpoint running the native web-search tool. Optional: resolved from the \" +\n    \"workspace catalogue (Gemini, then GPT) when no endpoint is pinned.\",\n  permission: \"CAN_QUERY\",\n  fields: {\n    name: {\n      env: SERVING_ENDPOINT_ENV,\n      description: `Serving endpoint name for web search. ${MODEL_ENV} overrides it.`,\n      discovery: {\n        type: \"cli\",\n        cliCommand: \"databricks serving-endpoints list --profile <PROFILE> --output json\",\n        selectField: \".name\",\n      },\n    },\n  },\n} satisfies Omit<ResourceRequirement, \"required\">;\n\n/**\n * AppKit plugin that resolves and holds the web-search runtime config used\n * by the `web_search` / `web_fetch` tools.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as webSearchPlugin } from \"@dbx-tools/appkit-web-search\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     webSearchPlugin.webSearch({\n *       model: \"gemini\",\n *       urlPolicy: \"allowlist\",\n *       allowedUrls: [\"*.databricks.com\"],\n *     }),\n *   ],\n * });\n * ```\n */\nexport class WebSearchPlugin extends Plugin<WebSearchPluginConfig> implements ToolProvider {\n  static manifest = {\n    name: \"web-search\",\n    displayName: \"Web Search\",\n    description:\n      \"Searches the web through the Databricks native web-search tool on its own \" +\n      \"web-capable serving endpoint, and fetches pages via got-scraping, behind an \" +\n      \"optional URL allow-list and per-tool approval gating.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [SERVING_ENDPOINT_RESOURCE],\n    },\n    config: { schema: WEB_SEARCH_CONFIG_SCHEMA },\n  } satisfies PluginManifest<\"web-search\">;\n\n  /**\n   * Promote the serving endpoint to a required resource once a deployment\n   * pins one, through plugin config or either environment name. Left optional\n   * otherwise, because the plugin picks a web-search-capable endpoint out of\n   * the live catalogue on its own.\n   */\n  static getResourceRequirements(config: WebSearchPluginConfig): ResourceRequirement[] {\n    const pinned =\n      string.trimToNull(config.model) ??\n      string.trimToNull(process.env[MODEL_ENV]) ??\n      string.trimToNull(process.env[SERVING_ENDPOINT_ENV]);\n    return pinned === null ? [] : [{ ...SERVING_ENDPOINT_RESOURCE, required: true }];\n  }\n\n  /**\n   * The tools this plugin offers to an AppKit agent. Both are reads and both\n   * run under the caller's identity.\n   *\n   * Neither is `autoInheritable`. `web_fetch` reaches a URL the model chose,\n   * which is reachable from inside the workspace network, so it must only\n   * appear in an agent that asked for it and accepted the URL policy that\n   * comes with it. `web_search` is safer but still spends serving tokens on\n   * every call, so it is opt-in for cost rather than for safety.\n   *\n   * `execute` re-parses its arguments with the local schema: AppKit validates\n   * against the same schema first, but re-parsing is what gives the body typed\n   * arguments instead of `unknown`.\n   */\n  private readonly tools: ToolRegistry = {\n    web_search: defineTool({\n      description: WEB_SEARCH_TOOL_DESCRIPTION,\n      schema: webSearchRequestSchema,\n      annotations: { effect: \"read\", requiresUserContext: true },\n      autoInheritable: false,\n      execute: async (args, signal) => this.search(webSearchRequestSchema.parse(args), signal),\n    }),\n    web_fetch: defineTool({\n      description: WEB_FETCH_TOOL_DESCRIPTION,\n      schema: webFetchRequestSchema,\n      annotations: { effect: \"read\", requiresUserContext: true },\n      autoInheritable: false,\n      execute: async (args, signal) => this.fetch(webFetchRequestSchema.parse(args), signal),\n    }),\n  };\n\n  /**\n   * Prime the shared runtime from this plugin's config (over env), route the\n   * tools' outbound calls through this plugin's interceptor chain, and log the\n   * effective policy so an active allow-list / caps are obvious at boot.\n   */\n  override async setup(): Promise<void> {\n    const { config } = getWebSearchRuntime(this.config);\n    setWebSearchExecutor((fn, settings) => this.execute(fn, settings));\n    logger.info(\"ready\", {\n      model: config.model ?? `fallbacks:[${config.modelFallbacks.join(\", \")}]`,\n      modelSource: config.modelSource,\n      urlPolicy: config.urlPolicy,\n      ...(config.allowList.restricted ? { allowedUrls: config.allowList.patterns } : {}),\n      maxCitations: config.maxCitations,\n      fetchMaxLength: config.fetchMaxLength,\n      approval: config.approval.mode,\n      scrapeFallback: config.scrapeFallback,\n    });\n  }\n\n  /**\n   * Drop the shared runtime so a restarted app re-resolves config and does not\n   * keep calling through a torn-down plugin's `execute()`. Bounded and\n   * idempotent: there is no connection to drain, only the memo to clear.\n   */\n  async shutdown(): Promise<void> {\n    resetWebSearchRuntime();\n  }\n\n  /**\n   * Abort in-flight work. AppKit's graceful shutdown only invokes this hook -\n   * it never calls {@link shutdown} - so the runtime memo is dropped from here\n   * to keep a restarted app from calling through a torn-down `execute()`. The\n   * teardown is synchronous and idempotent, so the un-awaited call costs\n   * nothing.\n   */\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\n    void this.shutdown();\n  }\n\n  /** AppKit `ToolProvider`: the tool definitions offered to an agent. */\n  getAgentTools(): AgentToolDefinition[] {\n    return toolsFromRegistry(this.tools);\n  }\n\n  /**\n   * AppKit `ToolProvider`: run one tool call. Arguments are validated against\n   * the tool's schema first, and a validation failure comes back as an\n   * LLM-friendly string so the model can correct itself on the next turn.\n   */\n  async executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown> {\n    return executeFromRegistry(this.tools, name, args, signal);\n  }\n\n  override exports() {\n    return {\n      /**\n       * Run a web search directly (bypassing the agent tool). Resolves the\n       * OBO client from the active execution context and reads the shared\n       * runtime config primed at setup.\n       */\n      search: (request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult> =>\n        this.search(request, signal),\n      /**\n       * Fetch one URL directly (bypassing the agent tool). Enforces the\n       * configured URL policy. Reads the shared runtime config.\n       */\n      fetch: (request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult> =>\n        this.fetch(request, signal),\n    };\n  }\n\n  private async search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult> {\n    return runWebSearch(\n      request,\n      getWebSearchRuntime().config,\n      await resolveWebSearchContext(),\n      signal,\n    );\n  }\n\n  private async fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult> {\n    return runWebFetch(request, getWebSearchRuntime().config, signal);\n  }\n}\n\n/**\n * Register the web-search runtime with AppKit.\n *\n * @example\n * ```ts\n * import { createApp, server } from \"@databricks/appkit\";\n * import { plugin as webSearchPlugin, tool as webTool } from \"@dbx-tools/appkit-web-search\";\n * import { agents, plugin as mastraPlugin } from \"@dbx-tools/appkit-mastra\";\n *\n * const researcher = agents.createAgent({\n *   instructions: \"Research questions with web_search, then read sources with web_fetch.\",\n *   tools: () => ({ web_search: webTool.webSearchTool(), web_fetch: webTool.webFetchTool() }),\n * });\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     webSearchPlugin.webSearch({ model: \"gemini\" }),\n *     mastraPlugin.mastra({ agents: researcher }),\n *   ],\n * });\n * ```\n */\nexport const webSearch = toPlugin(WebSearchPlugin);\n"]}