webfox 0.0.0-test.0 → 4.0.0

package/dist/adapter-67TIISDW.js

@@ -0,0 +1,753 @@
+import {
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  httpError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/brave/adapter.ts
+var DEFAULT_BASE_URL = "https://api.search.brave.com";
+var BRAVE_API_VERSION = void 0;
+var braveImplementation = {
+  async search(query, maxResults, config, context, options) {
+    const apiKey = requireKey(config.credentials?.search, "Brave search");
+    const callOptions = { ...options ?? {} };
+    const mode = readMode(callOptions.mode);
+    if (mode === "llm_context")
+      return await llmContext(
+        query,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "news")
+      return await news(
+        query,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "videos")
+      return await videos(
+        query,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "images")
+      return await images(
+        query,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    if (mode === "places")
+      return await places(
+        query,
+        maxResults,
+        config,
+        context,
+        apiKey,
+        callOptions
+      );
+    return await web(query, maxResults, config, context, apiKey, callOptions);
+  },
+  async answer(query, config, context, options) {
+    const raw = {
+      ...options ?? {}
+    };
+    return await completion(query, config, context, buildAnswerRequest(raw));
+  },
+  async research(input, config, context, options) {
+    const raw = {
+      ...options ?? {}
+    };
+    return await completion(input, config, context, buildResearchRequest(raw));
+  }
+};
+function requireKey(ref, label) {
+  const key = ref;
+  if (!key) throw new Error(`${label} is missing an API key`);
+  return key;
+}
+function base(config) {
+  return (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+function clamp(n, max = 20) {
+  return Math.max(1, Math.min(max, Math.trunc(n || 0)));
+}
+function readMode(v) {
+  return v === "llm_context" || v === "news" || v === "videos" || v === "images" || v === "places" ? v : "web";
+}
+function obj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function arr(v) {
+  return Array.isArray(v) ? v : [];
+}
+function str(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function pick(source, allowed) {
+  return Object.fromEntries(
+    allowed.filter((k) => source[k] !== void 0).map((k) => [k, source[k]])
+  );
+}
+function mergeOptions(options, key, allowed) {
+  return pick({ ...obj(options.common), ...obj(options[key]) }, allowed);
+}
+function headers(key, json = false) {
+  const result = { "X-Subscription-Token": key };
+  if (BRAVE_API_VERSION) {
+    result["Api-Version"] = BRAVE_API_VERSION;
+  }
+  if (json) {
+    result["content-type"] = "application/json";
+  }
+  return result;
+}
+function url(config, path, params) {
+  const u = new URL(`${base(config)}${path}`);
+  for (const [k, v] of Object.entries(params))
+    if (v !== void 0)
+      u.searchParams.set(k, Array.isArray(v) ? v.join(",") : String(v));
+  return u;
+}
+async function httpError2(response) {
+  const text = (await response.text()).trim();
+  return httpError(
+    response,
+    `Brave API request failed (${response.status}${response.statusText ? ` ${response.statusText}` : ""})${text ? `: ${text}` : "."}`
+  );
+}
+async function web(query, maxResults, config, context, key, options) {
+  const params = {
+    q: query,
+    count: clamp(maxResults),
+    text_decorations: false,
+    ...mergeOptions(options, "web", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "goggles",
+      "extra_snippets",
+      "offset",
+      "enable_rich_callback"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/web/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw await httpError2(r);
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(obj(p.web).results).map((e) => {
+      const x = obj(e);
+      const u = str(x.url) ?? "";
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          str(x.description) ?? arr(x.extra_snippets).join(" ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults))
+  };
+}
+async function llmContext(query, maxResults, config, context, key, options) {
+  const params = {
+    q: query,
+    count: clamp(maxResults),
+    maximum_number_of_urls: clamp(maxResults),
+    maximum_number_of_tokens: 8192,
+    enable_source_metadata: true,
+    ...mergeOptions(options, "llmContext", [
+      "count",
+      "maximum_number_of_urls",
+      "maximum_number_of_tokens",
+      "maximum_number_of_snippets",
+      "maximum_number_of_tokens_per_url",
+      "maximum_number_of_snippets_per_url",
+      "context_threshold_mode",
+      "enable_local",
+      "enable_source_metadata",
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "goggles"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/llm/context", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw await httpError2(r);
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: collectLlmContextEntries(obj(p.grounding)).map((e) => {
+      const x = obj(e);
+      const snippets = arr(x.snippets).map(String);
+      const source = obj(x.source);
+      const u = str(x.url) ?? str(source.url) ?? "";
+      return {
+        title: str(x.title) ?? str(x.name) ?? str(source.title) ?? (u || "Untitled"),
+        url: u,
+        snippet: trimSnippet(snippets.join("\n\n"), 1200),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults))
+  };
+}
+function collectLlmContextEntries(grounding) {
+  const entries = [];
+  for (const value of [grounding.generic, grounding.map]) {
+    entries.push(...arr(value).map(obj));
+  }
+  const poiEntries = Array.isArray(grounding.poi) ? grounding.poi.map(obj) : [obj(grounding.poi)];
+  entries.push(...poiEntries.filter((entry) => Object.keys(entry).length > 0));
+  return entries;
+}
+async function news(query, maxResults, config, context, key, options) {
+  const params = {
+    q: query,
+    count: clamp(maxResults, 50),
+    ...mergeOptions(options, "news", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "goggles",
+      "extra_snippets",
+      "offset",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/news/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw await httpError2(r);
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(p.results).map((e) => {
+      const x = obj(e);
+      const u = str(x.url) ?? "";
+      const source = str(x.source) ?? str(x.source_name);
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          [
+            str(x.description) ?? arr(x.extra_snippets).join(" "),
+            source,
+            str(x.age) ?? str(x.page_age)
+          ].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults, 50))
+  };
+}
+async function videos(query, maxResults, config, context, key, options) {
+  const params = {
+    q: query,
+    count: clamp(maxResults, 50),
+    ...mergeOptions(options, "videos", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "freshness",
+      "safesearch",
+      "spellcheck",
+      "offset",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/videos/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw await httpError2(r);
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(p.results).map((e) => {
+      const x = obj(e);
+      const u = str(x.url) ?? "";
+      const video = obj(x.video);
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          [
+            str(x.description),
+            str(video.creator) ?? str(x.creator),
+            str(video.duration) ?? str(x.duration),
+            num(video.views) ? `${num(video.views)} views` : void 0,
+            str(x.age) ?? str(x.page_age)
+          ].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults, 50))
+  };
+}
+async function images(query, maxResults, config, context, key, options) {
+  const params = {
+    q: query,
+    count: clamp(maxResults),
+    ...mergeOptions(options, "images", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "safesearch",
+      "spellcheck",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/images/search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw await httpError2(r);
+  const p = obj(await r.json());
+  return {
+    provider: "brave",
+    results: arr(p.results).map((e) => {
+      const x = obj(e);
+      const props = obj(x.properties);
+      const page = str(x.url) ?? str(x.source) ?? str(props.url) ?? "";
+      const image = str(props.url);
+      return {
+        title: str(x.title) || page || "Untitled",
+        url: page || image || "",
+        snippet: trimSnippet(
+          [str(x.description), str(x.publisher), image].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: x
+      };
+    }).slice(0, clamp(maxResults))
+  };
+}
+async function places(query, maxResults, config, context, key, options) {
+  const placeOptions = obj(options.places);
+  const params = {
+    q: query,
+    count: clamp(maxResults),
+    ...mergeOptions(options, "places", [
+      "country",
+      "search_lang",
+      "ui_lang",
+      "latitude",
+      "longitude",
+      "location",
+      "radius",
+      "units",
+      "safesearch",
+      "spellcheck",
+      "geoloc",
+      "count"
+    ])
+  };
+  const r = await fetch(url(config, "/res/v1/local/place_search", params), {
+    headers: headers(key),
+    signal: context.signal
+  });
+  if (!r.ok) throw await httpError2(r);
+  const p = obj(await r.json());
+  const rows = arr(p.results).slice(0, clamp(maxResults));
+  const ids = rows.map((e) => str(obj(e).id)).filter((id) => id !== void 0);
+  const [detailsById, descriptionsById] = await Promise.all([
+    placeOptions.includeDetails && ids.length > 0 ? fetchPlaceDetails(
+      config,
+      context,
+      key,
+      ids,
+      pick(params, ["search_lang", "ui_lang", "units"])
+    ) : Promise.resolve(/* @__PURE__ */ new Map()),
+    placeOptions.includeDescriptions && ids.length > 0 ? fetchPlaceDescriptions(config, context, key, ids) : Promise.resolve(/* @__PURE__ */ new Map())
+  ]);
+  return {
+    provider: "brave",
+    results: rows.map((e) => {
+      const x = obj(e);
+      const id = str(x.id);
+      const details = id ? detailsById.get(id) : void 0;
+      const description = id ? descriptionsById.get(id) : void 0;
+      const u = str(x.url) ?? str(x.provider_url) ?? "";
+      return {
+        title: str(x.title) || u || "Untitled",
+        url: u,
+        snippet: trimSnippet(
+          [
+            placeDescriptionText(description) ?? str(x.description),
+            placeAddress(x, details),
+            arr(x.categories).join(", "),
+            placeRating(x, details)
+          ].filter(Boolean).join(" \u2014 ")
+        ),
+        metadata: {
+          ...x,
+          ...details ? { poiDetails: details } : {},
+          ...description ? { poiDescription: description } : {}
+        }
+      };
+    })
+  };
+}
+async function fetchPlaceDetails(config, context, key, ids, options) {
+  const r = await fetch(
+    urlWithRepeatedArrays(config, "/res/v1/local/pois", {
+      ids: ids.slice(0, 20),
+      ...options
+    }),
+    {
+      headers: headers(key),
+      signal: context.signal
+    }
+  );
+  if (!r.ok) throw await httpError2(r);
+  return indexById(arr(obj(await r.json()).results));
+}
+async function fetchPlaceDescriptions(config, context, key, ids) {
+  const r = await fetch(
+    urlWithRepeatedArrays(config, "/res/v1/local/descriptions", {
+      ids: ids.slice(0, 20)
+    }),
+    {
+      headers: headers(key),
+      signal: context.signal
+    }
+  );
+  if (!r.ok) throw await httpError2(r);
+  return indexById(arr(obj(await r.json()).results));
+}
+function urlWithRepeatedArrays(config, path, params) {
+  const u = new URL(`${base(config)}${path}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0) continue;
+    if (Array.isArray(v)) {
+      for (const item of v) {
+        u.searchParams.append(k, String(item));
+      }
+    } else {
+      u.searchParams.set(k, String(v));
+    }
+  }
+  return u;
+}
+function indexById(values) {
+  const result = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const entry = obj(value);
+    const id = str(entry.id);
+    if (id) {
+      result.set(id, entry);
+    }
+  }
+  return result;
+}
+function placeDescriptionText(description) {
+  if (!description) return void 0;
+  return str(description.description) ?? str(description.text) ?? str(description.summary) ?? str(obj(description.description).text);
+}
+function placeAddress(place, details) {
+  return str(place.address) ?? str(obj(place.postal_address).displayAddress) ?? str(details?.address) ?? str(obj(details?.postal_address).displayAddress);
+}
+function placeRating(place, details) {
+  const rating = num(place.rating) ?? num(obj(place.rating).ratingValue) ?? num(details?.rating) ?? num(obj(details?.rating).ratingValue);
+  return rating === void 0 ? void 0 : `Rating: ${rating}`;
+}
+function buildAnswerRequest(raw) {
+  const webSearchOptions = pick(raw, [
+    "country",
+    "language",
+    "safesearch",
+    "enable_entities",
+    "enable_citations"
+  ]);
+  if (webSearchOptions.enable_citations === void 0) {
+    webSearchOptions.enable_citations = true;
+  }
+  const stream = webSearchOptions.enable_citations === true || webSearchOptions.enable_entities === true;
+  return {
+    stream,
+    ...pick(raw, ["model", "max_completion_tokens", "metadata", "seed"]),
+    web_search_options: webSearchOptions
+  };
+}
+function buildResearchRequest(raw) {
+  const webSearchOptions = pick(raw, [
+    "country",
+    "language",
+    "safesearch",
+    "enable_entities",
+    "research_allow_thinking",
+    "research_maximum_number_of_tokens_per_query",
+    "research_maximum_number_of_queries",
+    "research_maximum_number_of_iterations",
+    "research_maximum_number_of_seconds",
+    "research_maximum_number_of_results_per_query"
+  ]);
+  webSearchOptions.enable_research = true;
+  webSearchOptions.enable_citations = false;
+  return {
+    stream: true,
+    ...pick(raw, ["model", "max_completion_tokens", "metadata", "seed"]),
+    web_search_options: webSearchOptions
+  };
+}
+async function completion(input, config, context, request) {
+  const key = requireKey(config.credentials?.answers, "Brave Answers");
+  const body = {
+    model: "brave",
+    messages: [{ role: "user", content: input }],
+    ...request
+  };
+  const r = await fetch(`${base(config)}/res/v1/chat/completions`, {
+    method: "POST",
+    headers: headers(key, true),
+    body: JSON.stringify(body),
+    signal: context.signal
+  });
+  if (!r.ok) throw await httpError2(r);
+  const text = await r.text();
+  const parsed = body.stream === false ? parseAnswerJson(text) : parseAnswerStream(text);
+  const lines = [parsed.answer.trim() || text.trim()];
+  if (parsed.citations.length) {
+    lines.push("", "Sources:");
+    parsed.citations.forEach((c, i) => {
+      lines.push(`${i + 1}. ${c.title ?? c.url ?? "Source"}`);
+      if (c.url) lines.push(`   ${c.url}`);
+    });
+  }
+  const metadata = buildAnswerMetadata(parsed);
+  return {
+    provider: "brave",
+    text: lines.join("\n").trimEnd(),
+    itemCount: parsed.citations.length,
+    ...metadata ? { metadata } : {}
+  };
+}
+function buildAnswerMetadata(parsed) {
+  const metadata = {};
+  if (parsed.usage) {
+    metadata.usage = parsed.usage;
+  }
+  if (parsed.entities.length) {
+    metadata.entities = parsed.entities;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function parseAnswerJson(text) {
+  const payload = obj(JSON.parse(text));
+  const choice = obj(arr(payload.choices)[0]);
+  const message = obj(choice.message);
+  const content = str(message.content) ?? "";
+  const tags = extractBraveTags(content);
+  return {
+    answer: tags.text,
+    citations: dedupeCitations(tags.citations),
+    entities: tags.entities,
+    usage: payload.usage ?? tags.usage
+  };
+}
+function parseAnswerStream(text) {
+  let rawAnswer = "";
+  for (const line of text.split(/\r?\n/)) {
+    const data = line.startsWith("data:") ? line.slice(5).trim() : line.trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      const parsed = obj(JSON.parse(data));
+      const choice = obj(arr(parsed.choices)[0]);
+      const delta = str(obj(choice.delta).content);
+      if (delta) {
+        rawAnswer += delta;
+      }
+    } catch {
+      rawAnswer += data;
+    }
+  }
+  const tags = extractBraveTags(rawAnswer);
+  return {
+    answer: tags.text,
+    citations: dedupeCitations(tags.citations),
+    entities: tags.entities,
+    usage: tags.usage
+  };
+}
+function extractBraveTags(text) {
+  const citations = [];
+  const entities = [];
+  let usage;
+  let cleaned = "";
+  let offset = 0;
+  while (offset < text.length) {
+    const tagStart = text.indexOf("<", offset);
+    if (tagStart === -1) {
+      cleaned += text.slice(offset);
+      break;
+    }
+    const parsedTag = readBraveTagStart(text, tagStart);
+    if (!parsedTag) {
+      cleaned += text.slice(offset, tagStart + 1);
+      offset = tagStart + 1;
+      continue;
+    }
+    const jsonEnd = findJsonValueEnd(text, parsedTag.jsonStart);
+    if (jsonEnd === -1) {
+      cleaned += text.slice(offset);
+      break;
+    }
+    cleaned += text.slice(offset, tagStart);
+    const json = text.slice(parsedTag.jsonStart, jsonEnd + 1);
+    try {
+      const parsed = JSON.parse(json);
+      if (parsedTag.tag === "answer") {
+        cleaned += str(parsed.answer) ?? str(parsed.text) ?? "";
+      } else if (parsedTag.tag === "citation") {
+        citations.push({
+          title: str(parsed.title),
+          url: str(parsed.url)
+        });
+      } else if (parsedTag.tag === "enum_item") {
+        const item = obj(parsed);
+        entities.push(item);
+        cleaned += str(item.original_tokens) ?? str(item.name) ?? str(item.href) ?? "";
+      } else if (parsedTag.tag === "usage") {
+        usage = parsed;
+      }
+    } catch {
+    }
+    const closing = `</${parsedTag.tag}>`;
+    const abbreviatedClosing = `</${parsedTag.tag}`;
+    if (text.startsWith(closing, jsonEnd + 1)) {
+      offset = jsonEnd + 1 + closing.length;
+    } else if (text.startsWith(abbreviatedClosing, jsonEnd + 1)) {
+      offset = jsonEnd + 1 + abbreviatedClosing.length;
+    } else {
+      offset = jsonEnd + 1;
+    }
+  }
+  return { text: cleaned, citations, entities, usage };
+}
+var BRAVE_STRUCTURED_TAGS = /* @__PURE__ */ new Set([
+  "analyzing",
+  "answer",
+  "blindspots",
+  "citation",
+  "enum_item",
+  "progress",
+  "queries",
+  "thinking",
+  "usage"
+]);
+function readBraveTagStart(text, tagStart) {
+  const match = /^<([A-Za-z_][A-Za-z0-9_-]*)(>)?[{[]/.exec(
+    text.slice(tagStart)
+  );
+  if (!match) return void 0;
+  const tag = match[1];
+  if (!BRAVE_STRUCTURED_TAGS.has(tag)) return void 0;
+  return {
+    tag,
+    jsonStart: tagStart + match[0].length - 1
+  };
+}
+function findJsonValueEnd(text, start) {
+  const first = text[start];
+  const closing = first === "{" ? "}" : first === "[" ? "]" : void 0;
+  if (!closing) return -1;
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index++) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === "{") {
+      stack.push("}");
+    } else if (char === "[") {
+      stack.push("]");
+    } else if (char === "}" || char === "]") {
+      if (stack.pop() !== char) return -1;
+      if (stack.length === 0) return index;
+    }
+  }
+  return -1;
+}
+function dedupeCitations(citations) {
+  const seen = /* @__PURE__ */ new Set();
+  return citations.filter((citation) => {
+    const key = citation.url ?? citation.title;
+    if (!key) return false;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+var adapter = {
+  async search(input, config, context) {
+    return await braveImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async answer(input, config, context) {
+    return await braveImplementation.answer(
+      input.query,
+      config,
+      context,
+      input.options
+    );
+  },
+  async research(input, config, context) {
+    return await braveImplementation.research(
+      input.input,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};