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

package/lib/src/config.js

@@ -0,0 +1,269 @@
+/**
+ * Configuration for the web-search plugin: the typed
+ * {@link WebSearchPluginConfig} (the plugin's slice of AppKit config), the
+ * JSON Schema the manifest publishes for it, and {@link resolveWebSearchConfig}
+ * which layers that config over environment defaults into the concrete
+ * {@link ResolvedWebSearchConfig} the runtime + tools read.
+ *
+ * `web_search` runs on the Databricks Model Serving native web-search tool
+ * (see `provider.ts` / `search.ts`), so the key knob is which web-search-
+ * capable model to use. It resolves independently of the calling agent's chat
+ * model: `model` (a name, loose name, or capability class) is fuzzy-matched
+ * against the workspace catalogue, and when nothing is pinned the
+ * {@link WebSearchPluginConfig.modelFallbacks} order (Gemini, then GPT, then a
+ * repo floor) picks the first web-search-capable endpoint that exists.
+ *
+ * Which endpoint id is used follows the standard precedence - explicit plugin
+ * config, then environment, then a default - with two environment sources:
+ *
+ *   1. `model` in plugin config;
+ *   2. `WEB_SEARCH_MODEL`, the dedicated override, so a deployment can point
+ *      web search at a different endpoint than the agent's chat model;
+ *   3. `DATABRICKS_SERVING_ENDPOINT_NAME`, AppKit's standard name for a
+ *      Model Serving binding, honored so the resource declared in the manifest
+ *      wires this plugin up like any other. Because that binding is shared
+ *      with whatever else the app serves, it is treated as a preference: an
+ *      endpoint that cannot run the native web-search tool is skipped in
+ *      favor of {@link WebSearchPluginConfig.modelFallbacks} rather than
+ *      failing the call. A pin from (1) or (2) is explicit and DOES fail;
+ *   4. otherwise the fallback order, resolved against the live catalogue.
+ *
+ * Which model wins is decided lazily, at call time, against the live
+ * catalogue. Resolution here is eager about everything else and fails loudly
+ * on a contradiction: an unparseable `WEB_SEARCH_TOOLS`, an unknown
+ * {@link UrlPolicyMode}, or a URL policy that disagrees with the allow-list it
+ * was given.
+ *
+ * Env fallbacks: `WEB_SEARCH_MODEL`, `DATABRICKS_SERVING_ENDPOINT_NAME`,
+ * `WEB_SEARCH_MODEL_FALLBACKS`, `WEB_SEARCH_TOOLS` (JSON),
+ * `WEB_SEARCH_URL_POLICY`, `WEB_SEARCH_ALLOWED_URLS`,
+ * `WEB_SEARCH_MAX_CITATIONS`, `WEB_SEARCH_FETCH_MAX_LENGTH`,
+ * `WEB_SEARCH_TIMEOUT_MS`, `WEB_SEARCH_SCRAPE_FALLBACK`, `WEB_SEARCH_FUZZY`,
+ * `WEB_SEARCH_FUZZY_THRESHOLD`.
+ *
+ * @module
+ */
+import { ConfigurationError } from "@databricks/appkit";
+import { serving } from "@dbx-tools/model";
+import { json, object, string } from "@dbx-tools/shared-core";
+import { parseAllowedUrls, toUrlAllowList } from "./allowlist.js";
+/** Dedicated override for the web-search endpoint id. */
+export const MODEL_ENV = "WEB_SEARCH_MODEL";
+/** AppKit's standard environment name for a Model Serving endpoint binding. */
+export const SERVING_ENDPOINT_ENV = "DATABRICKS_SERVING_ENDPOINT_NAME";
+/**
+ * Default web-search model preference, tried in order when no model is
+ * pinned. Gemini first, then GPT - both support the native web-search tool;
+ * a workspace typically has at least one. Each is fuzzy-matched against the
+ * live catalogue, so a close variant (e.g. `databricks-gemini-3-1-pro`) is
+ * picked when the exact id isn't present.
+ */
+export const DEFAULT_MODEL_FALLBACKS = [
+    "databricks-gemini-3-pro",
+    "databricks-gemini-2-5-pro",
+    "databricks-gpt-5",
+    "databricks-gpt-5-mini",
+];
+/** Default cap on the number of citations returned from a single search. */
+export const DEFAULT_MAX_CITATIONS = 10;
+/** Default cap on characters returned from a single `web_fetch`. */
+export const DEFAULT_FETCH_MAX_LENGTH = 50_000;
+/** Default per-request network timeout (ms) for search + fetch. */
+export const DEFAULT_TIMEOUT_MS = 30_000;
+/** JSON Schema published on the manifest's `config.schema`. */
+export const WEB_SEARCH_CONFIG_SCHEMA = {
+    type: "object",
+    properties: {
+        model: {
+            type: "string",
+            description: "Default web-search model (endpoint name, loose name, or class). Fuzzy-matched. Env: WEB_SEARCH_MODEL, then DATABRICKS_SERVING_ENDPOINT_NAME.",
+        },
+        modelFallbacks: {
+            type: "array",
+            items: { type: "string" },
+            description: "Ordered web-search model candidates when `model` is unset (Gemini, then GPT). Env: WEB_SEARCH_MODEL_FALLBACKS.",
+        },
+        webSearchTools: {
+            type: "object",
+            description: 'Provider -> tool-spec override map merged over the built-in defaults (openai -> {"type":"web_search"}, gemini -> {"google_search":{}}). Env: WEB_SEARCH_TOOLS (JSON).',
+        },
+        modelFuzzyMatch: {
+            type: "boolean",
+            description: "Fuzzy-match loose model names against the live catalogue. Default true (env: WEB_SEARCH_FUZZY).",
+        },
+        modelFuzzyThreshold: {
+            type: "number",
+            description: "Fuse.js score threshold below which a fuzzy model match is accepted (env: WEB_SEARCH_FUZZY_THRESHOLD).",
+        },
+        maxCitations: {
+            type: "number",
+            description: "Hard cap on citations returned (env: WEB_SEARCH_MAX_CITATIONS).",
+        },
+        fetchMaxLength: {
+            type: "number",
+            description: "Hard cap on web_fetch content length (env: WEB_SEARCH_FETCH_MAX_LENGTH).",
+        },
+        timeoutMs: {
+            type: "number",
+            description: "Per-request network timeout in ms (env: WEB_SEARCH_TIMEOUT_MS).",
+        },
+        scrapeFallback: {
+            type: "boolean",
+            description: "Fall back to a DuckDuckGo scrape when no web-search-capable model is deployed. Default true (env: WEB_SEARCH_SCRAPE_FALLBACK).",
+        },
+        urlPolicy: {
+            type: "string",
+            enum: ["unrestricted", "allowlist"],
+            description: "Which URLs the tools may reach. Defaults to allowlist when allowedUrls has entries, else unrestricted (env: WEB_SEARCH_URL_POLICY).",
+        },
+        allowedUrls: {
+            type: "array",
+            items: { type: "string" },
+            description: 'URL allow-list of globs / bare hosts (e.g. "*.databricks.com", "docs.example.com"). Also accepts a comma/space-separated string. Falls back to WEB_SEARCH_ALLOWED_URLS. Empty = unrestricted.',
+        },
+        approval: {
+            description: 'Approval gate for both tools: true gates every call, a glob (or list of globs) gates only matching URLs, or state the mode directly as {"mode":"none"|"always"|"urls"}. Default none.',
+            oneOf: [
+                { type: "boolean" },
+                { type: "string" },
+                { type: "array", items: { type: "string" } },
+                {
+                    type: "object",
+                    properties: {
+                        mode: { type: "string", enum: ["none", "always", "urls"] },
+                        patterns: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["mode"],
+                },
+            ],
+        },
+    },
+};
+/** Parse a positive integer env/config value, else the fallback. */
+function resolvePositiveInt(value, envKey, fallback) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0)
+        return Math.floor(value);
+    const env = Number(process.env[envKey]);
+    return Number.isFinite(env) && env > 0 ? Math.floor(env) : fallback;
+}
+/**
+ * Parse the `WEB_SEARCH_TOOLS` env var (JSON object), else `{}`. A value that
+ * is set but not a JSON object is a deployment mistake that would otherwise
+ * silently leave the built-in tool specs in place, so it throws.
+ */
+function parseToolsEnv() {
+    const raw = string.trimToNull(process.env.WEB_SEARCH_TOOLS);
+    if (raw === null)
+        return {};
+    const parsed = json.parseRecord(raw);
+    if (!parsed) {
+        throw new ConfigurationError("WEB_SEARCH_TOOLS must be a JSON object mapping a provider family to its tool spec", { context: { envVar: "WEB_SEARCH_TOOLS" } });
+    }
+    return parsed;
+}
+/** Read the pinned endpoint id and record which source supplied it. */
+function resolveModelPin(config) {
+    const fromConfig = string.trimToNull(config.model);
+    if (fromConfig !== null)
+        return { model: fromConfig, source: "config" };
+    const fromModelEnv = string.trimToNull(process.env[MODEL_ENV]);
+    if (fromModelEnv !== null)
+        return { model: fromModelEnv, source: MODEL_ENV };
+    const fromResourceEnv = string.trimToNull(process.env[SERVING_ENDPOINT_ENV]);
+    if (fromResourceEnv !== null)
+        return { model: fromResourceEnv, source: SERVING_ENDPOINT_ENV };
+    return { source: "none" };
+}
+/**
+ * Resolve the named {@link UrlPolicyMode}, failing on a stated mode that
+ * contradicts the allow-list entries it was given.
+ */
+function resolveUrlPolicy(configured, patterns) {
+    const raw = configured ?? string.trimToNull(process.env.WEB_SEARCH_URL_POLICY) ?? undefined;
+    if (raw === undefined)
+        return patterns.length > 0 ? "allowlist" : "unrestricted";
+    if (raw !== "allowlist" && raw !== "unrestricted") {
+        throw new ConfigurationError('urlPolicy must be "allowlist" or "unrestricted" (env: WEB_SEARCH_URL_POLICY)', { context: { field: "urlPolicy", envVar: "WEB_SEARCH_URL_POLICY" } });
+    }
+    if (raw === "allowlist" && patterns.length === 0) {
+        throw new ConfigurationError('urlPolicy "allowlist" needs at least one entry in allowedUrls (env: WEB_SEARCH_ALLOWED_URLS)', { context: { field: "allowedUrls", envVar: "WEB_SEARCH_ALLOWED_URLS" } });
+    }
+    if (raw === "unrestricted" && patterns.length > 0) {
+        throw new ConfigurationError('urlPolicy "unrestricted" cannot be combined with allowedUrls entries; drop the entries or set urlPolicy to "allowlist"', { context: { field: "allowedUrls", envVar: "WEB_SEARCH_ALLOWED_URLS" } });
+    }
+    return raw;
+}
+/**
+ * Normalize any accepted approval spelling into an {@link ApprovalPolicy}.
+ * A pattern gate with no usable patterns collapses to `"none"` rather than
+ * gating everything, so a blank env var can never wedge the tools behind an
+ * approval nobody configured.
+ */
+export function toApprovalPolicy(gate) {
+    if (gate === undefined || gate === false)
+        return { mode: "none" };
+    if (gate === true)
+        return { mode: "always" };
+    if (object.isRecord(gate) && "mode" in gate) {
+        if (gate.mode === "urls") {
+            const patterns = parseAllowedUrls([...gate.patterns]);
+            return patterns.length > 0 ? { mode: "urls", patterns } : { mode: "none" };
+        }
+        if (gate.mode === "always" || gate.mode === "none")
+            return { mode: gate.mode };
+        throw new ConfigurationError('approval mode must be "none", "always" or "urls"', {
+            context: { field: "approval" },
+        });
+    }
+    const patterns = parseAllowedUrls(typeof gate === "string" ? gate : [...gate]);
+    return patterns.length > 0 ? { mode: "urls", patterns } : { mode: "none" };
+}
+/**
+ * Resolve plugin config over environment defaults into the concrete
+ * {@link ResolvedWebSearchConfig}. Which model is used stays lazy - it is
+ * picked at call time against the live catalogue - but everything else is
+ * settled here, and a contradiction (unparseable `WEB_SEARCH_TOOLS`, an
+ * unknown URL policy, a policy that disagrees with its allow-list) throws a
+ * {@link ConfigurationError} naming the field and the environment variable.
+ */
+export function resolveWebSearchConfig(config = {}) {
+    const patterns = parseAllowedUrls(config.allowedUrls ?? process.env.WEB_SEARCH_ALLOWED_URLS);
+    const urlPolicy = resolveUrlPolicy(config.urlPolicy, patterns);
+    const { model, source } = resolveModelPin(config);
+    const fallbacks = string.parseList(config.modelFallbacks ?? process.env.WEB_SEARCH_MODEL_FALLBACKS);
+    const fuzzyThresholdRaw = config.modelFuzzyThreshold ?? Number(process.env.WEB_SEARCH_FUZZY_THRESHOLD);
+    return {
+        ...(model ? { model } : {}),
+        modelSource: source,
+        modelFallbacks: fallbacks.length > 0 ? fallbacks : DEFAULT_MODEL_FALLBACKS,
+        webSearchTools: { ...parseToolsEnv(), ...(config.webSearchTools ?? {}) },
+        fuzzy: config.modelFuzzyMatch ?? object.toBoolean(process.env.WEB_SEARCH_FUZZY) ?? true,
+        fuzzyThreshold: Number.isFinite(fuzzyThresholdRaw) && fuzzyThresholdRaw
+            ? Number(fuzzyThresholdRaw)
+            : serving.DEFAULT_FUZZY_THRESHOLD,
+        maxCitations: resolvePositiveInt(config.maxCitations, "WEB_SEARCH_MAX_CITATIONS", DEFAULT_MAX_CITATIONS),
+        fetchMaxLength: resolvePositiveInt(config.fetchMaxLength, "WEB_SEARCH_FETCH_MAX_LENGTH", DEFAULT_FETCH_MAX_LENGTH),
+        timeoutMs: resolvePositiveInt(config.timeoutMs, "WEB_SEARCH_TIMEOUT_MS", DEFAULT_TIMEOUT_MS),
+        scrapeFallback: config.scrapeFallback ?? object.toBoolean(process.env.WEB_SEARCH_SCRAPE_FALLBACK) ?? true,
+        urlPolicy,
+        allowList: toUrlAllowList(urlPolicy === "allowlist" ? patterns : []),
+        approval: toApprovalPolicy(config.approval),
+    };
+}
+/**
+ * Resolve an approval gate against a set of candidate URLs into a concrete
+ * boolean: `"none"` / `"always"` pass straight through; a `"urls"` policy
+ * gates when ANY candidate matches. Empty candidates with a pattern gate
+ * never match (nothing to approve). Reuses the allow-list matcher so approval
+ * globs read exactly like allow-list globs.
+ */
+export function approvalMatches(gate, urls) {
+    const policy = toApprovalPolicy(gate);
+    if (policy.mode === "none")
+        return false;
+    if (policy.mode === "always")
+        return true;
+    const list = toUrlAllowList(policy.patterns);
+    return urls.some((url) => list.allows(url));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration for the web-search plugin: the typed\n * {@link WebSearchPluginConfig} (the plugin's slice of AppKit config), the\n * JSON Schema the manifest publishes for it, and {@link resolveWebSearchConfig}\n * which layers that config over environment defaults into the concrete\n * {@link ResolvedWebSearchConfig} the runtime + tools read.\n *\n * `web_search` runs on the Databricks Model Serving native web-search tool\n * (see `provider.ts` / `search.ts`), so the key knob is which web-search-\n * capable model to use. It resolves independently of the calling agent's chat\n * model: `model` (a name, loose name, or capability class) is fuzzy-matched\n * against the workspace catalogue, and when nothing is pinned the\n * {@link WebSearchPluginConfig.modelFallbacks} order (Gemini, then GPT, then a\n * repo floor) picks the first web-search-capable endpoint that exists.\n *\n * Which endpoint id is used follows the standard precedence - explicit plugin\n * config, then environment, then a default - with two environment sources:\n *\n *   1. `model` in plugin config;\n *   2. `WEB_SEARCH_MODEL`, the dedicated override, so a deployment can point\n *      web search at a different endpoint than the agent's chat model;\n *   3. `DATABRICKS_SERVING_ENDPOINT_NAME`, AppKit's standard name for a\n *      Model Serving binding, honored so the resource declared in the manifest\n *      wires this plugin up like any other. Because that binding is shared\n *      with whatever else the app serves, it is treated as a preference: an\n *      endpoint that cannot run the native web-search tool is skipped in\n *      favor of {@link WebSearchPluginConfig.modelFallbacks} rather than\n *      failing the call. A pin from (1) or (2) is explicit and DOES fail;\n *   4. otherwise the fallback order, resolved against the live catalogue.\n *\n * Which model wins is decided lazily, at call time, against the live\n * catalogue. Resolution here is eager about everything else and fails loudly\n * on a contradiction: an unparseable `WEB_SEARCH_TOOLS`, an unknown\n * {@link UrlPolicyMode}, or a URL policy that disagrees with the allow-list it\n * was given.\n *\n * Env fallbacks: `WEB_SEARCH_MODEL`, `DATABRICKS_SERVING_ENDPOINT_NAME`,\n * `WEB_SEARCH_MODEL_FALLBACKS`, `WEB_SEARCH_TOOLS` (JSON),\n * `WEB_SEARCH_URL_POLICY`, `WEB_SEARCH_ALLOWED_URLS`,\n * `WEB_SEARCH_MAX_CITATIONS`, `WEB_SEARCH_FETCH_MAX_LENGTH`,\n * `WEB_SEARCH_TIMEOUT_MS`, `WEB_SEARCH_SCRAPE_FALLBACK`, `WEB_SEARCH_FUZZY`,\n * `WEB_SEARCH_FUZZY_THRESHOLD`.\n *\n * @module\n */\n\nimport { ConfigurationError, type BasePluginConfig } from \"@databricks/appkit\";\nimport { serving } from \"@dbx-tools/model\";\nimport { json, object, type OneOrMany, string } from \"@dbx-tools/shared-core\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport { parseAllowedUrls, toUrlAllowList, type UrlAllowList } from \"./allowlist\";\n\n/**\n * A URL-pattern gate for per-tool approval. `true` gates every call; a\n * pattern (or list of patterns, in the {@link OneOrMany} shape used across\n * the repo) gates only calls whose URL matches. Patterns use the same glob\n * syntax as the allow-list (see `allowlist.ts`). Omit / `false` for no\n * approval. Normalized to an {@link ApprovalPolicy} before use.\n */\nexport type ApprovalGate = boolean | OneOrMany<string> | string;\n\n/**\n * The normalized form of an {@link ApprovalGate}: which calls pause for a\n * human. `\"none\"` runs every call straight through, `\"always\"` gates all of\n * them, and `\"urls\"` gates only calls whose URL matches one of `patterns`.\n */\nexport type ApprovalPolicy =\n  | { readonly mode: \"none\" }\n  | { readonly mode: \"always\" }\n  | { readonly mode: \"urls\"; readonly patterns: readonly string[] };\n\n/**\n * Which URLs the tools may reach. `\"allowlist\"` permits only the configured\n * entries; `\"unrestricted\"` names the permissive mode explicitly, so an\n * unrestricted deployment is a stated choice visible in the boot log rather\n * than an empty list nobody noticed.\n */\nexport type UrlPolicyMode = \"unrestricted\" | \"allowlist\";\n\n/** Dedicated override for the web-search endpoint id. */\nexport const MODEL_ENV = \"WEB_SEARCH_MODEL\";\n\n/** AppKit's standard environment name for a Model Serving endpoint binding. */\nexport const SERVING_ENDPOINT_ENV = \"DATABRICKS_SERVING_ENDPOINT_NAME\";\n\n/** Where the pinned web-search endpoint id came from, or `\"none\"` when unpinned. */\nexport type ModelSource = \"config\" | typeof MODEL_ENV | typeof SERVING_ENDPOINT_ENV | \"none\";\n\n/**\n * Default web-search model preference, tried in order when no model is\n * pinned. Gemini first, then GPT - both support the native web-search tool;\n * a workspace typically has at least one. Each is fuzzy-matched against the\n * live catalogue, so a close variant (e.g. `databricks-gemini-3-1-pro`) is\n * picked when the exact id isn't present.\n */\nexport const DEFAULT_MODEL_FALLBACKS: readonly string[] = [\n  \"databricks-gemini-3-pro\",\n  \"databricks-gemini-2-5-pro\",\n  \"databricks-gpt-5\",\n  \"databricks-gpt-5-mini\",\n];\n\n/** Default cap on the number of citations returned from a single search. */\nexport const DEFAULT_MAX_CITATIONS = 10;\n\n/** Default cap on characters returned from a single `web_fetch`. */\nexport const DEFAULT_FETCH_MAX_LENGTH = 50_000;\n\n/** Default per-request network timeout (ms) for search + fetch. */\nexport const DEFAULT_TIMEOUT_MS = 30_000;\n\n/** AppKit config accepted by the web-search plugin. */\nexport interface WebSearchPluginConfig extends BasePluginConfig {\n  /**\n   * The web-search model to use by default: a Databricks serving endpoint\n   * name (`\"databricks-gemini-3-pro\"`), a loose name (`\"gemini\"`, `\"gpt\"`),\n   * or a capability class. Fuzzy-matched against the live catalogue. Falls\n   * back to `WEB_SEARCH_MODEL`, then `DATABRICKS_SERVING_ENDPOINT_NAME`, then\n   * the {@link modelFallbacks} order. Chosen independently of the calling\n   * agent's chat model.\n   */\n  model?: string;\n  /**\n   * Priority-ordered web-search model candidates tried when {@link model} is\n   * unset, each fuzzy-matched and checked for web-search support. Falls back\n   * to `WEB_SEARCH_MODEL_FALLBACKS` (comma/space-separated), then\n   * {@link DEFAULT_MODEL_FALLBACKS} (Gemini, then GPT).\n   */\n  modelFallbacks?: string | string[];\n  /**\n   * Provider -> tool-spec override map, merged over the built-in\n   * {@link WEB_SEARCH_PROVIDERS} defaults. Keyed by provider family\n   * (`\"openai\"`, `\"gemini\"`); each value may override the `tool` entry\n   * and/or the `api` surface. Use to change the tool shape as the platform\n   * evolves without a code change. Falls back to `WEB_SEARCH_TOOLS` parsed as\n   * JSON. This is the `WEB_SEARCH_TOOLS` setting.\n   */\n  webSearchTools?: Record<string, unknown>;\n  /**\n   * Enable fuzzy matching of loose model names against the catalogue.\n   * Defaults to `true`; falls back to `WEB_SEARCH_FUZZY`.\n   */\n  modelFuzzyMatch?: boolean;\n  /** Fuse.js fuzzy threshold. Falls back to `WEB_SEARCH_FUZZY_THRESHOLD`, then the shared default. */\n  modelFuzzyThreshold?: number;\n  /**\n   * Hard cap on the number of citations a single search returns. Falls back\n   * to `WEB_SEARCH_MAX_CITATIONS`, then {@link DEFAULT_MAX_CITATIONS}.\n   */\n  maxCitations?: number;\n  /**\n   * Hard cap on the character length of a single `web_fetch` result. Falls\n   * back to `WEB_SEARCH_FETCH_MAX_LENGTH`, then {@link DEFAULT_FETCH_MAX_LENGTH}.\n   */\n  fetchMaxLength?: number;\n  /**\n   * Per-request network timeout in ms for search + fetch. Falls back to\n   * `WEB_SEARCH_TIMEOUT_MS`, then {@link DEFAULT_TIMEOUT_MS}.\n   */\n  timeoutMs?: number;\n  /**\n   * Fall back to a DuckDuckGo scrape when the workspace has NO deployed\n   * web-search-capable model (no GPT / Gemini serving endpoint). The native\n   * Databricks tool is always preferred; this only kicks in when there is no\n   * native option, so the tool still returns results instead of erroring.\n   * Defaults to `true`; set `false` (or `WEB_SEARCH_SCRAPE_FALLBACK=0`) to\n   * require a native model and error otherwise.\n   */\n  scrapeFallback?: boolean;\n  /**\n   * Which URLs the tools may reach ({@link UrlPolicyMode}). Falls back to\n   * `WEB_SEARCH_URL_POLICY`, then to `\"allowlist\"` when {@link allowedUrls}\n   * has entries and `\"unrestricted\"` when it does not. Naming the mode\n   * explicitly is the way to state that an open deployment is intended;\n   * `\"allowlist\"` with no entries, or `\"unrestricted\"` alongside entries, is\n   * a contradiction and fails at resolution.\n   */\n  urlPolicy?: UrlPolicyMode;\n  /**\n   * Optional URL allow-list. Each entry is a glob (or bare host) tested\n   * against a URL's full `href`. When set, `web_search` silently filters\n   * citations to the permitted set and `web_fetch` refuses a disallowed URL.\n   * Accepts a `string[]` or a comma-/whitespace-separated string; falls back\n   * to `WEB_SEARCH_ALLOWED_URLS`. Omit (or leave empty) for no restriction.\n   * See `allowlist.ts`.\n   */\n  allowedUrls?: string | string[];\n  /**\n   * Approval gate applied to BOTH tools (per-tool overrides via\n   * {@link WebSearchToolOptions.approval} win). `true` gates every call;\n   * a URL-pattern (or list) gates only matching calls; an\n   * {@link ApprovalPolicy} states the mode directly. Omit for no approval.\n   */\n  approval?: ApprovalGate | ApprovalPolicy;\n}\n\n/** Concrete, validated config the runtime + tools read. */\nexport interface ResolvedWebSearchConfig {\n  /** Pinned web-search model, when configured (else undefined - use fallbacks). */\n  model?: string;\n  /** Where {@link model} came from, which decides whether an unsupported pin is fatal. */\n  modelSource: ModelSource;\n  /** Ordered fallback model candidates (Gemini, then GPT, then a floor). */\n  modelFallbacks: readonly string[];\n  /** Provider -> tool-spec override map, merged over the built-in defaults. */\n  webSearchTools: Record<string, unknown>;\n  /** Whether to fuzzy-match loose model names. */\n  fuzzy: boolean;\n  /** Fuse.js fuzzy threshold. */\n  fuzzyThreshold: number;\n  maxCitations: number;\n  fetchMaxLength: number;\n  timeoutMs: number;\n  /** Whether to scrape-fallback when no native web-search model is deployed. */\n  scrapeFallback: boolean;\n  /** The named URL policy in force. */\n  urlPolicy: UrlPolicyMode;\n  /** Compiled allow-list (permit-all under the `unrestricted` policy). */\n  allowList: UrlAllowList;\n  /** Default per-tool approval policy. */\n  approval: ApprovalPolicy;\n}\n\n/** JSON Schema published on the manifest's `config.schema`. */\nexport const WEB_SEARCH_CONFIG_SCHEMA: JSONSchema7 = {\n  type: \"object\",\n  properties: {\n    model: {\n      type: \"string\",\n      description:\n        \"Default web-search model (endpoint name, loose name, or class). Fuzzy-matched. Env: WEB_SEARCH_MODEL, then DATABRICKS_SERVING_ENDPOINT_NAME.\",\n    },\n    modelFallbacks: {\n      type: \"array\",\n      items: { type: \"string\" },\n      description:\n        \"Ordered web-search model candidates when `model` is unset (Gemini, then GPT). Env: WEB_SEARCH_MODEL_FALLBACKS.\",\n    },\n    webSearchTools: {\n      type: \"object\",\n      description:\n        'Provider -> tool-spec override map merged over the built-in defaults (openai -> {\"type\":\"web_search\"}, gemini -> {\"google_search\":{}}). Env: WEB_SEARCH_TOOLS (JSON).',\n    },\n    modelFuzzyMatch: {\n      type: \"boolean\",\n      description:\n        \"Fuzzy-match loose model names against the live catalogue. Default true (env: WEB_SEARCH_FUZZY).\",\n    },\n    modelFuzzyThreshold: {\n      type: \"number\",\n      description:\n        \"Fuse.js score threshold below which a fuzzy model match is accepted (env: WEB_SEARCH_FUZZY_THRESHOLD).\",\n    },\n    maxCitations: {\n      type: \"number\",\n      description: \"Hard cap on citations returned (env: WEB_SEARCH_MAX_CITATIONS).\",\n    },\n    fetchMaxLength: {\n      type: \"number\",\n      description: \"Hard cap on web_fetch content length (env: WEB_SEARCH_FETCH_MAX_LENGTH).\",\n    },\n    timeoutMs: {\n      type: \"number\",\n      description: \"Per-request network timeout in ms (env: WEB_SEARCH_TIMEOUT_MS).\",\n    },\n    scrapeFallback: {\n      type: \"boolean\",\n      description:\n        \"Fall back to a DuckDuckGo scrape when no web-search-capable model is deployed. Default true (env: WEB_SEARCH_SCRAPE_FALLBACK).\",\n    },\n    urlPolicy: {\n      type: \"string\",\n      enum: [\"unrestricted\", \"allowlist\"],\n      description:\n        \"Which URLs the tools may reach. Defaults to allowlist when allowedUrls has entries, else unrestricted (env: WEB_SEARCH_URL_POLICY).\",\n    },\n    allowedUrls: {\n      type: \"array\",\n      items: { type: \"string\" },\n      description:\n        'URL allow-list of globs / bare hosts (e.g. \"*.databricks.com\", \"docs.example.com\"). Also accepts a comma/space-separated string. Falls back to WEB_SEARCH_ALLOWED_URLS. Empty = unrestricted.',\n    },\n    approval: {\n      description:\n        'Approval gate for both tools: true gates every call, a glob (or list of globs) gates only matching URLs, or state the mode directly as {\"mode\":\"none\"|\"always\"|\"urls\"}. Default none.',\n      oneOf: [\n        { type: \"boolean\" },\n        { type: \"string\" },\n        { type: \"array\", items: { type: \"string\" } },\n        {\n          type: \"object\",\n          properties: {\n            mode: { type: \"string\", enum: [\"none\", \"always\", \"urls\"] },\n            patterns: { type: \"array\", items: { type: \"string\" } },\n          },\n          required: [\"mode\"],\n        },\n      ],\n    },\n  },\n};\n\n/** Parse a positive integer env/config value, else the fallback. */\nfunction resolvePositiveInt(value: number | undefined, envKey: string, fallback: number): number {\n  if (typeof value === \"number\" && Number.isFinite(value) && value > 0) return Math.floor(value);\n  const env = Number(process.env[envKey]);\n  return Number.isFinite(env) && env > 0 ? Math.floor(env) : fallback;\n}\n\n/**\n * Parse the `WEB_SEARCH_TOOLS` env var (JSON object), else `{}`. A value that\n * is set but not a JSON object is a deployment mistake that would otherwise\n * silently leave the built-in tool specs in place, so it throws.\n */\nfunction parseToolsEnv(): Record<string, unknown> {\n  const raw = string.trimToNull(process.env.WEB_SEARCH_TOOLS);\n  if (raw === null) return {};\n  const parsed = json.parseRecord(raw);\n  if (!parsed) {\n    throw new ConfigurationError(\n      \"WEB_SEARCH_TOOLS must be a JSON object mapping a provider family to its tool spec\",\n      { context: { envVar: \"WEB_SEARCH_TOOLS\" } },\n    );\n  }\n  return parsed;\n}\n\n/** Read the pinned endpoint id and record which source supplied it. */\nfunction resolveModelPin(config: WebSearchPluginConfig): { model?: string; source: ModelSource } {\n  const fromConfig = string.trimToNull(config.model);\n  if (fromConfig !== null) return { model: fromConfig, source: \"config\" };\n  const fromModelEnv = string.trimToNull(process.env[MODEL_ENV]);\n  if (fromModelEnv !== null) return { model: fromModelEnv, source: MODEL_ENV };\n  const fromResourceEnv = string.trimToNull(process.env[SERVING_ENDPOINT_ENV]);\n  if (fromResourceEnv !== null) return { model: fromResourceEnv, source: SERVING_ENDPOINT_ENV };\n  return { source: \"none\" };\n}\n\n/**\n * Resolve the named {@link UrlPolicyMode}, failing on a stated mode that\n * contradicts the allow-list entries it was given.\n */\nfunction resolveUrlPolicy(\n  configured: UrlPolicyMode | undefined,\n  patterns: readonly string[],\n): UrlPolicyMode {\n  const raw = configured ?? string.trimToNull(process.env.WEB_SEARCH_URL_POLICY) ?? undefined;\n  if (raw === undefined) return patterns.length > 0 ? \"allowlist\" : \"unrestricted\";\n  if (raw !== \"allowlist\" && raw !== \"unrestricted\") {\n    throw new ConfigurationError(\n      'urlPolicy must be \"allowlist\" or \"unrestricted\" (env: WEB_SEARCH_URL_POLICY)',\n      { context: { field: \"urlPolicy\", envVar: \"WEB_SEARCH_URL_POLICY\" } },\n    );\n  }\n  if (raw === \"allowlist\" && patterns.length === 0) {\n    throw new ConfigurationError(\n      'urlPolicy \"allowlist\" needs at least one entry in allowedUrls (env: WEB_SEARCH_ALLOWED_URLS)',\n      { context: { field: \"allowedUrls\", envVar: \"WEB_SEARCH_ALLOWED_URLS\" } },\n    );\n  }\n  if (raw === \"unrestricted\" && patterns.length > 0) {\n    throw new ConfigurationError(\n      'urlPolicy \"unrestricted\" cannot be combined with allowedUrls entries; drop the entries or set urlPolicy to \"allowlist\"',\n      { context: { field: \"allowedUrls\", envVar: \"WEB_SEARCH_ALLOWED_URLS\" } },\n    );\n  }\n  return raw;\n}\n\n/**\n * Normalize any accepted approval spelling into an {@link ApprovalPolicy}.\n * A pattern gate with no usable patterns collapses to `\"none\"` rather than\n * gating everything, so a blank env var can never wedge the tools behind an\n * approval nobody configured.\n */\nexport function toApprovalPolicy(gate: ApprovalGate | ApprovalPolicy | undefined): ApprovalPolicy {\n  if (gate === undefined || gate === false) return { mode: \"none\" };\n  if (gate === true) return { mode: \"always\" };\n  if (object.isRecord(gate) && \"mode\" in gate) {\n    if (gate.mode === \"urls\") {\n      const patterns = parseAllowedUrls([...gate.patterns]);\n      return patterns.length > 0 ? { mode: \"urls\", patterns } : { mode: \"none\" };\n    }\n    if (gate.mode === \"always\" || gate.mode === \"none\") return { mode: gate.mode };\n    throw new ConfigurationError('approval mode must be \"none\", \"always\" or \"urls\"', {\n      context: { field: \"approval\" },\n    });\n  }\n  const patterns = parseAllowedUrls(typeof gate === \"string\" ? gate : [...gate]);\n  return patterns.length > 0 ? { mode: \"urls\", patterns } : { mode: \"none\" };\n}\n\n/**\n * Resolve plugin config over environment defaults into the concrete\n * {@link ResolvedWebSearchConfig}. Which model is used stays lazy - it is\n * picked at call time against the live catalogue - but everything else is\n * settled here, and a contradiction (unparseable `WEB_SEARCH_TOOLS`, an\n * unknown URL policy, a policy that disagrees with its allow-list) throws a\n * {@link ConfigurationError} naming the field and the environment variable.\n */\nexport function resolveWebSearchConfig(\n  config: WebSearchPluginConfig = {},\n): ResolvedWebSearchConfig {\n  const patterns = parseAllowedUrls(config.allowedUrls ?? process.env.WEB_SEARCH_ALLOWED_URLS);\n  const urlPolicy = resolveUrlPolicy(config.urlPolicy, patterns);\n  const { model, source } = resolveModelPin(config);\n  const fallbacks = string.parseList(\n    config.modelFallbacks ?? process.env.WEB_SEARCH_MODEL_FALLBACKS,\n  );\n  const fuzzyThresholdRaw =\n    config.modelFuzzyThreshold ?? Number(process.env.WEB_SEARCH_FUZZY_THRESHOLD);\n  return {\n    ...(model ? { model } : {}),\n    modelSource: source,\n    modelFallbacks: fallbacks.length > 0 ? fallbacks : DEFAULT_MODEL_FALLBACKS,\n    webSearchTools: { ...parseToolsEnv(), ...(config.webSearchTools ?? {}) },\n    fuzzy: config.modelFuzzyMatch ?? object.toBoolean(process.env.WEB_SEARCH_FUZZY) ?? true,\n    fuzzyThreshold:\n      Number.isFinite(fuzzyThresholdRaw) && fuzzyThresholdRaw\n        ? Number(fuzzyThresholdRaw)\n        : serving.DEFAULT_FUZZY_THRESHOLD,\n    maxCitations: resolvePositiveInt(\n      config.maxCitations,\n      \"WEB_SEARCH_MAX_CITATIONS\",\n      DEFAULT_MAX_CITATIONS,\n    ),\n    fetchMaxLength: resolvePositiveInt(\n      config.fetchMaxLength,\n      \"WEB_SEARCH_FETCH_MAX_LENGTH\",\n      DEFAULT_FETCH_MAX_LENGTH,\n    ),\n    timeoutMs: resolvePositiveInt(config.timeoutMs, \"WEB_SEARCH_TIMEOUT_MS\", DEFAULT_TIMEOUT_MS),\n    scrapeFallback:\n      config.scrapeFallback ?? object.toBoolean(process.env.WEB_SEARCH_SCRAPE_FALLBACK) ?? true,\n    urlPolicy,\n    allowList: toUrlAllowList(urlPolicy === \"allowlist\" ? patterns : []),\n    approval: toApprovalPolicy(config.approval),\n  };\n}\n\n/**\n * Resolve an approval gate against a set of candidate URLs into a concrete\n * boolean: `\"none\"` / `\"always\"` pass straight through; a `\"urls\"` policy\n * gates when ANY candidate matches. Empty candidates with a pattern gate\n * never match (nothing to approve). Reuses the allow-list matcher so approval\n * globs read exactly like allow-list globs.\n */\nexport function approvalMatches(\n  gate: ApprovalGate | ApprovalPolicy,\n  urls: readonly string[],\n): boolean {\n  const policy = toApprovalPolicy(gate);\n  if (policy.mode === \"none\") return false;\n  if (policy.mode === \"always\") return true;\n  const list = toUrlAllowList(policy.patterns);\n  return urls.some((url) => list.allows(url));\n}\n"]}

