@dbx-tools/appkit-web-search 0.3.28 → 0.3.30

package/src/runtime.ts

@@ -5,23 +5,64 @@
  * plugin at setup) primes it from the plugin's config; later callers (the
  * tools' `execute`) reuse it.
  *
+ * The runtime also carries the {@link WebSearchExecutor} every outbound call
+ * runs through. The plugin installs its own `execute()` there at setup, which
+ * is how the tools - plain functions with no plugin instance in scope - still
+ * get AppKit's cache / retry / timeout / telemetry chain. Without a
+ * registered plugin (a direct call from a script or a test) the calls still
+ * run, just without interceptors.
+ *
  * Unlike the email runtime there is no connection to pool - the backend is
- * stateless HTTP per call - so the runtime holds only the resolved config.
+ * stateless HTTP per call - so the runtime holds only the resolved config and
+ * that executor.
  *
  * @module
  */
 
+import { AppKitError, ExecutionError, type ExecutionResult } from "@databricks/appkit";
+import { async, error, log } from "@dbx-tools/shared-core";
 import {
   resolveWebSearchConfig,
   type ResolvedWebSearchConfig,
   type WebSearchPluginConfig,
 } from "./config";
+import type { WebSearchExecutionSettings } from "./defaults";
+
+const logger = log.logger("web-search/runtime");
+
+/**
+ * Runs one outbound call through AppKit's interceptor chain. Matches
+ * `Plugin.execute()`, which never throws: a failure comes back as
+ * `{ ok: false }`.
+ */
+export type WebSearchExecutor = <T>(
+  fn: (signal?: AbortSignal) => Promise<T>,
+  settings: WebSearchExecutionSettings,
+) => Promise<ExecutionResult<T>>;
 
-/** The shared resolved config. */
+/** The shared resolved config plus the executor outbound calls run through. */
 export interface WebSearchRuntime {
   config: ResolvedWebSearchConfig;
+  execute: WebSearchExecutor;
 }
 
+/**
+ * Executor used until (or unless) the plugin installs its own: run the call
+ * directly, mapping a throw onto the same {@link ExecutionResult} shape so
+ * call sites branch on `ok` either way.
+ */
+const directExecute: WebSearchExecutor = async (fn) => {
+  try {
+    return { ok: true, data: await fn() };
+  } catch (err) {
+    return {
+      ok: false,
+      status: err instanceof AppKitError ? err.statusCode : 500,
+      message: error.errorMessage(err),
+    };
+  }
+};
+
 let runtime: WebSearchRuntime | undefined;
 
 /**
@@ -33,12 +74,55 @@ let runtime: WebSearchRuntime | undefined;
  */
 export function getWebSearchRuntime(overrides?: WebSearchPluginConfig): WebSearchRuntime {
   if (!runtime) {
-    runtime = { config: resolveWebSearchConfig(overrides) };
+    runtime = { config: resolveWebSearchConfig(overrides), execute: directExecute };
   }
   return runtime;
 }
 
+/**
+ * Install the executor outbound calls run through. The plugin calls this at
+ * setup with its own `execute()`; a second call replaces the previous one, so
+ * a re-registered plugin does not leave the tools bound to a dead instance.
+ */
+export function setWebSearchExecutor(execute: WebSearchExecutor): void {
+  getWebSearchRuntime().execute = execute;
+}
+
 /** Drop the memoized runtime so the next {@link getWebSearchRuntime} rebuilds it. */
 export function resetWebSearchRuntime(): void {
   runtime = undefined;
 }
+
+/**
+ * Run one idempotent read through the shared executor and unwrap it.
+ *
+ * `execute()` never throws, so a failed call arrives as `{ ok: false }` with
+ * a status the interceptors already sanitized; it is logged here and re-raised
+ * as a stable {@link ExecutionError} so an upstream message never becomes the
+ * caller's error text. `signal` is the caller's own cancellation (an agent
+ * run, a request teardown); it is merged with the signal the timeout
+ * interceptor supplies so either one unwinds the I/O.
+ */
+export async function executeRead<T>(
+  operation: string,
+  settings: WebSearchExecutionSettings,
+  fn: (signal?: AbortSignal) => Promise<T>,
+  signal?: AbortSignal,
+): Promise<T> {
+  const { execute } = getWebSearchRuntime();
+  const result = await execute(
+    (executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)),
+    settings,
+  );
+  if (result.ok) return result.data;
+  // A caller that cancelled is not a failure worth reporting as one.
+  if (signal?.aborted) throw ExecutionError.canceled();
+  logger.warn("execution-failed", {
+    operation,
+    status: result.status,
+    error: result.message,
+  });
+  throw new ExecutionError(`web-search: ${operation} failed`, {
+    context: { operation, status: result.status },
+  });
+}

