@dbx-tools/appkit-web-search 0.9.131 → 0.9.136

package/README.md

@@ -1,15 +1,13 @@
 # @dbx-tools/appkit-web-search
 
-Server-side web-search runtime, Mastra tools, and AppKit plugin.
-
 Add `web_search` and `web_fetch` to an AppKit or Mastra backend. `web_search`
 runs on the
 [Databricks Model Serving native web-search tool](https://docs.databricks.com/aws/en/machine-learning/model-serving/web-search):
 the model searches the web server-side and returns a synthesized answer plus the
-sources it used - no third-party search API key. `web_fetch` reads a single page
-through [`got-scraping`](https://www.npmjs.com/package/got-scraping).
+sources it used without a third-party search API key. `web_fetch` reads a single page
+through [got-scraping](https://www.npmjs.com/package/got-scraping).
 
-## Quick Start
+## Quick start
 
 Register the plugin and give its tools to an agent:
 
@@ -30,7 +28,7 @@ await createApp({
 });
 ```
 
-**Key features:**
+Registration provides:
 
 - AppKit plugin registration that resolves and logs the effective policy at boot.
 - Two Mastra tools: `web_search` (answer + citations) and `web_fetch` (page
@@ -39,13 +37,13 @@ await createApp({
 - `web_search` resolves a dedicated web-search-capable model - defaulting to Gemini,
   then GPT - independently of the calling agent's chat model (which may not
   support web search). Loose names (`"gemini"`, `"gpt"`) fuzzy-match the live
-  catalogue via [`@dbx-tools/model`](../model).
+  catalogue through [@dbx-tools/model](../model).
 - A built-in provider -> request-fragment map (OpenAI Responses API
   `{"tools":[{"type":"web_search"}]}`, Gemini Chat Completions
   `{"google_search":{}}`),
-  overridable per provider via the `WEB_SEARCH_TOOLS` setting.
-- A named URL policy (`allowlist` or `unrestricted`) over a glob allow-list
-  built on [`@dbx-tools/path`](../path)'s `match` matcher: `web_search` silently
+  overridable per provider with the `WEB_SEARCH_TOOLS` setting.
+- A named URL policy (`allowlist` or `unrestricted`) over a glob allowlist
+  built on [@dbx-tools/path](../path)'s `match` matcher: `web_search` silently
   filters disallowed citations, `web_fetch` refuses a disallowed URL, and the
   mode in force is logged at boot.
 - Per-tool approval gating: gate every call, or (for `web_fetch`) only calls
@@ -57,18 +55,24 @@ await createApp({
 - Page and fallback-result HTML use parser-backed text conversion and selectors,
   including complete HTML entity decoding and malformed-markup recovery.
 
-## Use With Native AppKit
+## Choose a web provider
 
 AppKit has no first-party web-search or page-fetch surface. Use this package when
 an agent needs to look things up on the open web or read a URL the user pasted,
-with a policy layer (allow-list + optional approval) around it so a deployment
-controls which sites are reachable and which calls pause for a human. Crucially,
-the web-search tool resolves its own web-search-capable model, so an agent
+with a policy layer (allowlist + optional approval) around it so a deployment
+controls which sites are reachable and which calls pause for a human. The
+web-search tool resolves its own web-search-capable model, so an agent
 running on any chat model (including one without web search) can still search. It
-is a thin add-on in the same shape as [`@dbx-tools/email`](../email): a Mastra
-tool pair plus an AppKit plugin.
+provides a Mastra tool pair and an AppKit plugin, like
+[@dbx-tools/email](../email).
+
+Use native Databricks web search when a supported GPT or Gemini endpoint is
+deployed. Use the DuckDuckGo scrape fallback only when no capable endpoint is
+available and unsynthesized search results are acceptable. Use `web_fetch` for a
+specific public HTTPS page. For indexed application data, use
+[@dbx-tools/search](../search) instead.
 
-## Configure The AppKit Plugin
+## Configure the AppKit plugin
 
 ```ts
 import { createApp, lakebase, server } from "@databricks/appkit";
@@ -101,7 +105,7 @@ the native plugin toolkit as shown above, which preserves that plugin's policy,
 OBO scope, and AppKit execution chain. Approval, when enabled, requires Mastra
 storage, so register `lakebase()` or configure storage in the Mastra plugin.
 
-The plugin is also an AppKit `ToolProvider`, so a simple native code agent can
+The plugin is also an AppKit `ToolProvider`, so a native code agent can
 take the same two tools without Mastra. Put the definition at
 `server/agents/researcher/agent.ts` so AppKit discovers it:
 
@@ -132,16 +136,16 @@ Both tools are annotated `effect: "read"` and require user context, and neither
 is auto-inheritable: an agent has to ask for them, because `web_fetch` reaches
 whatever URL the model produces.
 
-Native volume skills currently execute as the service principal; the 0.81
+Native volume skills run as the service principal. The 0.81
 `skillCredentialMode: "obo"` option is not wired. Keep request-scoped writable
 skills, remote sources, asynchronous Graphiti discovery, Sandbox/Monty,
 Mastra memory, and durable approvals on `@dbx-tools/appkit-mastra`.
 
-## Choose The Web-Search Model
+## Choose the web-search model
 
 The native web-search tool only runs on certain models, and it is provider-
 specific. This package resolves deployed endpoints through
-[`@dbx-tools/model`](../model) and applies this order:
+[@dbx-tools/model](../model) and applies this order:
 
 1. Highest-ranked web-search-capable **Gemini**.
 2. Without Gemini, a capable **GPT** matching the calling/requested model.
@@ -159,26 +163,26 @@ Serving binding, and it is the field the plugin declares in its manifest, so
 The request's `model`, plugin `model`, and environment model values are used to
 match the calling GPT after Gemini availability is checked.
 When the tool runs through `@dbx-tools/appkit-mastra`, the host injects the
-actual resolved chat model, overriding any different model argument generated
+resolved chat model, overriding any different model argument generated
 by the LLM.
 
-Model resolution runs against the LIVE workspace catalogue (via
-[`@dbx-tools/model`](../model)), so it only ever picks an endpoint that is
+Model resolution runs against the live workspace catalogue through
+[@dbx-tools/model](../model), so it only picks an endpoint that is
 actually deployed - a configured id that doesn't exist is never called.
 
-### Scrape Fallback
+### Scrape fallback
 
-The native tool is always preferred. But when the workspace has NO deployed
+The native tool is preferred. When the workspace has no deployed
 GPT/Gemini endpoint (so native web search can't run at all), the tool falls
-back to a DuckDuckGo scrape (via `got-scraping`) so it still returns results
+back to a DuckDuckGo scrape using `got-scraping` so it still returns results
 instead of erroring. Fallback results set `model` to `"scrape:duckduckgo"` and
 carry the substance in `citations` (there is no model synthesizing an answer,
-so `answer` is a lead-in over the top results). It is enabled by default; set
+so `answer` is a lead-in over the top results). It is enabled by default. Set
 `scrapeFallback: false` (or `WEB_SEARCH_SCRAPE_FALLBACK=0`) to require a native
 model and error when none is deployed.
 
-The right provider request fragment is selected automatically from the resolved model:
-OpenAI GPT uses the Responses API `{"tools":[{"type":"web_search"}]}`; Gemini
+The plugin selects the provider request fragment from the resolved model:
+OpenAI GPT uses the Responses API `{"tools":[{"type":"web_search"}]}`. Gemini
 uses the top-level Chat Completions field `{"google_search":{}}`. Override or extend that map per provider with
 the `webSearchTools` setting (env `WEB_SEARCH_TOOLS`, JSON) as the platform
 evolves:
@@ -190,7 +194,7 @@ plugin.webSearch({
 });
 ```
 
-## Search And Fetch Without An Agent
+## Search and fetch without an agent
 
 ```ts
 import { search, fetch, runtime, tool } from "@dbx-tools/appkit-web-search";
@@ -217,7 +221,7 @@ const page = await fetch.runWebFetch({ url: result.citations[0]!.url, format: "t
 
 Use direct calls for operational lookups, tests, or admin flows where a model is
 not involved. Standalone Mastra tool factories likewise accept `runtime` or
-`config`; they never discover or attach to a process-global plugin:
+`config`. They never discover or attach to a process-global plugin:
 
 ```ts
 const webRuntime = runtime.createWebSearchRuntime({
@@ -233,7 +237,7 @@ const tools = {
 Pass the runtime explicitly or provide the executor to
 `createWebSearchRuntime`.
 
-## Restrict Which URLs Are Reachable
+## Restrict reachable URLs
 
 ```ts
 import { allowlist } from "@dbx-tools/appkit-web-search";
@@ -246,9 +250,9 @@ list.allows("https://docs.databricks.com/aws/en/index.html"); // true
 list.allows("https://evil.example.com/"); // false
 ```
 
-Each entry is a glob compiled by [`@dbx-tools/path`](../path)'s `match` matcher.
-A host entry (no path, e.g. `databricks.com` or `*.databricks.com`) matches the
-URL's hostname, and a bare host also matches its subdomains; a path entry
+Each entry is a glob compiled by [@dbx-tools/path](../path)'s `match` matcher.
+A host entry (no path, for example `databricks.com` or `*.databricks.com`) matches the
+URL's hostname, and a bare host also matches its subdomains. A path entry
 (`docs.example.com/api/**`) matches host + pathname. Enforcement is asymmetric by
 design: `web_search` citations are silently filtered to the permitted set (the
 model never surfaces a source it then can't fetch), while an explicit `web_fetch`
@@ -277,10 +281,10 @@ plugin.webSearch({ urlPolicy: "unrestricted" });
 plugin.webSearch({ urlPolicy: "allowlist", allowedUrls: ["*.databricks.com"] });
 ```
 
-## Gate Calls For Approval
+## Gate calls for approval
 
 Both tools run without approval by default. Pass `approval` to a tool (or set it
-plugin-wide) to require a human click. `true` gates every call; a URL pattern (or
+plugin-wide) to require approval. `true` gates every call. A URL pattern (or
 list) gates only calls whose URL matches - a `web_fetch` is evaluated precisely
 against its target URL, while a `web_search` (whose result URLs are unknown
 before the call) treats a pattern gate as "gate every call".
@@ -307,7 +311,7 @@ tool.webFetchTool({ config: { approval: ["*.internal.example.com"] } });
 Every spelling normalizes to one of three modes - `{ mode: "none" }`,
 `{ mode: "always" }`, `{ mode: "urls", patterns }` - which is what the resolved
 config carries and the boot log reports. Approval uses the same glob syntax as
-the allow-list, so the two policies read identically.
+the allowlist, so the two policies read identically.
 
 ## Configuration
 
@@ -334,7 +338,7 @@ built-in default.
 | `WEB_SEARCH_MODEL`                 | `model` (dedicated override, wins over the binding below)         |
 | `DATABRICKS_SERVING_ENDPOINT_NAME` | `model` (AppKit's Model Serving binding, treated as a preference) |
 | `WEB_SEARCH_MODEL_FALLBACKS`       | `modelFallbacks` (comma/space-separated)                          |
-| `WEB_SEARCH_TOOLS`                 | `webSearchTools` (JSON object; anything else fails at boot)       |
+| `WEB_SEARCH_TOOLS`                 | `webSearchTools` (JSON object. Any other value fails at boot.)    |
 | `WEB_SEARCH_FUZZY`                 | `modelFuzzyMatch`                                                 |
 | `WEB_SEARCH_FUZZY_THRESHOLD`       | `modelFuzzyThreshold`                                             |
 | `WEB_SEARCH_MAX_CITATIONS`         | `maxCitations`                                                    |
@@ -355,10 +359,10 @@ TTLs and retry budgets and why each was chosen.
 
 OpenAI Responses web searches stream native search, page-read, and completion
 status through the Mastra tool writer. The common tool-session pill updates
-while the search runs; the completed Responses payload remains the tool result.
+while the search runs. The completed Responses payload remains the tool result.
 
 Requirements: the native web-search tool runs on pay-per-token GPT / Gemini
-serving endpoints with cross-region processing enabled; it is unavailable on
+serving endpoints with cross-region processing enabled. It is unavailable on
 provisioned throughput, for external models, or under HIPAA/BAA compliance. See
 the [Databricks docs](https://docs.databricks.com/aws/en/machine-learning/model-serving/web-search).
 
@@ -381,9 +385,9 @@ the [Databricks docs](https://docs.databricks.com/aws/en/machine-learning/model-
   and `executeRead()`.
 - `config` - config types, JSON schema, `resolveWebSearchConfig()`, URL policy
   and approval helpers.
-- `allowlist` - URL allow-list parsing/compiling on top of `@dbx-tools/path`.
+- `allowlist` - URL allowlist parsing/compiling on top of `@dbx-tools/path`.
 - `schema` - zod tool contracts and inferred types.
 
-Pair this package with [`@dbx-tools/appkit-mastra`](../appkit-mastra) to spread
-the tools into an agent (and resolve its own model via [`@dbx-tools/model`](../model)),
-and [`@dbx-tools/email`](../email) for the sibling approval-gated tool pattern.
+Pair this package with [@dbx-tools/appkit-mastra](../appkit-mastra) to add
+the tools to an agent and resolve its model through [@dbx-tools/model](../model).
+Use [@dbx-tools/email](../email) for the sibling approval-gated tool pattern.

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.131";
+export const PACKAGE_VERSION = "0.9.136";
 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.131";
+export declare const PACKAGE_VERSION = "0.9.136";
 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.131";
+export const PACKAGE_VERSION = "0.9.136";
 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;