webfox 0.0.0-test.0 → 4.0.1

package/dist/adapter-I6OUKBZQ.js

@@ -0,0 +1,492 @@
+import {
+  asJsonObject,
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  httpError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/serper/types.ts
+var SERPER_SEARCH_MODE_VALUES = {
+  search: "search",
+  images: "images",
+  videos: "videos",
+  places: "places",
+  maps: "maps",
+  reviews: "reviews",
+  news: "news",
+  shopping: "shopping",
+  productReviews: "product-reviews",
+  lens: "lens",
+  scholar: "scholar",
+  patents: "patents",
+  autocomplete: "autocomplete",
+  webpage: "webpage"
+};
+
+// src/providers/serper/adapter.ts
+var DEFAULT_BASE_URL = "https://google.serper.dev";
+var DEFAULT_SCRAPE_URL = "https://scrape.serper.dev";
+var SERPER_SEARCH_MODES = Object.values(SERPER_SEARCH_MODE_VALUES);
+var SERPER_SEARCH_MODE_SET = new Set(SERPER_SEARCH_MODES);
+var RESERVED_REQUEST_OPTION_KEYS = [
+  "q",
+  "num",
+  "mode",
+  "url",
+  "productId",
+  "nextPageToken",
+  "ll",
+  "placeId",
+  "cid",
+  "fid",
+  "sortBy",
+  "topicId",
+  "includeMarkdown",
+  "includeImages",
+  "includeLinks",
+  "includeVideos",
+  "location",
+  "gl",
+  "hl",
+  "tbs",
+  "page",
+  "autocorrect"
+];
+var PRIMARY_RESULT_FIELDS_BY_MODE = {
+  search: ["organic"],
+  images: ["images"],
+  videos: ["videos"],
+  places: ["places"],
+  maps: ["maps", "places"],
+  reviews: ["reviews"],
+  news: ["news"],
+  shopping: ["shopping"],
+  "product-reviews": ["reviews", "productReviews"],
+  lens: ["visualMatches", "organic", "images"],
+  scholar: ["organic"],
+  patents: ["organic"],
+  autocomplete: ["suggestions"],
+  webpage: []
+};
+var CONTEXT_ARRAY_FIELDS = [
+  "peopleAlsoAsk",
+  "relatedSearches",
+  "topStories",
+  "news",
+  "images",
+  "videos",
+  "places",
+  "maps",
+  "shopping",
+  "reviews",
+  "productReviews",
+  "visualMatches",
+  "suggestions"
+];
+var serperImplementation = {
+  async search(query, maxResults, config, context, options) {
+    const apiKey = config.credentials?.api;
+    if (!apiKey) {
+      throw new Error("is missing an API key");
+    }
+    const callOptions = asJsonObject(options);
+    const requestOptions = readRequestOptions({
+      ...callOptions
+    });
+    const requestBody = buildRequestBody(
+      query,
+      clampMaxResults(maxResults),
+      requestOptions
+    );
+    const response = await fetch(joinUrl(config.baseUrl, requestOptions.mode), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify(requestBody),
+      signal: context.signal
+    });
+    if (!response.ok) {
+      throw httpError(response, await buildHttpError(response));
+    }
+    const payload = await response.json();
+    const responseRecord = enrichResponseRecord(
+      asRecord(payload) ?? {},
+      requestOptions.mode,
+      requestBody
+    );
+    const results = readPrimaryResults(responseRecord, requestOptions.mode);
+    const searchContext = buildSearchContext(
+      responseRecord,
+      requestOptions.mode
+    );
+    return {
+      provider: "serper",
+      results: results.map(
+        (entry) => toSearchResult(entry, searchContext, requestOptions.mode)
+      ).filter(
+        (result) => result !== null
+      ).slice(0, clampMaxResults(maxResults))
+    };
+  }
+};
+function joinUrl(baseUrl, mode = "search") {
+  const base = (baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  if (mode === "webpage" && base === DEFAULT_BASE_URL) {
+    return DEFAULT_SCRAPE_URL;
+  }
+  return `${base}/${mode}`;
+}
+function readRequestOptions(options) {
+  const result = {
+    mode: readSearchMode(options.mode),
+    extra: extractExtraMetadata(options, RESERVED_REQUEST_OPTION_KEYS)
+  };
+  copyStringOption(result, "gl", options.gl);
+  copyStringOption(result, "hl", options.hl);
+  copyStringOption(result, "location", options.location);
+  copyStringOption(result, "tbs", options.tbs);
+  copyStringOption(result, "url", options.url);
+  copyStringOption(result, "ll", options.ll);
+  copyStringOption(result, "placeId", options.placeId);
+  copyStringOption(result, "cid", options.cid);
+  copyStringOption(result, "fid", options.fid);
+  copyStringOption(result, "sortBy", options.sortBy);
+  copyStringOption(result, "topicId", options.topicId);
+  copyStringOption(result, "productId", options.productId);
+  copyStringOption(result, "nextPageToken", options.nextPageToken);
+  copyBooleanOption(result, "autocorrect", options.autocorrect);
+  copyBooleanOption(result, "includeMarkdown", options.includeMarkdown);
+  copyBooleanOption(result, "includeImages", options.includeImages);
+  copyBooleanOption(result, "includeLinks", options.includeLinks);
+  copyBooleanOption(result, "includeVideos", options.includeVideos);
+  const page = readInteger(options.page);
+  if (page !== void 0) {
+    result.page = Math.max(1, page);
+  }
+  return result;
+}
+function buildRequestBody(query, maxResults, options) {
+  const common = omitUndefined({
+    location: options.location,
+    gl: options.gl,
+    hl: options.hl
+  });
+  const withExtra = (body) => ({
+    ...body,
+    ...options.extra
+  });
+  switch (options.mode) {
+    case "webpage":
+      return withExtra(
+        omitUndefined({
+          url: options.url ?? query,
+          includeMarkdown: options.includeMarkdown ?? true,
+          includeImages: options.includeImages,
+          includeLinks: options.includeLinks,
+          includeVideos: options.includeVideos
+        })
+      );
+    case "product-reviews":
+      return withExtra(
+        omitUndefined({
+          productId: options.productId ?? query,
+          nextPageToken: options.nextPageToken,
+          ...common,
+          num: maxResults
+        })
+      );
+    case "autocomplete":
+      return withExtra({ q: query, ...common });
+    case "maps":
+      return withExtra(
+        omitUndefined({
+          q: query,
+          num: maxResults,
+          ...common,
+          ll: options.ll,
+          placeId: options.placeId,
+          cid: options.cid,
+          page: options.page
+        })
+      );
+    case "reviews": {
+      const hasExplicitPlaceIdentifier = firstNonEmptyString(options.cid, options.fid, options.placeId) !== void 0;
+      return withExtra(
+        omitUndefined({
+          q: hasExplicitPlaceIdentifier ? void 0 : query,
+          cid: options.cid,
+          fid: options.fid,
+          placeId: options.placeId,
+          gl: options.gl,
+          hl: options.hl,
+          sortBy: options.sortBy,
+          topicId: options.topicId,
+          nextPageToken: options.nextPageToken
+        })
+      );
+    }
+    case "lens":
+      return withExtra(
+        omitUndefined({
+          url: options.url ?? query,
+          ...common,
+          tbs: options.tbs
+        })
+      );
+    case "scholar":
+      return withExtra(
+        omitUndefined({
+          q: query,
+          ...common,
+          autocorrect: options.autocorrect,
+          tbs: options.tbs,
+          page: options.page
+        })
+      );
+    default:
+      return withExtra(
+        omitUndefined({
+          q: query,
+          num: maxResults,
+          ...common,
+          autocorrect: options.autocorrect,
+          tbs: options.tbs,
+          page: options.page
+        })
+      );
+  }
+}
+function enrichResponseRecord(response, mode, requestBody) {
+  if (mode !== "webpage") {
+    return response;
+  }
+  return omitUndefined({
+    ...response,
+    url: readString(response.url) ?? readString(requestBody.url)
+  });
+}
+function readSearchMode(value) {
+  return typeof value === "string" && SERPER_SEARCH_MODE_SET.has(value) ? value : "search";
+}
+function readPrimaryResults(response, mode) {
+  if (mode === "webpage") {
+    return [response];
+  }
+  for (const field of PRIMARY_RESULT_FIELDS_BY_MODE[mode]) {
+    const values = asArray(response[field]);
+    if (values) {
+      return values;
+    }
+  }
+  return [];
+}
+function clampMaxResults(value) {
+  return Math.max(1, Math.min(20, Math.trunc(value || 0)));
+}
+async function buildHttpError(response) {
+  const detail = await readErrorDetail(response);
+  const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+  return detail ? `Serper API request failed (${status}): ${detail}` : `Serper API request failed (${status}).`;
+}
+async function readErrorDetail(response) {
+  const text = (await response.text()).trim();
+  if (!text) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    const record = asRecord(parsed);
+    const detail = readString(record?.message) ?? readString(record?.error) ?? readString(record?.detail);
+    if (detail) {
+      return detail;
+    }
+    return JSON.stringify(parsed);
+  } catch {
+    return text;
+  }
+}
+function toSearchResult(entry, searchContext, mode) {
+  if (typeof entry === "string") {
+    return {
+      title: entry,
+      url: mode === "autocomplete" ? toGoogleSearchUrl(entry) : "",
+      snippet: entry,
+      metadata: {
+        source: mode,
+        ...searchContext ? { searchContext } : {}
+      }
+    };
+  }
+  const record = asRecord(entry);
+  if (!record) {
+    return null;
+  }
+  const responseMetadata = asRecord(record.metadata);
+  const user = asRecord(record.user);
+  const resultUrl = firstString(record.link, record.website, record.url, record.imageUrl) ?? "";
+  const title = firstNonEmptyString(
+    record.title,
+    responseMetadata?.title,
+    record.name,
+    record.query,
+    record.value,
+    user?.name,
+    formatReviewTitle(record, user),
+    resultUrl
+  ) ?? "Untitled";
+  const url = resultUrl || (mode === "autocomplete" ? toGoogleSearchUrl(title) : "");
+  const snippet = trimSnippet(
+    firstNonEmptyString(
+      record.snippet,
+      record.richSnippet,
+      record.markdown,
+      record.text,
+      record.address,
+      record.price,
+      record.date,
+      record.name,
+      record.value,
+      record.url
+    ) ?? ""
+  );
+  const metadata = omitUndefined({
+    source: readString(record.source) ?? (mode === "search" ? "organic" : mode),
+    position: readNumber(record.position),
+    date: readString(record.date),
+    attributes: asRecord(record.attributes),
+    sitelinks: asArray(record.sitelinks),
+    rating: readNumber(record.rating),
+    ratingCount: readNumber(record.ratingCount),
+    cid: readString(record.cid),
+    ...extractExtraMetadata(record, [
+      "title",
+      "name",
+      "query",
+      "value",
+      "link",
+      "website",
+      "url",
+      "snippet"
+    ]),
+    ...searchContext ? { searchContext } : {}
+  });
+  return {
+    title,
+    url,
+    snippet,
+    ...Object.keys(metadata).length > 0 ? { metadata } : {}
+  };
+}
+function buildSearchContext(response, mode) {
+  const context = omitUndefined({
+    searchParameters: asRecord(response.searchParameters),
+    searchInformation: asRecord(response.searchInformation),
+    credits: readNumber(response.credits),
+    answerBox: asRecord(response.answerBox),
+    knowledgeGraph: asRecord(response.knowledgeGraph)
+  });
+  const primaryResultFields = new Set(
+    PRIMARY_RESULT_FIELDS_BY_MODE[mode]
+  );
+  for (const field of CONTEXT_ARRAY_FIELDS) {
+    if (primaryResultFields.has(field)) {
+      continue;
+    }
+    const value = asArray(response[field]);
+    if (value) {
+      context[field] = value;
+    }
+  }
+  return Object.keys(context).length > 0 ? context : void 0;
+}
+function copyStringOption(target, key, value) {
+  const text = readString(value);
+  if (text !== void 0) {
+    target[key] = text;
+  }
+}
+function copyBooleanOption(target, key, value) {
+  const flag = readBoolean(value);
+  if (flag !== void 0) {
+    target[key] = flag;
+  }
+}
+function firstString(...values) {
+  return values.find((value) => typeof value === "string");
+}
+function toGoogleSearchUrl(query) {
+  return `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+}
+function formatReviewTitle(record, user) {
+  const userName = readString(user?.name);
+  const rating = readNumber(record.rating);
+  const date = readString(record.date) ?? readString(record.isoDate);
+  if (userName && rating !== void 0) {
+    return `${userName} (${rating}-star review)`;
+  }
+  if (userName) {
+    return `${userName}'s review`;
+  }
+  if (rating !== void 0 && date) {
+    return `${rating}-star review from ${date}`;
+  }
+  if (rating !== void 0) {
+    return `${rating}-star review`;
+  }
+  if (date) {
+    return `Review from ${date}`;
+  }
+  return void 0;
+}
+function firstNonEmptyString(...values) {
+  return values.find(
+    (value) => typeof value === "string" && value.length > 0
+  );
+}
+function extractExtraMetadata(record, ignoredKeys) {
+  return Object.fromEntries(
+    Object.entries(record).filter(
+      ([key, value]) => !ignoredKeys.includes(key) && value !== void 0
+    )
+  );
+}
+function omitUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : void 0;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+var adapter = {
+  async search(input, config, context) {
+    return await serperImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};

package/dist/adapter-ISZQTZDP.js

@@ -0,0 +1,166 @@
+import {
+  normalizeContentText,
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  orderedContents
+} from "./chunk-YZXM4U2C.js";
+import {
+  asWebfoxError,
+  httpError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/ollama/adapter.ts
+var DEFAULT_BASE_URL = "https://ollama.com";
+var WEB_SEARCH_PATH = "/api/web_search";
+var WEB_FETCH_PATH = "/api/web_fetch";
+async function searchOllama(query, maxResults, config, context) {
+  const apiKey = resolveApiKey(config);
+  const response = await fetch(
+    resolveEndpoint(config.baseUrl, WEB_SEARCH_PATH),
+    {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify({
+        query,
+        max_results: clampMaxResults(maxResults)
+      }),
+      signal: context.signal
+    }
+  );
+  if (!response.ok) {
+    throw httpError(response, await buildHttpError(response));
+  }
+  const data = await response.json();
+  const results = Array.isArray(data.results) ? data.results : [];
+  return {
+    provider: "ollama",
+    results: results.slice(0, clampMaxResults(maxResults)).map((result) => ({
+      title: result.title || result.url || "Untitled",
+      url: result.url ?? "",
+      snippet: trimSnippet(result.content)
+    }))
+  };
+}
+async function fetchOllamaContents(urls, config, context) {
+  const apiKey = resolveApiKey(config);
+  const endpoint = resolveEndpoint(config.baseUrl, WEB_FETCH_PATH);
+  return {
+    provider: "ollama",
+    answers: await Promise.all(
+      urls.map(async (url) => {
+        try {
+          const response = await fetch(endpoint, {
+            method: "POST",
+            headers: buildHeaders(apiKey),
+            body: JSON.stringify({
+              url
+            }),
+            signal: context.signal
+          });
+          if (!response.ok) {
+            return {
+              url,
+              error: httpError(
+                response,
+                await buildHttpError(response)
+              ).toJSON()
+            };
+          }
+          const data = await response.json();
+          const content = normalizeContentText(data.content);
+          if (!content) {
+            return {
+              url,
+              error: "No content returned for this URL."
+            };
+          }
+          const metadata = buildFetchMetadata(data);
+          return {
+            url,
+            content,
+            ...metadata ? { metadata } : {}
+          };
+        } catch (error) {
+          return {
+            url,
+            error: asWebfoxError(error).toJSON()
+          };
+        }
+      })
+    )
+  };
+}
+function resolveApiKey(config) {
+  const apiKey = config.credentials?.api;
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return apiKey;
+}
+function buildHeaders(apiKey) {
+  return {
+    authorization: `Bearer ${apiKey}`,
+    "content-type": "application/json"
+  };
+}
+function resolveEndpoint(baseUrlReference, endpointPath) {
+  const baseUrl = baseUrlReference ?? DEFAULT_BASE_URL;
+  const base = baseUrl.replace(/\/+$/, "");
+  const apiPath = endpointPath.replace(/^\/api\//, "");
+  if (base.endsWith(endpointPath)) {
+    return base;
+  }
+  if (base.endsWith("/api")) {
+    return `${base}/${apiPath}`;
+  }
+  return `${base}${endpointPath}`;
+}
+function clampMaxResults(value) {
+  return Math.max(1, Math.min(10, Math.trunc(value || 0)));
+}
+async function buildHttpError(response) {
+  const detail = await readErrorDetail(response);
+  const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+  return detail ? `Ollama API request failed (${status}): ${detail}` : `Ollama API request failed (${status}).`;
+}
+async function readErrorDetail(response) {
+  const text = (await response.text()).trim();
+  if (!text) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    for (const key of ["message", "error", "detail"]) {
+      if (typeof parsed[key] === "string" && parsed[key].trim()) {
+        return parsed[key];
+      }
+    }
+    return JSON.stringify(parsed);
+  } catch {
+    return text;
+  }
+}
+function buildFetchMetadata(data) {
+  const metadata = {};
+  if (data.title) {
+    metadata.title = data.title;
+  }
+  if (data.links?.length) {
+    metadata.links = data.links;
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+var adapter = {
+  async search(input, config, context) {
+    return await searchOllama(input.query, input.maxResults, config, context);
+  },
+  async contents(input, config, context) {
+    return orderedContents(
+      await fetchOllamaContents(input.urls, config, context)
+    );
+  }
+};
+export {
+  adapter
+};