package/src/schema.ts

@@ -20,6 +20,28 @@
 import { string } from "@dbx-tools/shared-core";
 import { z } from "zod";
 
+/**
+ * Description the model reads for `web_search`. Shared by the Mastra tool and
+ * the AppKit tool provider so both hosts describe the tool identically.
+ */
+export const WEB_SEARCH_TOOL_DESCRIPTION = string.toDescription(`
+  Search the web for current information and get an answer synthesized from
+  live results, with the sources it used. Pass a natural-language query;
+  the search runs inside a web-search-capable model (chosen independently
+  of your own model). Optionally pass a model name to use a specific
+  web-search model. Use it whenever a question needs up-to-date or external
+  information you don't already have.
+`);
+
+/** Description the model reads for `web_fetch`. Shared like {@link WEB_SEARCH_TOOL_DESCRIPTION}. */
+export const WEB_FETCH_TOOL_DESCRIPTION = string.toDescription(`
+  Fetch a single web page and return its readable contents. Pass an
+  absolute URL (including https://); set format to "html" for raw markup
+  instead of extracted text. Use it to read a page returned by web_search
+  or provided by the user. Content is length-capped; fetching a URL outside
+  the configured allow-list is refused.
+`);
+
 /** Schema for the `web_search` tool input. */
 export const webSearchRequestSchema = z.object({
   query: z

package/src/scrape.ts

@@ -21,6 +21,9 @@
 import { log } from "@dbx-tools/shared-core";
 import { gotScraping } from "got-scraping";
 import type { ResolvedWebSearchConfig } from "./config";
+import { scrapeSearchExecuteDefaults, toCallSettings } from "./defaults";
+import { htmlFragmentToText } from "./html-text";
+import { executeRead } from "./runtime";
 import type { WebSearchCitation, WebSearchRequest, WebSearchResult } from "./schema";
 
 const logger = log.logger("web-search/scrape");
@@ -28,20 +31,6 @@ const logger = log.logger("web-search/scrape");
 /** DuckDuckGo's no-JS HTML results endpoint (queried via GET). */
 const DDG_HTML_URL = "https://html.duckduckgo.com/html/";
 
-/** Strip HTML tags and decode the few entities DDG emits in titles/snippets. */
-function stripTags(html: string): string {
-  return html
-    .replace(/<[^>]+>/g, "")
-    .replace(/&amp;/g, "&")
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&#x27;|&#39;/g, "'")
-    .replace(/&nbsp;/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
 /**
  * DDG wraps result URLs in a redirect (`//duckduckgo.com/l/?uddg=<encoded>`).
  * Unwrap to the real destination; leave already-absolute URLs untouched.
@@ -66,12 +55,12 @@ function parseDdgHtml(html: string): WebSearchCitation[] {
   const snippetRe = /<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/g;
   const snippets: string[] = [];
   let sm: RegExpExecArray | null;
-  while ((sm = snippetRe.exec(html)) !== null) snippets.push(stripTags(sm[1] ?? ""));
+  while ((sm = snippetRe.exec(html)) !== null) snippets.push(htmlFragmentToText(sm[1] ?? ""));
   let am: RegExpExecArray | null;
   let i = 0;
   while ((am = anchorRe.exec(html)) !== null) {
     const url = unwrapDdgUrl(am[1] ?? "");
-    const title = stripTags(am[2] ?? "");
+    const title = htmlFragmentToText(am[2] ?? "");
     if (!url || !title) continue;
     const snippet = snippets[i] ?? "";
     citations.push({ url, title, ...(snippet ? { snippet } : {}) });
@@ -84,21 +73,40 @@ function parseDdgHtml(html: string): WebSearchCitation[] {
  * Run a scraping search over DuckDuckGo. Returns the same
  * {@link WebSearchResult} shape as the native path, with `model` set to
  * `"scrape:duckduckgo"` so callers can tell how the result was produced.
- * Citations are filtered through the configured URL allow-list.
+ * Citations are filtered through the configured URL allow-list. `signal`
+ * cancels the in-flight request.
  */
 export async function runScrapeSearch(
   request: WebSearchRequest,
   config: ResolvedWebSearchConfig,
+  signal?: AbortSignal,
 ): Promise<WebSearchResult> {
-  const response = await gotScraping({
-    url: `${DDG_HTML_URL}?q=${encodeURIComponent(request.query)}`,
-    method: "GET",
-    timeout: { request: config.timeoutMs },
-    throwHttpErrors: false,
-    followRedirect: true,
-  });
-  const body = typeof response.body === "string" ? response.body : String(response.body ?? "");
-  const all = parseDdgHtml(body);
+  const page = await executeRead(
+    "scrape-search",
+    toCallSettings(scrapeSearchExecuteDefaults, config.timeoutMs, [
+      "web-search",
+      "scrape",
+      request.query,
+    ]),
+    async (executeSignal): Promise<{ body: string; statusCode: number }> => {
+      const response = await gotScraping({
+        url: `${DDG_HTML_URL}?q=${encodeURIComponent(request.query)}`,
+        method: "GET",
+        // got's own timeout aborts the socket and reports which phase timed
+        // out; the interceptor timeout bounds the whole attempt around it.
+        timeout: { request: config.timeoutMs },
+        throwHttpErrors: false,
+        followRedirect: true,
+        ...(executeSignal ? { signal: executeSignal } : {}),
+      });
+      return {
+        body: typeof response.body === "string" ? response.body : String(response.body ?? ""),
+        statusCode: response.statusCode,
+      };
+    },
+    signal,
+  );
+  const all = parseDdgHtml(page.body);
   const permitted = all.filter((c) => config.allowList.allows(c.url));
   const citations = permitted.slice(0, config.maxCitations);
   const answer =
@@ -112,7 +120,7 @@ export async function runScrapeSearch(
     query: request.query,
     found: all.length,
     returned: citations.length,
-    status: response.statusCode,
+    status: page.statusCode,
   });
   return { query: request.query, answer, citations, model: "scrape:duckduckgo" };
 }

package/src/search.ts

@@ -10,22 +10,31 @@
  *      agent's chat model (the agent may run on a model without web search).
  *      A pinned `model` (request or config) is fuzzy-matched; otherwise the
  *      configured fallback order (Gemini, then GPT) is walked to the first
- *      web-search-capable endpoint that exists in the workspace. An explicit
- *      but unsupported model is a hard error, not a silent fallback.
+ *      web-search-capable endpoint that exists. An explicit but unsupported
+ *      model is a hard error, not a silent fallback.
  *   2. POSTs to the provider's REST surface (`/serving-endpoints/responses`
  *      for OpenAI, `/serving-endpoints/chat/completions` for Gemini) with the
- *      mapped tool spec, using the OBO-scoped workspace client.
+ *      mapped tool spec, authenticated as the OBO caller.
  *   3. Returns the synthesized answer plus the cited sources, with citations
  *      silently filtered through the configured URL allow-list.
  *
  * @module
  */
 
-import { resolve, serving } from "@dbx-tools/model";
-import { error, log } from "@dbx-tools/shared-core";
-import { openaiResponses } from "@dbx-tools/shared-model";
-import type { ResolvedWebSearchConfig } from "./config";
+import {
+  ConfigurationError,
+  ConnectionError,
+  ExecutionError,
+  getExecutionContext,
+  ValidationError,
+} from "@databricks/appkit";
+import { invoke, resolve, serving } from "@dbx-tools/model";
+import { log, object, string } from "@dbx-tools/shared-core";
+import { openaiChat, openaiResponses } from "@dbx-tools/shared-model";
+import { MODEL_ENV, SERVING_ENDPOINT_ENV, type ResolvedWebSearchConfig } from "./config";
+import { toCallSettings, webSearchExecuteDefaults } from "./defaults";
 import { detectWebSearchProvider, supportsWebSearch, webSearchToolSpec } from "./provider";
+import { executeRead } from "./runtime";
 import type { WebSearchCitation, WebSearchRequest, WebSearchResult } from "./schema";
 import { runScrapeSearch } from "./scrape";
 
@@ -34,12 +43,38 @@ const logger = log.logger("web-search/search");
 const { resolveModel } = resolve;
 const { listServingEndpoints } = serving;
 
+/**
+ * How deep the grounding-metadata walk descends. Gemini nests its sources a
+ * handful of levels down and the shape varies by model version, so the walk
+ * is generic; the bound is what keeps a pathological payload from turning it
+ * into a full traversal of the response.
+ */
+const MAX_GROUNDING_WALK_DEPTH = 6;
+
+/** Lowest HTTP status treated as a server-side (retryable) serving failure. */
+const SERVER_ERROR_STATUS = 500;
+
+/** Status Model Serving uses to shed load; retryable like a 5xx. */
+const RATE_LIMITED_STATUS = 429;
+
 /** Context a search needs from the caller: the OBO client + workspace host. */
 export interface WebSearchContext {
   client: WorkspaceClientLike;
   host: string;
 }
 
+/**
+ * Resolve the OBO workspace client + host from the active AppKit execution
+ * context. Inside `agent.stream`'s `asUser(req)` scope this hits the serving
+ * endpoint as the requesting user; outside a user context AppKit falls back to
+ * the service principal.
+ */
+export async function resolveWebSearchContext(): Promise<WebSearchContext> {
+  const ctx = getExecutionContext();
+  const host = (await ctx.client.config.getHost()).toString();
+  return { client: ctx.client, host };
+}
+
 /**
  * Resolve a web-search-capable model against the LIVE workspace catalogue - so
  * we never return an endpoint id that isn't actually deployed (the "endpoint
@@ -51,9 +86,13 @@ export interface WebSearchContext {
  *
  * Returns the chosen endpoint id, or `null` when the workspace has no
  * web-search-capable model deployed (the caller then uses the scrape
- * fallback). An explicit request that resolves to an unsupported / absent
- * model throws, so a deliberate bad pin surfaces rather than silently
- * degrading.
+ * fallback). A pin the caller chose deliberately - the request's `model`, the
+ * plugin's `model`, or `WEB_SEARCH_MODEL` - throws when it resolves to an
+ * unsupported / absent endpoint, so a bad pin surfaces rather than silently
+ * degrading. A pin inherited from the shared `DATABRICKS_SERVING_ENDPOINT_NAME`
+ * binding is only a preference: that endpoint is the app's serving endpoint,
+ * not necessarily a web-search-capable one, so an unusable value falls through
+ * to the fallback order.
  */
 async function resolveWebSearchModel(
   ctx: WebSearchContext,
@@ -64,6 +103,8 @@ async function resolveWebSearchModel(
   // Only deployed, web-search-capable endpoints are candidates.
   const capable = endpoints.filter((e) => supportsWebSearch(e.name));
   const pinned = requested ?? config.model;
+  const pinIsDeliberate =
+    requested !== undefined || config.modelSource === "config" || config.modelSource === MODEL_ENV;
 
   if (pinned) {
     // Resolve the explicit ask within the capable set only.
@@ -74,19 +115,33 @@ async function resolveWebSearchModel(
     });
     // resolveModel returns the input verbatim on no match; require it to be a
     // real capable endpoint so a bad pin is a clear error, not a phantom call.
-    if (!capable.some((e) => e.name === modelId) || !supportsWebSearch(modelId)) {
-      throw new Error(
-        `web-search: requested model "${pinned}" is not a deployed web-search-capable endpoint. ` +
-          `Deployed GPT/Gemini endpoints: [${capable.map((e) => e.name).join(", ") || "none"}].`,
+    const usable = capable.some((e) => e.name === modelId) && supportsWebSearch(modelId);
+    if (usable) return modelId;
+    const deployed = capable.map((e) => e.name).join(", ") || "none";
+    if (!pinIsDeliberate) {
+      logger.info("shared-endpoint-not-web-capable", {
+        envVar: SERVING_ENDPOINT_ENV,
+        deployed,
+      });
+    } else if (requested !== undefined) {
+      throw ValidationError.invalidValue(
+        "model",
+        pinned,
+        `a deployed web-search-capable endpoint (deployed: ${deployed})`,
+      );
+    } else {
+      throw ConfigurationError.resourceNotFound(
+        "Web-search-capable serving endpoint",
+        `Deployed web-search-capable endpoints: ${deployed}. Set model or ${MODEL_ENV} to one of them.`,
       );
     }
-    return modelId;
   }
 
   if (capable.length === 0) return null;
 
-  // Nothing pinned: prefer the configured fallback order (Gemini, then GPT)
-  // when those ids are actually deployed; else take the best capable endpoint.
+  // Nothing usable pinned: prefer the configured fallback order (Gemini, then
+  // GPT) when those ids are actually deployed; else take the best capable
+  // endpoint.
   const { modelId } = resolveModel(capable, {
     fallbacks: config.modelFallbacks,
     fuzzy: config.fuzzy,
@@ -95,29 +150,61 @@ async function resolveWebSearchModel(
   return capable.some((e) => e.name === modelId) ? modelId : (capable[0]?.name ?? null);
 }
 
-/** POST a serving request through the OBO client and return the parsed JSON. */
+/**
+ * POST a serving request as the OBO caller and return the parsed JSON body.
+ *
+ * Auth headers are minted per call from the OBO client's SDK config, which
+ * refreshes the token when it is close to expiry, so the request carries the
+ * requesting user's identity.
+ *
+ * This is the one Databricks call in the repo that does not go through
+ * `apiClient.request` + `databricks.toContext` (which does forward
+ * cancellation). Retry classification here has to distinguish a load-shed or
+ * server fault from this request's own 4xx, and `fetch` exposes the HTTP status
+ * directly; the SDK raises an `ApiError` that carries the status under
+ * inconsistent keys, which is guesswork by comparison.
+ */
 async function postServing(
   ctx: WebSearchContext,
-  path: string,
+  url: string,
   body: unknown,
+  config: ResolvedWebSearchConfig,
+  cacheKey: readonly (string | number)[],
+  signal?: AbortSignal,
 ): Promise<Record<string, unknown>> {
-  const res = await ctx.client.apiClient.request({
-    path,
-    method: "POST",
-    headers: new Headers({ Accept: "application/json", "Content-Type": "application/json" }),
-    raw: false,
-    payload: body,
-  });
-  return (res ?? {}) as Record<string, unknown>;
+  const payload = await executeRead(
+    "serving-request",
+    toCallSettings(webSearchExecuteDefaults, config.timeoutMs, cacheKey),
+    async (executeSignal): Promise<unknown> => {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          ...(await invoke.authHeaders(ctx.client)),
+          Accept: "application/json",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+        ...(executeSignal ? { signal: executeSignal } : {}),
+      });
+      if (!response.ok) {
+        // Load-shedding and server faults are worth another attempt; a 4xx is
+        // this request's own problem, so it must not be retried.
+        const retryable =
+          response.status >= SERVER_ERROR_STATUS || response.status === RATE_LIMITED_STATUS;
+        const message = `web-search: Model Serving rejected the search request (HTTP ${response.status})`;
+        throw retryable
+          ? new ConnectionError(message, { context: { status: response.status } })
+          : new ExecutionError(message, { context: { status: response.status } });
+      }
+      return response.json();
+    },
+    signal,
+  );
+  return object.isRecord(payload) ? payload : {};
 }
 
 /* --------------------------- response extraction --------------------------- */
 
-/** Coerce an unknown to a trimmed string, or "" . */
-function str(v: unknown): string {
-  return typeof v === "string" ? v.trim() : "";
-}
-
 /**
  * Extract answer text + citations from an OpenAI Responses API payload, via the
  * shared reader in `@dbx-tools/shared-model` (the same module the model-proxy
@@ -141,21 +228,22 @@ function fromChatPayload(payload: Record<string, unknown>): {
   answer: string;
   citations: WebSearchCitation[];
 } {
-  const choices = Array.isArray(payload.choices) ? (payload.choices as unknown[]) : [];
-  const message = (choices[0] as { message?: Record<string, unknown> })?.message ?? {};
-  const answer = str(message.content);
+  const choices = Array.isArray(payload.choices) ? payload.choices : [];
+  const first = choices[0];
+  const message = object.isRecord(first) && object.isRecord(first.message) ? first.message : {};
+  const answer = openaiChat.chatContentToText(message.content);
   const citations: WebSearchCitation[] = [];
   // Best-effort grounding extraction: walk any nested object for {uri|url,title}.
   const seen = new Set<string>();
   const visit = (v: unknown, depth: number): void => {
-    if (depth > 6 || v === null || typeof v !== "object") return;
-    const o = v as Record<string, unknown>;
-    const url = str(o.url) || str(o.uri);
+    if (depth > MAX_GROUNDING_WALK_DEPTH || !object.isRecord(v)) return;
+    const url = string.trimToEmpty(v.url) || string.trimToEmpty(v.uri);
     if (url && !seen.has(url)) {
       seen.add(url);
-      citations.push({ url, ...(str(o.title) ? { title: str(o.title) } : {}) });
+      const title = string.trimToEmpty(v.title);
+      citations.push({ url, ...(title ? { title } : {}) });
     }
-    for (const val of Object.values(o)) {
+    for (const val of Object.values(v)) {
       if (Array.isArray(val)) val.forEach((x) => visit(x, depth + 1));
       else if (val && typeof val === "object") visit(val, depth + 1);
     }
@@ -170,11 +258,14 @@ function fromChatPayload(payload: Record<string, unknown>): {
  * workspace has no such endpoint AND the scrape fallback is enabled, falls
  * back to a DuckDuckGo scrape so the tool still returns results instead of
  * erroring. Citations are filtered through the configured URL allow-list.
+ *
+ * `signal` cancels the whole call, including the in-flight serving request.
  */
 export async function runWebSearch(
   request: WebSearchRequest,
   config: ResolvedWebSearchConfig,
   ctx: WebSearchContext,
+  signal?: AbortSignal,
 ): Promise<WebSearchResult> {
   const modelId = await resolveWebSearchModel(ctx, config, request.model);
 
@@ -182,22 +273,21 @@ export async function runWebSearch(
     // No native web-search model deployed in this workspace.
     if (config.scrapeFallback) {
       logger.info("no-native-model:scrape-fallback", { query: request.query });
-      return runScrapeSearch(request, config);
+      return runScrapeSearch(request, config, signal);
     }
-    throw new Error(
-      "web-search: no web-search-capable model (GPT/Gemini) is deployed in this workspace, " +
-        "and the scrape fallback is disabled. Deploy a supported endpoint, set `model` / " +
-        "WEB_SEARCH_MODEL, or enable the fallback (WEB_SEARCH_SCRAPE_FALLBACK=1).",
+    throw ConfigurationError.resourceNotFound(
+      "Web-search-capable serving endpoint",
+      "No GPT/Gemini endpoint is deployed in this workspace and the scrape fallback is " +
+        `disabled. Deploy a supported endpoint, set model or ${MODEL_ENV}, or enable the ` +
+        "fallback (WEB_SEARCH_SCRAPE_FALLBACK=1).",
     );
   }
 
   const provider = detectWebSearchProvider(modelId)!; // guaranteed by resolve step
   const spec = webSearchToolSpec(provider, config.webSearchTools);
 
-  const path =
-    spec.api === "responses"
-      ? "/serving-endpoints/responses"
-      : "/serving-endpoints/chat/completions";
+  const url =
+    spec.api === "responses" ? invoke.responsesUrl(ctx.host) : invoke.chatCompletionsUrl(ctx.host);
   const body =
     spec.api === "responses"
       ? {
@@ -211,13 +301,14 @@ export async function runWebSearch(
           tools: [spec.tool],
         };
 
-  let payload: Record<string, unknown>;
-  try {
-    payload = await postServing(ctx, path, body);
-  } catch (err) {
-    logger.warn("serving-error", { model: modelId, provider, error: error.errorMessage(err) });
-    throw err;
-  }
+  const payload = await postServing(
+    ctx,
+    url,
+    body,
+    config,
+    ["web-search", "serving", spec.api, modelId, request.query],
+    signal,
+  );
 
   const { answer, citations } =
     spec.api === "responses" ? fromResponsesPayload(payload) : fromChatPayload(payload);