webfox 0.0.0-test.0 → 4.0.1

package/dist/adapter-HPTMLH75.js

@@ -0,0 +1,334 @@
+import {
+  executeAsyncResearch
+} from "./chunk-EF4VMDZL.js";
+import "./chunk-I2UIACY3.js";
+import "./chunk-WCTOYZVB.js";
+import {
+  formatJson,
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  orderedContents
+} from "./chunk-YZXM4U2C.js";
+import {
+  asWebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/linkup/adapter.ts
+import {
+  LinkupClient
+} from "linkup-sdk";
+var linkupImplementation = {
+  async search(query, maxResults, config, _context, options) {
+    const client = createClient(config);
+    const response = await client.search(
+      buildSearchParams(query, maxResults, {
+        ...options ?? {}
+      })
+    );
+    return {
+      provider: "linkup",
+      results: (response.results ?? []).map(toSearchResult).filter((result) => result !== null).slice(0, maxResults)
+    };
+  },
+  async contents(urls, config, _context, options) {
+    const client = createClient(config);
+    return {
+      provider: "linkup",
+      answers: await Promise.all(
+        urls.map(async (url) => {
+          try {
+            const response = await client.fetch(
+              buildFetchParams(url, {
+                ...options ?? {}
+              })
+            );
+            const metadata = Object.fromEntries(
+              Object.entries(response).filter(
+                ([key, value]) => [
+                  "rawContent",
+                  "rawHtml",
+                  "contentType",
+                  "images",
+                  "favicon"
+                ].includes(key) && value !== void 0
+              )
+            );
+            return response.markdown ? {
+              url,
+              content: response.markdown,
+              ...Object.keys(metadata).length ? { metadata } : {}
+            } : {
+              url,
+              error: "No content returned for this URL."
+            };
+          } catch (error) {
+            return {
+              url,
+              error: asWebfoxError(error).toJSON()
+            };
+          }
+        })
+      )
+    };
+  },
+  async research(input, config, context, options) {
+    return await executeAsyncResearch({
+      providerLabel: "Linkup",
+      providerId: "linkup",
+      context,
+      start: (researchContext) => linkupImplementation.startResearch(
+        input,
+        config,
+        researchContext,
+        options
+      ),
+      poll: (id, researchContext) => linkupImplementation.pollResearch(id, config, researchContext)
+    });
+  },
+  async startResearch(input, config, _context, options) {
+    const client = createClient(config);
+    const task = await client.research(
+      buildResearchParams(input, {
+        ...options ?? {}
+      })
+    );
+    return { id: task.id };
+  },
+  async pollResearch(id, config, _context) {
+    const client = createClient(config);
+    const task = await client.getResearch(id);
+    if (task.status === "completed") {
+      return {
+        status: "completed",
+        output: formatResearchTaskOutput(task)
+      };
+    }
+    if (task.status === "failed") {
+      return {
+        status: "failed",
+        error: task.error ?? "research failed"
+      };
+    }
+    return {
+      status: "in_progress",
+      statusText: task.status
+    };
+  }
+};
+function buildSearchParams(query, maxResults, options) {
+  const searchOptions = options;
+  if (searchOptions.query !== void 0) {
+    throw new Error("Linkup search options cannot override the managed query.");
+  }
+  if (searchOptions.maxResults !== void 0) {
+    throw new Error(
+      "Linkup search options cannot override the managed maxResults."
+    );
+  }
+  if (searchOptions.outputType !== void 0 && searchOptions.outputType !== "searchResults") {
+    throw new Error("Linkup search only supports outputType 'searchResults'.");
+  }
+  if (searchOptions.includeInlineCitations !== void 0 || searchOptions.includeSources !== void 0 || searchOptions.structuredOutputSchema !== void 0) {
+    throw new Error(
+      "Linkup search only supports search-results mode for managed web_search."
+    );
+  }
+  return {
+    query,
+    depth: searchOptions.depth ?? "standard",
+    outputType: "searchResults",
+    maxResults,
+    ...searchOptions.includeImages !== void 0 ? { includeImages: searchOptions.includeImages } : {},
+    ...searchOptions.includeDomains !== void 0 ? { includeDomains: searchOptions.includeDomains } : {},
+    ...searchOptions.excludeDomains !== void 0 ? { excludeDomains: searchOptions.excludeDomains } : {},
+    ...searchOptions.fromDate !== void 0 ? { fromDate: toDate(searchOptions.fromDate, "fromDate") } : {},
+    ...searchOptions.toDate !== void 0 ? { toDate: toDate(searchOptions.toDate, "toDate") } : {}
+  };
+}
+function buildFetchParams(url, options) {
+  const fetchOptions = options;
+  if (fetchOptions.url !== void 0) {
+    throw new Error("Linkup fetch options cannot override the managed URL.");
+  }
+  return {
+    url,
+    ...fetchOptions.mode !== void 0 ? { mode: fetchOptions.mode } : {},
+    ...fetchOptions.includeRawContent !== void 0 ? { includeRawContent: fetchOptions.includeRawContent } : {},
+    ...fetchOptions.renderJs !== void 0 ? { renderJs: fetchOptions.renderJs } : {},
+    ...fetchOptions.includeRawHtml !== void 0 ? { includeRawHtml: fetchOptions.includeRawHtml } : {},
+    ...fetchOptions.extractImages !== void 0 ? { extractImages: fetchOptions.extractImages } : {}
+  };
+}
+function buildResearchParams(input, options) {
+  const researchOptions = options;
+  if (researchOptions.q !== void 0 || researchOptions.query !== void 0 || researchOptions.input !== void 0) {
+    throw new Error(
+      "Linkup research options cannot override the managed input."
+    );
+  }
+  const outputType = researchOptions.outputType ?? (researchOptions.structuredOutputSchema !== void 0 ? "structured" : "sourcedAnswer");
+  if (outputType === "structured" && researchOptions.structuredOutputSchema === void 0) {
+    throw new Error(
+      "Linkup research outputType 'structured' requires structuredOutputSchema."
+    );
+  }
+  if (outputType === "sourcedAnswer" && researchOptions.structuredOutputSchema !== void 0) {
+    throw new Error(
+      "Linkup research structuredOutputSchema requires outputType 'structured'."
+    );
+  }
+  const commonParams = {
+    query: input,
+    ...researchOptions.includeDomains !== void 0 ? { includeDomains: researchOptions.includeDomains } : {},
+    ...researchOptions.excludeDomains !== void 0 ? { excludeDomains: researchOptions.excludeDomains } : {},
+    ...researchOptions.fromDate !== void 0 ? { fromDate: toDate(researchOptions.fromDate, "fromDate") } : {},
+    ...researchOptions.toDate !== void 0 ? { toDate: toDate(researchOptions.toDate, "toDate") } : {},
+    ...researchOptions.mode !== void 0 ? { mode: researchOptions.mode } : {},
+    ...researchOptions.reasoningDepth !== void 0 ? { reasoningDepth: researchOptions.reasoningDepth } : {}
+  };
+  if (outputType === "structured") {
+    return {
+      ...commonParams,
+      outputType,
+      structuredOutputSchema: researchOptions.structuredOutputSchema
+    };
+  }
+  return {
+    ...commonParams,
+    outputType
+  };
+}
+function createClient(config) {
+  const apiKey = config.credentials?.api;
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return new LinkupClient({
+    apiKey,
+    baseUrl: config.baseUrl
+  });
+}
+function formatResearchTaskOutput(task) {
+  const output = task.output;
+  if (!output) {
+    return {
+      provider: "linkup",
+      text: "Linkup research completed without textual output."
+    };
+  }
+  const outputRecord = asRecord(output);
+  const inputRecord = asRecord(task.input);
+  const outputType = inputRecord ? readString(inputRecord.outputType) : void 0;
+  const answer = outputRecord ? readString(outputRecord.answer) : void 0;
+  const sources = outputRecord ? readSources(outputRecord.sources) : [];
+  if (outputType !== "structured" && answer !== void 0) {
+    const lines = [answer];
+    if (sources.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, source] of sources.entries()) {
+        lines.push(`${index + 1}. ${source.title}`);
+        lines.push(`   ${source.url}`);
+      }
+    }
+    return {
+      provider: "linkup",
+      text: lines.join("\n").trimEnd(),
+      itemCount: sources.length
+    };
+  }
+  return {
+    provider: "linkup",
+    text: formatJson(output)
+  };
+}
+function toSearchResult(value) {
+  const entry = asRecord(value);
+  if (!entry) {
+    return null;
+  }
+  const url = readString(entry.url) ?? "";
+  const title = readString(entry.name) ?? (url || "Untitled");
+  const type = readString(entry.type);
+  const favicon = readString(entry.favicon);
+  const snippet = type === "text" ? trimSnippet(readString(entry.content) ?? "") : "";
+  const metadata = {
+    ...type ? { type } : {},
+    ...favicon ? { favicon } : {}
+  };
+  return {
+    title,
+    url,
+    snippet,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  };
+}
+function readSources(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const source = asRecord(entry);
+    if (!source) {
+      return [];
+    }
+    const url = readString(source.url);
+    if (!url) {
+      return [];
+    }
+    return [
+      {
+        title: readString(source.name) ?? url,
+        url
+      }
+    ];
+  });
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function toDate(value, name) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(
+      `Linkup option '${name}' must be a valid date string, timestamp, or Date.`
+    );
+  }
+  return date;
+}
+var adapter = {
+  async search(input, config, context) {
+    return await linkupImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async contents(input, config, context) {
+    return orderedContents(
+      await linkupImplementation.contents(
+        input.urls,
+        config,
+        context,
+        input.options
+      )
+    );
+  },
+  async research(input, config, context) {
+    return await linkupImplementation.research(
+      input.input,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};