package/lib/src/defaults.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Interceptor settings for the add-on's three outbound calls: the native
+ * web-search POST to Model Serving, the `web_fetch` page read, and the
+ * DuckDuckGo scrape fallback. They live here, in the sibling `defaults.ts`
+ * AppKit plugins keep, so a TTL or retry budget is tuned in one place instead
+ * of at a call site.
+ *
+ * All three are idempotent READS: none of them create or mutate anything, so
+ * both caching and retrying are safe. Each constant below records why its
+ * numbers were chosen.
+ *
+ * @module
+ */
+/**
+ * The `PluginExecuteConfig` slice this package sets. Mirrored structurally
+ * because AppKit's `PluginExecuteConfig` lives behind a subpath its `exports`
+ * map does not publish, so the nominal type cannot be imported.
+ */
+export type WebSearchExecuteConfig = {
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+        cacheKey?: (string | number | object)[];
+    };
+    retry?: {
+        enabled?: boolean;
+        attempts?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+    };
+    timeout?: number;
+};
+/**
+ * The `PluginExecutionSettings` shape accepted by AppKit's `Plugin.execute()`.
+ * Mirrored structurally for the same reason as {@link WebSearchExecuteConfig}.
+ */
+export type WebSearchExecutionSettings = {
+    default: WebSearchExecuteConfig;
+    user?: WebSearchExecuteConfig;
+};
+/**
+ * Cache lifetime for a native web-search answer. Long enough that a model
+ * re-asking the same question inside one conversation does not pay for a
+ * second serving call, short enough that "current information" stays current.
+ */
+export declare const SEARCH_CACHE_TTL_SECONDS = 300;
+/**
+ * Cache lifetime for a fetched page. Pages move more slowly than search
+ * results, and an agent commonly re-reads the same source across turns.
+ */
+export declare const FETCH_CACHE_TTL_SECONDS = 900;
+/**
+ * Attempts for a serving call. Model Serving sheds load with 429 / 503 under
+ * contention; three attempts with AppKit's exponential backoff and full jitter
+ * clears that without turning a genuine outage into a long stall.
+ */
+export declare const SERVING_RETRY_ATTEMPTS = 3;
+/**
+ * Attempts for an open-web request. Kept lower than the serving budget: a
+ * remote site that refuses once usually refuses again, and the caller is
+ * waiting on an interactive tool call.
+ */
+export declare const WEB_RETRY_ATTEMPTS = 2;
+/**
+ * Settings for the native web-search POST to Model Serving.
+ *
+ * Cache enabled: the POST is a pure read of the model's answer for one query,
+ * and repeat asks of the same question are common in a multi-turn agent.
+ * Retry enabled: the POST creates no conversation or state, so replaying it
+ * after a transient 429 / 5xx is safe.
+ */
+export declare const webSearchExecuteDefaults: WebSearchExecutionSettings;
+/**
+ * Settings for a `web_fetch` page read.
+ *
+ * Cache enabled: fetching a URL is a read, and an agent that searches then
+ * reads its own citations hits the same page repeatedly.
+ * Retry enabled: a GET is idempotent, so a dropped connection is worth one
+ * more attempt.
+ */
+export declare const webFetchExecuteDefaults: WebSearchExecutionSettings;
+/**
+ * Settings for the DuckDuckGo scrape fallback. Same read semantics as the
+ * native search, and the shorter cache lifetime applies for the same reason,
+ * but the retry budget follows the open-web one: DuckDuckGo answers a repeat
+ * request with a bot challenge rather than results.
+ */
+export declare const scrapeSearchExecuteDefaults: WebSearchExecutionSettings;
+/**
+ * Bind one of the named defaults to a single call: the configured network
+ * timeout and the cache key for this request.
+ *
+ * AppKit only installs the cache interceptor when a non-empty `cacheKey` is
+ * present, so every cached call has to name its own key parts. The per-user
+ * half of the key is added by `execute()` from the active execution context,
+ * which is what keeps an OBO result from leaking across identities.
+ */
+export declare function toCallSettings(base: WebSearchExecutionSettings, timeoutMs: number, cacheKey: readonly (string | number)[]): WebSearchExecutionSettings;

