@dbx-tools/appkit-web-search 0.9.132 → 0.9.138

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-web-search";
-export const PACKAGE_VERSION = "0.9.132";
+export const PACKAGE_VERSION = "0.9.138";
 export * as allowlist from "./src/allowlist.ts";
 export * as config from "./src/config.ts";
 export * as defaults from "./src/defaults.ts";
@@ -21,6 +21,7 @@ export { MODEL_ENV, SERVING_ENDPOINT_ENV, DEFAULT_MODEL_FALLBACKS, DEFAULT_MAX_C
 export type { ApprovalGate, ApprovalPolicy, UrlPolicyMode, ModelSource, WebSearchPluginConfig, ResolvedWebSearchConfig } from "./src/config.ts";
 export { SEARCH_CACHE_TTL_SECONDS, FETCH_CACHE_TTL_SECONDS, SERVING_RETRY_ATTEMPTS, WEB_RETRY_ATTEMPTS, webSearchExecuteDefaults, webFetchExecuteDefaults, scrapeSearchExecuteDefaults } from "./src/defaults.ts";
 export type { WebSearchExecuteConfig, WebSearchExecutionSettings } from "./src/defaults.ts";
+export type { WebAssetPageFetchRequest, WebImageFetchRequest, WebImageFetchResult } from "./src/fetch.ts";
 export { WebSearchPlugin, webSearch } from "./src/plugin.ts";
 export { WebSearchProviderSpecSchema, WEB_SEARCH_PROVIDERS } from "./src/provider.ts";
 export type { WebSearchProvider, WebSearchProviderSpec } from "./src/provider.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-web-search";
-export declare const PACKAGE_VERSION = "0.9.132";
+export declare const PACKAGE_VERSION = "0.9.138";
 export * as allowlist from "./src/allowlist.ts";
 export * as config from "./src/config.ts";
 export * as defaults from "./src/defaults.ts";
@@ -17,6 +17,7 @@ export { MODEL_ENV, SERVING_ENDPOINT_ENV, DEFAULT_MODEL_FALLBACKS, DEFAULT_MAX_C
 export type { ApprovalGate, ApprovalPolicy, UrlPolicyMode, ModelSource, WebSearchPluginConfig, ResolvedWebSearchConfig } from "./src/config.ts";
 export { SEARCH_CACHE_TTL_SECONDS, FETCH_CACHE_TTL_SECONDS, SERVING_RETRY_ATTEMPTS, WEB_RETRY_ATTEMPTS, webSearchExecuteDefaults, webFetchExecuteDefaults, scrapeSearchExecuteDefaults } from "./src/defaults.ts";
 export type { WebSearchExecuteConfig, WebSearchExecutionSettings } from "./src/defaults.ts";
+export type { WebAssetPageFetchRequest, WebImageFetchRequest, WebImageFetchResult } from "./src/fetch.ts";
 export { WebSearchPlugin, webSearch } from "./src/plugin.ts";
 export { WebSearchProviderSpecSchema, WEB_SEARCH_PROVIDERS } from "./src/provider.ts";
 export type { WebSearchProvider, WebSearchProviderSpec } from "./src/provider.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-web-search";
-export const PACKAGE_VERSION = "0.9.132";
+export const PACKAGE_VERSION = "0.9.138";
 export * as allowlist from "./src/allowlist.js";
 export * as config from "./src/config.js";
 export * as defaults from "./src/defaults.js";
@@ -20,4 +20,4 @@ export { SEARCH_CACHE_TTL_SECONDS, FETCH_CACHE_TTL_SECONDS, SERVING_RETRY_ATTEMP
 export { WebSearchPlugin, webSearch } from "./src/plugin.js";
 export { WebSearchProviderSpecSchema, WEB_SEARCH_PROVIDERS } from "./src/provider.js";
 export { WEB_SEARCH_TOOL_DESCRIPTION, WEB_FETCH_TOOL_DESCRIPTION, webSearchRequestSchema, webSearchToolRequestSchema, webSearchCitationSchema, webSearchResultSchema, webFetchRequestSchema, webFetchResultSchema } from "./src/schema.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/fetch.d.ts

@@ -16,6 +16,29 @@
  */
 import { type WebSearchRuntimeInput } from "./runtime.ts";
 import type { WebFetchRequest, WebFetchResult } from "./schema.ts";
+/** Input for a policy-checked HTML fetch used by in-process asset discovery. */
+export interface WebAssetPageFetchRequest {
+    /** Public HTTPS page URL. */
+    url: string;
+    /** Maximum returned markup length. Defaults to 1.5 million characters. */
+    maxLength?: number;
+}
+/** Input for a policy-checked binary image fetch. */
+export interface WebImageFetchRequest {
+    /** Public HTTPS image URL. */
+    url: string;
+    /** Maximum accepted response size. Defaults to 5 MiB. */
+    maxBytes?: number;
+}
+/** Binary image fetched through the web-search runtime's URL policy. */
+export interface WebImageFetchResult {
+    /** Final URL after redirects. */
+    url: string;
+    /** Image media type returned by the server. */
+    contentType: string;
+    /** Fetched image bytes. */
+    data: Uint8Array;
+}
 /**
  * Fetch a single URL and return its content in the requested format.
  *
@@ -25,3 +48,11 @@ import type { WebFetchRequest, WebFetchResult } from "./schema.ts";
  * `signal` cancels the in-flight fetch.
  */
 export declare function runWebFetch(request: WebFetchRequest, runtimeOrConfig: WebSearchRuntimeInput, signal?: AbortSignal): Promise<WebFetchResult>;
+/**
+ * Fetch bounded raw markup for deterministic in-process asset discovery.
+ *
+ * This does not widen the model-facing `web_fetch` cap.
+ */
+export declare function runWebAssetPageFetch(request: WebAssetPageFetchRequest, runtimeOrConfig: WebSearchRuntimeInput, signal?: AbortSignal): Promise<WebFetchResult>;
+/** Fetch one public image while preserving URL policy, timeout, and redirect checks. */
+export declare function runWebImageFetch(request: WebImageFetchRequest, runtimeOrConfig: WebSearchRuntimeInput, signal?: AbortSignal): Promise<WebImageFetchResult>;

package/lib/src/fetch.js

@@ -19,8 +19,10 @@ import { gotScraping } from "got-scraping";
 import { assertFetchUrlAllowed } from "./_fetch-url.js";
 import { toCallSettings, webFetchExecuteDefaults } from "./defaults.js";
 import { decodeHtmlEntities, htmlToText } from "./html-text.js";
-import { executeRead, toWebSearchRuntime } from "./runtime.js";
+import { executeRead, toWebSearchRuntime, } from "./runtime.js";
 const logger = log.logger("web-search/fetch");
+const DEFAULT_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
+const DEFAULT_ASSET_PAGE_MAX_LENGTH = 1_500_000;
 /** Pull the <title> text out of an HTML document, when present. */
 function extractTitle(html) {
     const match = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
@@ -33,29 +35,18 @@ function truncate(text, 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, runtimeOrConfig, signal) {
-    const runtime = toWebSearchRuntime(runtimeOrConfig);
+/** Fetch and cache one raw page before caller-specific output reduction. */
+async function fetchPage(requestUrl, runtime, signal) {
     const { config } = runtime;
-    await assertFetchUrlAllowed(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.
+    await assertFetchUrlAllowed(requestUrl, config.allowList);
     const page = await executeRead(runtime, "page-fetch", toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [
         "web-search",
         "fetch",
-        request.url,
+        requestUrl,
         ...config.allowList.patterns,
     ]), async (executeSignal) => {
         const response = await gotScraping({
-            url: request.url,
+            url: requestUrl,
             // Bun's node:http2 reports default-port origins with :443 while
             // http2-wrapper compares them against URL-normalized origins.
             http2: false,
@@ -74,13 +65,28 @@ export async function runWebFetch(request, runtimeOrConfig, signal) {
             ...(executeSignal ? { signal: executeSignal } : {}),
         });
         return {
-            url: response.url ?? request.url,
+            url: response.url ?? requestUrl,
             statusCode: response.statusCode,
             contentType: response.headers["content-type"],
             body: typeof response.body === "string" ? response.body : String(response.body ?? ""),
         };
     }, signal);
     await assertFetchUrlAllowed(page.url, config.allowList);
+    return page;
+}
+/**
+ * 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, runtimeOrConfig, signal) {
+    const runtime = toWebSearchRuntime(runtimeOrConfig);
+    const { config } = runtime;
+    const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);
+    const page = await fetchPage(request.url, runtime, 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);
@@ -101,4 +107,72 @@ export async function runWebFetch(request, runtimeOrConfig, signal) {
         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 { assertFetchUrlAllowed } from \"./_fetch-url.ts\";\nimport { toCallSettings, webFetchExecuteDefaults } from \"./defaults.ts\";\nimport { decodeHtmlEntities, htmlToText } from \"./html-text.ts\";\nimport { executeRead, toWebSearchRuntime, type WebSearchRuntimeInput } from \"./runtime.ts\";\nimport type { WebFetchRequest, WebFetchResult } from \"./schema.ts\";\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  runtimeOrConfig: WebSearchRuntimeInput,\n  signal?: AbortSignal,\n): Promise<WebFetchResult> {\n  const runtime = toWebSearchRuntime(runtimeOrConfig);\n  const { config } = runtime;\n  await assertFetchUrlAllowed(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    runtime,\n    \"page-fetch\",\n    toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [\n      \"web-search\",\n      \"fetch\",\n      request.url,\n      ...config.allowList.patterns,\n    ]),\n    async (executeSignal): Promise<FetchedPage> => {\n      const response = await gotScraping({\n        url: request.url,\n        // Bun's node:http2 reports default-port origins with :443 while\n        // http2-wrapper compares them against URL-normalized origins.\n        http2: false,\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        hooks: {\n          beforeRequest: [\n            async (options) => {\n              await assertFetchUrlAllowed(String(options.url), config.allowList);\n            },\n          ],\n        },\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  await assertFetchUrlAllowed(page.url, config.allowList);\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"]}
+/**
+ * Fetch bounded raw markup for deterministic in-process asset discovery.
+ *
+ * This does not widen the model-facing `web_fetch` cap.
+ */
+export async function runWebAssetPageFetch(request, runtimeOrConfig, signal) {
+    const runtime = toWebSearchRuntime(runtimeOrConfig);
+    const cap = Math.min(Math.max(1, request.maxLength ?? DEFAULT_ASSET_PAGE_MAX_LENGTH), DEFAULT_ASSET_PAGE_MAX_LENGTH);
+    const page = await fetchPage(request.url, runtime, signal);
+    const { content, truncated } = truncate(page.body, cap);
+    const title = extractTitle(page.body);
+    return {
+        url: page.url,
+        status: page.statusCode,
+        ...(page.contentType ? { contentType: page.contentType } : {}),
+        ...(title ? { title } : {}),
+        content,
+        truncated,
+    };
+}
+/** Fetch one public image while preserving URL policy, timeout, and redirect checks. */
+export async function runWebImageFetch(request, runtimeOrConfig, signal) {
+    const runtime = toWebSearchRuntime(runtimeOrConfig);
+    const { config } = runtime;
+    const maxBytes = Math.max(1, request.maxBytes ?? DEFAULT_IMAGE_MAX_BYTES);
+    await assertFetchUrlAllowed(request.url, config.allowList);
+    const page = await executeRead(runtime, "image-fetch", {
+        default: {
+            cache: { enabled: false },
+            retry: { enabled: true, attempts: 2 },
+            timeout: config.timeoutMs,
+        },
+    }, async (executeSignal) => {
+        const response = await gotScraping({
+            url: request.url,
+            responseType: "buffer",
+            http2: false,
+            timeout: { request: config.timeoutMs },
+            throwHttpErrors: true,
+            followRedirect: true,
+            hooks: {
+                beforeRequest: [
+                    async (options) => {
+                        await assertFetchUrlAllowed(String(options.url), config.allowList);
+                    },
+                ],
+            },
+            ...(executeSignal ? { signal: executeSignal } : {}),
+        });
+        const contentType = String(response.headers["content-type"] ?? "")
+            .split(";")[0]
+            .trim()
+            .toLowerCase();
+        if (!contentType.startsWith("image/")) {
+            throw new TypeError(`Expected an image response, received ${contentType || "unknown"}`);
+        }
+        if (response.body.byteLength > maxBytes) {
+            throw new RangeError(`Image response exceeds ${maxBytes} bytes`);
+        }
+        return {
+            url: response.url ?? request.url,
+            contentType,
+            data: new Uint8Array(response.body),
+        };
+    }, signal, false);
+    await assertFetchUrlAllowed(page.url, config.allowList);
+    return page;
+}
+//# 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 { assertFetchUrlAllowed } from \"./_fetch-url.ts\";\nimport { toCallSettings, webFetchExecuteDefaults } from \"./defaults.ts\";\nimport { decodeHtmlEntities, htmlToText } from \"./html-text.ts\";\nimport {\n  executeRead,\n  toWebSearchRuntime,\n  type WebSearchRuntime,\n  type WebSearchRuntimeInput,\n} from \"./runtime.ts\";\nimport type { WebFetchRequest, WebFetchResult } from \"./schema.ts\";\n\nconst logger = log.logger(\"web-search/fetch\");\nconst DEFAULT_IMAGE_MAX_BYTES = 5 * 1024 * 1024;\nconst DEFAULT_ASSET_PAGE_MAX_LENGTH = 1_500_000;\n\n/** Input for a policy-checked HTML fetch used by in-process asset discovery. */\nexport interface WebAssetPageFetchRequest {\n  /** Public HTTPS page URL. */\n  url: string;\n  /** Maximum returned markup length. Defaults to 1.5 million characters. */\n  maxLength?: number;\n}\n\n/** Input for a policy-checked binary image fetch. */\nexport interface WebImageFetchRequest {\n  /** Public HTTPS image URL. */\n  url: string;\n  /** Maximum accepted response size. Defaults to 5 MiB. */\n  maxBytes?: number;\n}\n\n/** Binary image fetched through the web-search runtime's URL policy. */\nexport interface WebImageFetchResult {\n  /** Final URL after redirects. */\n  url: string;\n  /** Image media type returned by the server. */\n  contentType: string;\n  /** Fetched image bytes. */\n  data: Uint8Array;\n}\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/** Fetch and cache one raw page before caller-specific output reduction. */\nasync function fetchPage(\n  requestUrl: string,\n  runtime: WebSearchRuntime,\n  signal?: AbortSignal,\n): Promise<FetchedPage> {\n  const { config } = runtime;\n  await assertFetchUrlAllowed(requestUrl, config.allowList);\n  const page = await executeRead(\n    runtime,\n    \"page-fetch\",\n    toCallSettings(webFetchExecuteDefaults, config.timeoutMs, [\n      \"web-search\",\n      \"fetch\",\n      requestUrl,\n      ...config.allowList.patterns,\n    ]),\n    async (executeSignal): Promise<FetchedPage> => {\n      const response = await gotScraping({\n        url: requestUrl,\n        // Bun's node:http2 reports default-port origins with :443 while\n        // http2-wrapper compares them against URL-normalized origins.\n        http2: false,\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        hooks: {\n          beforeRequest: [\n            async (options) => {\n              await assertFetchUrlAllowed(String(options.url), config.allowList);\n            },\n          ],\n        },\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      return {\n        url: response.url ?? requestUrl,\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  await assertFetchUrlAllowed(page.url, config.allowList);\n  return page;\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  runtimeOrConfig: WebSearchRuntimeInput,\n  signal?: AbortSignal,\n): Promise<WebFetchResult> {\n  const runtime = toWebSearchRuntime(runtimeOrConfig);\n  const { config } = runtime;\n  const cap = Math.min(request.maxLength ?? config.fetchMaxLength, config.fetchMaxLength);\n  const page = await fetchPage(request.url, runtime, signal);\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\n/**\n * Fetch bounded raw markup for deterministic in-process asset discovery.\n *\n * This does not widen the model-facing `web_fetch` cap.\n */\nexport async function runWebAssetPageFetch(\n  request: WebAssetPageFetchRequest,\n  runtimeOrConfig: WebSearchRuntimeInput,\n  signal?: AbortSignal,\n): Promise<WebFetchResult> {\n  const runtime = toWebSearchRuntime(runtimeOrConfig);\n  const cap = Math.min(\n    Math.max(1, request.maxLength ?? DEFAULT_ASSET_PAGE_MAX_LENGTH),\n    DEFAULT_ASSET_PAGE_MAX_LENGTH,\n  );\n  const page = await fetchPage(request.url, runtime, signal);\n  const { content, truncated } = truncate(page.body, cap);\n  const title = extractTitle(page.body);\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\n/** Fetch one public image while preserving URL policy, timeout, and redirect checks. */\nexport async function runWebImageFetch(\n  request: WebImageFetchRequest,\n  runtimeOrConfig: WebSearchRuntimeInput,\n  signal?: AbortSignal,\n): Promise<WebImageFetchResult> {\n  const runtime = toWebSearchRuntime(runtimeOrConfig);\n  const { config } = runtime;\n  const maxBytes = Math.max(1, request.maxBytes ?? DEFAULT_IMAGE_MAX_BYTES);\n  await assertFetchUrlAllowed(request.url, config.allowList);\n  const page = await executeRead(\n    runtime,\n    \"image-fetch\",\n    {\n      default: {\n        cache: { enabled: false },\n        retry: { enabled: true, attempts: 2 },\n        timeout: config.timeoutMs,\n      },\n    },\n    async (executeSignal) => {\n      const response = await gotScraping({\n        url: request.url,\n        responseType: \"buffer\",\n        http2: false,\n        timeout: { request: config.timeoutMs },\n        throwHttpErrors: true,\n        followRedirect: true,\n        hooks: {\n          beforeRequest: [\n            async (options) => {\n              await assertFetchUrlAllowed(String(options.url), config.allowList);\n            },\n          ],\n        },\n        ...(executeSignal ? { signal: executeSignal } : {}),\n      });\n      const contentType = String(response.headers[\"content-type\"] ?? \"\")\n        .split(\";\")[0]!\n        .trim()\n        .toLowerCase();\n      if (!contentType.startsWith(\"image/\")) {\n        throw new TypeError(`Expected an image response, received ${contentType || \"unknown\"}`);\n      }\n      if (response.body.byteLength > maxBytes) {\n        throw new RangeError(`Image response exceeds ${maxBytes} bytes`);\n      }\n      return {\n        url: response.url ?? request.url,\n        contentType,\n        data: new Uint8Array(response.body),\n      };\n    },\n    signal,\n    false,\n  );\n  await assertFetchUrlAllowed(page.url, config.allowList);\n  return page;\n}\n"]}

package/lib/src/plugin.d.ts

@@ -19,6 +19,7 @@ import { type ToolRegistry } from "@databricks/appkit/beta";
 import { ToolRegistryPlugin } from "@dbx-tools/appkit";
 import type { AgentToolExecutionContext } from "@dbx-tools/appkit/tool-provider";
 import { type WebSearchPluginConfig } from "./config.ts";
+import { type WebAssetPageFetchRequest, type WebImageFetchRequest, type WebImageFetchResult } from "./fetch.ts";
 import type { WebFetchRequest, WebFetchResult, WebSearchRequest, WebSearchResult } from "./schema.ts";
 /**
  * AppKit plugin that resolves and holds the web-search runtime config used
@@ -123,6 +124,10 @@ export declare class WebSearchPlugin extends ToolRegistryPlugin<WebSearchPluginC
          * configured URL policy.
          */
         fetch: (request: WebFetchRequest, signal?: AbortSignal) => Promise<WebFetchResult>;
+        /** Fetch expanded HTML for in-process asset discovery. */
+        fetchAssetPage: (request: WebAssetPageFetchRequest, signal?: AbortSignal) => Promise<WebFetchResult>;
+        /** Fetch one image for in-process visual research. */
+        fetchImage: (request: WebImageFetchRequest, signal?: AbortSignal) => Promise<WebImageFetchResult>;
     };
     private search;
     private fetch;

package/lib/src/plugin.js

@@ -19,7 +19,7 @@ import { defineTool } from "@databricks/appkit/beta";
 import { ToolRegistryPlugin } from "@dbx-tools/appkit";
 import { log, stringUtils } from "@dbx-tools/shared-core";
 import { MODEL_ENV, SERVING_ENDPOINT_ENV, WEB_SEARCH_CONFIG_SCHEMA, } from "./config.js";
-import { runWebFetch } from "./fetch.js";
+import { runWebAssetPageFetch, runWebFetch, runWebImageFetch, } from "./fetch.js";
 import { createWebSearchRuntime } from "./runtime.js";
 import { webFetchRequestSchema, webSearchToolRequestSchema, WEB_FETCH_TOOL_DESCRIPTION, WEB_SEARCH_TOOL_DESCRIPTION, } from "./schema.js";
 import { resolveWebSearchContext, runWebSearch } from "./search.js";
@@ -181,6 +181,10 @@ export class WebSearchPlugin extends ToolRegistryPlugin {
              * configured URL policy.
              */
             fetch: (request, signal) => this.fetch(request, signal),
+            /** Fetch expanded HTML for in-process asset discovery. */
+            fetchAssetPage: (request, signal) => runWebAssetPageFetch(request, this.runtime, signal),
+            /** Fetch one image for in-process visual research. */
+            fetchImage: (request, signal) => runWebImageFetch(request, this.runtime, signal),
         };
     }
     async search(request, signal, writeProgress) {
@@ -216,4 +220,4 @@ export class WebSearchPlugin extends ToolRegistryPlugin {
  * ```
  */
 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 its tools read. Registering it resolves and logs the\n * effective config (which URL policy is in force, the caps) so a\n * misconfiguration is visible in the boot logs rather than on the first\n * search. The plugin's `execute()` is captured by its own runtime so every\n * outbound call picks up 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. App-integrated\n * Mastra agents consume this provider through `plugins[\"web-search\"].toolkit()`;\n * standalone factories in `tool.ts` use their own explicit runtime or config.\n *\n * @module\n */\n\nimport {\n  ResourceType,\n  toPlugin,\n  type PluginManifest,\n  type ResourceRequirement,\n} from \"@databricks/appkit\";\nimport { defineTool, type ToolRegistry } from \"@databricks/appkit/beta\";\nimport { ToolRegistryPlugin } from \"@dbx-tools/appkit\";\nimport type { AgentToolExecutionContext } from \"@dbx-tools/appkit/tool-provider\";\nimport { log, stringUtils } from \"@dbx-tools/shared-core\";\nimport {\n  MODEL_ENV,\n  SERVING_ENDPOINT_ENV,\n  WEB_SEARCH_CONFIG_SCHEMA,\n  type WebSearchPluginConfig,\n} from \"./config.ts\";\nimport { runWebFetch } from \"./fetch.ts\";\nimport { createWebSearchRuntime, type WebSearchRuntime } from \"./runtime.ts\";\nimport {\n  webFetchRequestSchema,\n  webSearchToolRequestSchema,\n  WEB_FETCH_TOOL_DESCRIPTION,\n  WEB_SEARCH_TOOL_DESCRIPTION,\n} from \"./schema.ts\";\nimport type {\n  WebFetchRequest,\n  WebFetchResult,\n  WebSearchRequest,\n  WebSearchResult,\n} from \"./schema.ts\";\nimport { resolveWebSearchContext, runWebSearch } from \"./search.ts\";\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 { webSearch } from \"@dbx-tools/appkit-web-search\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     webSearch({\n *       model: \"gemini\",\n *       urlPolicy: \"allowlist\",\n *       allowedUrls: [\"*.databricks.com\"],\n *     }),\n *   ],\n * });\n * ```\n */\nexport class WebSearchPlugin extends ToolRegistryPlugin<WebSearchPluginConfig> {\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  /** Runtime owned exclusively by this plugin instance. */\n  private readonly runtime: WebSearchRuntime = createWebSearchRuntime(this.config, (fn, settings) =>\n    this.execute(fn, settings),\n  );\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      stringUtils.trimToNull(config.model) ??\n      stringUtils.trimToNull(process.env[MODEL_ENV]) ??\n      stringUtils.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  protected readonly toolRegistry: ToolRegistry = {\n    web_search: defineTool({\n      description: WEB_SEARCH_TOOL_DESCRIPTION,\n      schema: webSearchToolRequestSchema,\n      annotations: { effect: \"read\", requiresUserContext: true },\n      autoInheritable: false,\n      execute: async (args, signal) => this.search(webSearchToolRequestSchema.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  /** Dispatch with the actual calling model and optional host progress sink. */\n  override executeAgentTool(\n    name: string,\n    args: unknown,\n    signal?: AbortSignal,\n    context?: AgentToolExecutionContext,\n  ): Promise<unknown> {\n    if (name !== \"web_search\") return super.executeAgentTool(name, args, signal, context);\n    const request = webSearchToolRequestSchema.parse(args);\n    return this.search(\n      {\n        ...request,\n        ...(context?.model ? { model: context.model } : {}),\n      },\n      signal,\n      context?.writeProgress,\n    );\n  }\n\n  /**\n   * Log the effective policy so an active allow-list and caps are obvious at\n   * boot. Runtime construction already resolved config and captured this\n   * plugin's interceptor chain.\n   */\n  override async setup(): Promise<void> {\n    const { config } = this.runtime;\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   * No runtime resources require draining. The instance-owned config and\n   * executor become unreachable with this plugin.\n   */\n  shutdown(): void {\n    return;\n  }\n\n  /** Abort in-flight work owned by this plugin instance. */\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\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 this plugin's\n       * runtime config.\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.\n       */\n      fetch: (request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult> =>\n        this.fetch(request, signal),\n    };\n  }\n\n  private async search(\n    request: WebSearchRequest,\n    signal?: AbortSignal,\n    writeProgress?: AgentToolExecutionContext[\"writeProgress\"],\n  ): Promise<WebSearchResult> {\n    return runWebSearch(\n      request,\n      this.runtime,\n      await resolveWebSearchContext(),\n      signal,\n      writeProgress,\n    );\n  }\n\n  private async fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult> {\n    return runWebFetch(request, this.runtime, 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 { webSearch } from \"@dbx-tools/appkit-web-search\";\n * import { agents, mastra } 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 *   async tools(plugins) {\n *     return { ...(await plugins[\"web-search\"].toolkit()) };\n *   },\n * });\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     webSearch({ model: \"gemini\" }),\n *     mastra({ agents: researcher }),\n *   ],\n * });\n * ```\n */\nexport const webSearch = toPlugin(WebSearchPlugin);\n"]}
+//# 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 its tools read. Registering it resolves and logs the\n * effective config (which URL policy is in force, the caps) so a\n * misconfiguration is visible in the boot logs rather than on the first\n * search. The plugin's `execute()` is captured by its own runtime so every\n * outbound call picks up 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. App-integrated\n * Mastra agents consume this provider through `plugins[\"web-search\"].toolkit()`;\n * standalone factories in `tool.ts` use their own explicit runtime or config.\n *\n * @module\n */\n\nimport {\n  ResourceType,\n  toPlugin,\n  type PluginManifest,\n  type ResourceRequirement,\n} from \"@databricks/appkit\";\nimport { defineTool, type ToolRegistry } from \"@databricks/appkit/beta\";\nimport { ToolRegistryPlugin } from \"@dbx-tools/appkit\";\nimport type { AgentToolExecutionContext } from \"@dbx-tools/appkit/tool-provider\";\nimport { log, stringUtils } from \"@dbx-tools/shared-core\";\nimport {\n  MODEL_ENV,\n  SERVING_ENDPOINT_ENV,\n  WEB_SEARCH_CONFIG_SCHEMA,\n  type WebSearchPluginConfig,\n} from \"./config.ts\";\nimport {\n  runWebAssetPageFetch,\n  runWebFetch,\n  runWebImageFetch,\n  type WebAssetPageFetchRequest,\n  type WebImageFetchRequest,\n  type WebImageFetchResult,\n} from \"./fetch.ts\";\nimport { createWebSearchRuntime, type WebSearchRuntime } from \"./runtime.ts\";\nimport {\n  webFetchRequestSchema,\n  webSearchToolRequestSchema,\n  WEB_FETCH_TOOL_DESCRIPTION,\n  WEB_SEARCH_TOOL_DESCRIPTION,\n} from \"./schema.ts\";\nimport type {\n  WebFetchRequest,\n  WebFetchResult,\n  WebSearchRequest,\n  WebSearchResult,\n} from \"./schema.ts\";\nimport { resolveWebSearchContext, runWebSearch } from \"./search.ts\";\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 { webSearch } from \"@dbx-tools/appkit-web-search\";\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     webSearch({\n *       model: \"gemini\",\n *       urlPolicy: \"allowlist\",\n *       allowedUrls: [\"*.databricks.com\"],\n *     }),\n *   ],\n * });\n * ```\n */\nexport class WebSearchPlugin extends ToolRegistryPlugin<WebSearchPluginConfig> {\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  /** Runtime owned exclusively by this plugin instance. */\n  private readonly runtime: WebSearchRuntime = createWebSearchRuntime(this.config, (fn, settings) =>\n    this.execute(fn, settings),\n  );\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      stringUtils.trimToNull(config.model) ??\n      stringUtils.trimToNull(process.env[MODEL_ENV]) ??\n      stringUtils.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  protected readonly toolRegistry: ToolRegistry = {\n    web_search: defineTool({\n      description: WEB_SEARCH_TOOL_DESCRIPTION,\n      schema: webSearchToolRequestSchema,\n      annotations: { effect: \"read\", requiresUserContext: true },\n      autoInheritable: false,\n      execute: async (args, signal) => this.search(webSearchToolRequestSchema.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  /** Dispatch with the actual calling model and optional host progress sink. */\n  override executeAgentTool(\n    name: string,\n    args: unknown,\n    signal?: AbortSignal,\n    context?: AgentToolExecutionContext,\n  ): Promise<unknown> {\n    if (name !== \"web_search\") return super.executeAgentTool(name, args, signal, context);\n    const request = webSearchToolRequestSchema.parse(args);\n    return this.search(\n      {\n        ...request,\n        ...(context?.model ? { model: context.model } : {}),\n      },\n      signal,\n      context?.writeProgress,\n    );\n  }\n\n  /**\n   * Log the effective policy so an active allow-list and caps are obvious at\n   * boot. Runtime construction already resolved config and captured this\n   * plugin's interceptor chain.\n   */\n  override async setup(): Promise<void> {\n    const { config } = this.runtime;\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   * No runtime resources require draining. The instance-owned config and\n   * executor become unreachable with this plugin.\n   */\n  shutdown(): void {\n    return;\n  }\n\n  /** Abort in-flight work owned by this plugin instance. */\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\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 this plugin's\n       * runtime config.\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.\n       */\n      fetch: (request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult> =>\n        this.fetch(request, signal),\n      /** Fetch expanded HTML for in-process asset discovery. */\n      fetchAssetPage: (\n        request: WebAssetPageFetchRequest,\n        signal?: AbortSignal,\n      ): Promise<WebFetchResult> => runWebAssetPageFetch(request, this.runtime, signal),\n      /** Fetch one image for in-process visual research. */\n      fetchImage: (\n        request: WebImageFetchRequest,\n        signal?: AbortSignal,\n      ): Promise<WebImageFetchResult> => runWebImageFetch(request, this.runtime, signal),\n    };\n  }\n\n  private async search(\n    request: WebSearchRequest,\n    signal?: AbortSignal,\n    writeProgress?: AgentToolExecutionContext[\"writeProgress\"],\n  ): Promise<WebSearchResult> {\n    return runWebSearch(\n      request,\n      this.runtime,\n      await resolveWebSearchContext(),\n      signal,\n      writeProgress,\n    );\n  }\n\n  private async fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult> {\n    return runWebFetch(request, this.runtime, 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 { webSearch } from \"@dbx-tools/appkit-web-search\";\n * import { agents, mastra } 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 *   async tools(plugins) {\n *     return { ...(await plugins[\"web-search\"].toolkit()) };\n *   },\n * });\n *\n * await createApp({\n *   plugins: [\n *     server(),\n *     webSearch({ model: \"gemini\" }),\n *     mastra({ agents: researcher }),\n *   ],\n * });\n * ```\n */\nexport const webSearch = toPlugin(WebSearchPlugin);\n"]}

package/lib/src/runtime.d.ts

@@ -23,6 +23,10 @@ export interface WebSearchRuntime {
     execute: WebSearchExecutor;
     /** Provider-family cooldown deadlines learned from workspace failures. */
     familyCooldowns: Map<policy.ModelFamily, number>;
+    /** Provider families that completed a native search successfully. */
+    availableFamilies: Set<policy.ModelFamily>;
+    /** First native request currently establishing one family's availability. */
+    familyProbes: Map<policy.ModelFamily, Promise<void>>;
 }
 /** Runtime-aware operation input, retaining resolved-config compatibility. */
 export type WebSearchRuntimeInput = WebSearchRuntime | ResolvedWebSearchConfig;
@@ -44,4 +48,4 @@ export declare function setWebSearchExecutor(runtime: WebSearchRuntime, execute:
  * 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>(runtime: WebSearchRuntime, operation: string, settings: WebSearchExecutionSettings, fn: (signal?: AbortSignal) => Promise<T>, signal?: AbortSignal): Promise<T>;
+export declare function executeRead<T>(runtime: WebSearchRuntime, operation: string, settings: WebSearchExecutionSettings, fn: (signal?: AbortSignal) => Promise<T>, signal?: AbortSignal, logFailure?: boolean): Promise<T>;

package/lib/src/runtime.js

@@ -19,11 +19,23 @@ const logger = log.logger("web-search/runtime");
 const directExecute = execution.directExecutor();
 /** Build an isolated runtime for one plugin instance or standalone tool set. */
 export function createWebSearchRuntime(overrides, execute = directExecute) {
-    return { config: resolveWebSearchConfig(overrides), execute, familyCooldowns: new Map() };
+    return {
+        config: resolveWebSearchConfig(overrides),
+        execute,
+        familyCooldowns: new Map(),
+        availableFamilies: new Set(),
+        familyProbes: new Map(),
+    };
 }
 /** Build an isolated runtime from config that has already been resolved. */
 export function createResolvedWebSearchRuntime(config, execute = directExecute) {
-    return { config, execute, familyCooldowns: new Map() };
+    return {
+        config,
+        execute,
+        familyCooldowns: new Map(),
+        availableFamilies: new Set(),
+        familyProbes: new Map(),
+    };
 }
 /** Normalize an explicit runtime or legacy resolved config for one operation. */
 export function toWebSearchRuntime(input) {
@@ -43,10 +55,10 @@ export function setWebSearchExecutor(runtime, execute) {
  * 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(runtime, operation, settings, fn, signal) {
+export async function executeRead(runtime, operation, settings, fn, signal, logFailure = true) {
     return pluginExecution.runPluginExecution({
         plugin: "web-search",
-        logger,
+        logger: logFailure ? logger : { warn() { } },
         operation,
         settings,
         execute: runtime.execute,
@@ -54,4 +66,4 @@ export async function executeRead(runtime, operation, settings, fn, signal) {
         signal,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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