package/lib/src/defaults.js

@@ -0,0 +1,96 @@
+/**
+ * Interceptor settings for the add-on's three outbound calls: the native
+ * web-search POST to Model Serving, the `web_fetch` page read, and the
+ * DuckDuckGo scrape fallback. They live here, in the sibling `defaults.ts`
+ * AppKit plugins keep, so a TTL or retry budget is tuned in one place instead
+ * of at a call site.
+ *
+ * All three are idempotent READS: none of them create or mutate anything, so
+ * both caching and retrying are safe. Each constant below records why its
+ * numbers were chosen.
+ *
+ * @module
+ */
+/**
+ * Cache lifetime for a native web-search answer. Long enough that a model
+ * re-asking the same question inside one conversation does not pay for a
+ * second serving call, short enough that "current information" stays current.
+ */
+export const SEARCH_CACHE_TTL_SECONDS = 300;
+/**
+ * Cache lifetime for a fetched page. Pages move more slowly than search
+ * results, and an agent commonly re-reads the same source across turns.
+ */
+export const FETCH_CACHE_TTL_SECONDS = 900;
+/**
+ * Attempts for a serving call. Model Serving sheds load with 429 / 503 under
+ * contention; three attempts with AppKit's exponential backoff and full jitter
+ * clears that without turning a genuine outage into a long stall.
+ */
+export const SERVING_RETRY_ATTEMPTS = 3;
+/**
+ * Attempts for an open-web request. Kept lower than the serving budget: a
+ * remote site that refuses once usually refuses again, and the caller is
+ * waiting on an interactive tool call.
+ */
+export const WEB_RETRY_ATTEMPTS = 2;
+/**
+ * Settings for the native web-search POST to Model Serving.
+ *
+ * Cache enabled: the POST is a pure read of the model's answer for one query,
+ * and repeat asks of the same question are common in a multi-turn agent.
+ * Retry enabled: the POST creates no conversation or state, so replaying it
+ * after a transient 429 / 5xx is safe.
+ */
+export const webSearchExecuteDefaults = {
+    default: {
+        cache: { enabled: true, ttl: SEARCH_CACHE_TTL_SECONDS },
+        retry: { enabled: true, attempts: SERVING_RETRY_ATTEMPTS },
+    },
+};
+/**
+ * Settings for a `web_fetch` page read.
+ *
+ * Cache enabled: fetching a URL is a read, and an agent that searches then
+ * reads its own citations hits the same page repeatedly.
+ * Retry enabled: a GET is idempotent, so a dropped connection is worth one
+ * more attempt.
+ */
+export const webFetchExecuteDefaults = {
+    default: {
+        cache: { enabled: true, ttl: FETCH_CACHE_TTL_SECONDS },
+        retry: { enabled: true, attempts: WEB_RETRY_ATTEMPTS },
+    },
+};
+/**
+ * Settings for the DuckDuckGo scrape fallback. Same read semantics as the
+ * native search, and the shorter cache lifetime applies for the same reason,
+ * but the retry budget follows the open-web one: DuckDuckGo answers a repeat
+ * request with a bot challenge rather than results.
+ */
+export const scrapeSearchExecuteDefaults = {
+    default: {
+        cache: { enabled: true, ttl: SEARCH_CACHE_TTL_SECONDS },
+        retry: { enabled: true, attempts: WEB_RETRY_ATTEMPTS },
+    },
+};
+/**
+ * Bind one of the named defaults to a single call: the configured network
+ * timeout and the cache key for this request.
+ *
+ * AppKit only installs the cache interceptor when a non-empty `cacheKey` is
+ * present, so every cached call has to name its own key parts. The per-user
+ * half of the key is added by `execute()` from the active execution context,
+ * which is what keeps an OBO result from leaking across identities.
+ */
+export function toCallSettings(base, timeoutMs, cacheKey) {
+    return {
+        default: {
+            ...base.default,
+            cache: { ...base.default.cache, cacheKey: [...cacheKey] },
+            timeout: timeoutMs,
+        },
+        ...(base.user ? { user: base.user } : {}),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAsBH;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,CAAC;AAE5C;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAExC;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAEpC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAA+B;IAClE,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,wBAAwB,EAAE;QACvD,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,sBAAsB,EAAE;KAC3D;CACF,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAA+B;IACjE,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,uBAAuB,EAAE;QACtD,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,EAAE;KACvD;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAA+B;IACrE,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,wBAAwB,EAAE;QACvD,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,EAAE;KACvD;CACF,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAgC,EAChC,SAAiB,EACjB,QAAsC;IAEtC,OAAO;QACL,OAAO,EAAE;YACP,GAAG,IAAI,CAAC,OAAO;YACf,KAAK,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE;YACzD,OAAO,EAAE,SAAS;SACnB;QACD,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC1C,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Interceptor settings for the add-on's three outbound calls: the native\n * web-search POST to Model Serving, the `web_fetch` page read, and the\n * DuckDuckGo scrape fallback. They live here, in the sibling `defaults.ts`\n * AppKit plugins keep, so a TTL or retry budget is tuned in one place instead\n * of at a call site.\n *\n * All three are idempotent READS: none of them create or mutate anything, so\n * both caching and retrying are safe. Each constant below records why its\n * numbers were chosen.\n *\n * @module\n */\n\n/**\n * The `PluginExecuteConfig` slice this package sets. Mirrored structurally\n * because AppKit's `PluginExecuteConfig` lives behind a subpath its `exports`\n * map does not publish, so the nominal type cannot be imported.\n */\nexport type WebSearchExecuteConfig = {\n  cache?: { enabled?: boolean; ttl?: number; cacheKey?: (string | number | object)[] };\n  retry?: { enabled?: boolean; attempts?: number; initialDelay?: number; maxDelay?: number };\n  timeout?: number;\n};\n\n/**\n * The `PluginExecutionSettings` shape accepted by AppKit's `Plugin.execute()`.\n * Mirrored structurally for the same reason as {@link WebSearchExecuteConfig}.\n */\nexport type WebSearchExecutionSettings = {\n  default: WebSearchExecuteConfig;\n  user?: WebSearchExecuteConfig;\n};\n\n/**\n * Cache lifetime for a native web-search answer. Long enough that a model\n * re-asking the same question inside one conversation does not pay for a\n * second serving call, short enough that \"current information\" stays current.\n */\nexport const SEARCH_CACHE_TTL_SECONDS = 300;\n\n/**\n * Cache lifetime for a fetched page. Pages move more slowly than search\n * results, and an agent commonly re-reads the same source across turns.\n */\nexport const FETCH_CACHE_TTL_SECONDS = 900;\n\n/**\n * Attempts for a serving call. Model Serving sheds load with 429 / 503 under\n * contention; three attempts with AppKit's exponential backoff and full jitter\n * clears that without turning a genuine outage into a long stall.\n */\nexport const SERVING_RETRY_ATTEMPTS = 3;\n\n/**\n * Attempts for an open-web request. Kept lower than the serving budget: a\n * remote site that refuses once usually refuses again, and the caller is\n * waiting on an interactive tool call.\n */\nexport const WEB_RETRY_ATTEMPTS = 2;\n\n/**\n * Settings for the native web-search POST to Model Serving.\n *\n * Cache enabled: the POST is a pure read of the model's answer for one query,\n * and repeat asks of the same question are common in a multi-turn agent.\n * Retry enabled: the POST creates no conversation or state, so replaying it\n * after a transient 429 / 5xx is safe.\n */\nexport const webSearchExecuteDefaults: WebSearchExecutionSettings = {\n  default: {\n    cache: { enabled: true, ttl: SEARCH_CACHE_TTL_SECONDS },\n    retry: { enabled: true, attempts: SERVING_RETRY_ATTEMPTS },\n  },\n};\n\n/**\n * Settings for a `web_fetch` page read.\n *\n * Cache enabled: fetching a URL is a read, and an agent that searches then\n * reads its own citations hits the same page repeatedly.\n * Retry enabled: a GET is idempotent, so a dropped connection is worth one\n * more attempt.\n */\nexport const webFetchExecuteDefaults: WebSearchExecutionSettings = {\n  default: {\n    cache: { enabled: true, ttl: FETCH_CACHE_TTL_SECONDS },\n    retry: { enabled: true, attempts: WEB_RETRY_ATTEMPTS },\n  },\n};\n\n/**\n * Settings for the DuckDuckGo scrape fallback. Same read semantics as the\n * native search, and the shorter cache lifetime applies for the same reason,\n * but the retry budget follows the open-web one: DuckDuckGo answers a repeat\n * request with a bot challenge rather than results.\n */\nexport const scrapeSearchExecuteDefaults: WebSearchExecutionSettings = {\n  default: {\n    cache: { enabled: true, ttl: SEARCH_CACHE_TTL_SECONDS },\n    retry: { enabled: true, attempts: WEB_RETRY_ATTEMPTS },\n  },\n};\n\n/**\n * Bind one of the named defaults to a single call: the configured network\n * timeout and the cache key for this request.\n *\n * AppKit only installs the cache interceptor when a non-empty `cacheKey` is\n * present, so every cached call has to name its own key parts. The per-user\n * half of the key is added by `execute()` from the active execution context,\n * which is what keeps an OBO result from leaking across identities.\n */\nexport function toCallSettings(\n  base: WebSearchExecutionSettings,\n  timeoutMs: number,\n  cacheKey: readonly (string | number)[],\n): WebSearchExecutionSettings {\n  return {\n    default: {\n      ...base.default,\n      cache: { ...base.default.cache, cacheKey: [...cacheKey] },\n      timeout: timeoutMs,\n    },\n    ...(base.user ? { user: base.user } : {}),\n  };\n}\n"]}

package/lib/src/fetch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Page fetching over {@link https://www.npmjs.com/package/got-scraping | got-scraping}
+ * - a `got` wrapper that generates browser-like TLS + header fingerprints, so
+ * fetches survive the bot walls a plain `fetch` trips. {@link runWebFetch}
+ * enforces the URL allow-list (an explicit fetch of a disallowed URL is
+ * refused, not silently emptied), fetches with the plugin's timeout, and
+ * returns either the raw HTML or a readable plain-text reduction, capped at
+ * the configured length.
+ *
+ * The HTML-to-text reduction is deliberately dependency-free (strip
+ * script/style, unwrap tags, decode a handful of entities, collapse
+ * whitespace): good enough to feed a model, and it keeps the add-on's
+ * dependency surface to the two libraries the task called for.
+ *
+ * @module
+ */
+import type { ResolvedWebSearchConfig } from "./config.js";
+import type { WebFetchRequest, WebFetchResult } from "./schema.js";
+/**
+ * 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 declare function runWebFetch(request: WebFetchRequest, config: ResolvedWebSearchConfig, signal?: AbortSignal): Promise<WebFetchResult>;