webfox 0.0.0-test.0 → 4.0.1

package/dist/adapter-SDQX2533.js

@@ -0,0 +1,123 @@
+import {
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  orderedContents
+} from "./chunk-YZXM4U2C.js";
+import "./chunk-U4BLULLV.js";
+
+// src/providers/tavily/adapter.ts
+import {
+  tavily
+} from "@tavily/core";
+var tavilyImplementation = {
+  async search(query, maxResults, config, _context, options) {
+    const client = createClient(config);
+    const response = await client.search(query, {
+      ...options ?? {},
+      maxResults
+    });
+    return {
+      provider: "tavily",
+      results: response.results.slice(0, maxResults).map((result) => ({
+        title: result.title || result.url || "Untitled",
+        url: result.url || "",
+        snippet: trimSnippet(result.content ?? result.rawContent),
+        score: typeof result.score === "number" ? result.score : void 0,
+        metadata: buildSearchMetadata(response, result)
+      }))
+    };
+  },
+  async contents(urls, config, _context, options) {
+    const client = createClient(config);
+    const response = await client.extract(urls, {
+      ...options ?? {}
+    });
+    const resultsByUrl = new Map(
+      response.results.map((result) => [result.url, result])
+    );
+    const failedResultsByUrl = new Map(
+      response.failedResults.map((result) => [result.url, result])
+    );
+    return {
+      provider: "tavily",
+      answers: urls.map((url) => {
+        const result = resultsByUrl.get(url) ?? (urls.length === 1 && response.results.length === 1 ? response.results[0] : void 0);
+        if (result) {
+          return {
+            url: result.url,
+            ...typeof result.rawContent === "string" ? { content: result.rawContent } : {},
+            metadata: buildExtractMetadata(response, result)
+          };
+        }
+        const failedResult = failedResultsByUrl.get(url) ?? (urls.length === 1 && response.failedResults.length === 1 ? response.failedResults[0] : void 0);
+        if (failedResult) {
+          return {
+            url,
+            error: failedResult.error || "Content extraction failed."
+          };
+        }
+        return {
+          url,
+          error: "No content returned for this URL."
+        };
+      })
+    };
+  }
+};
+function createClient(config) {
+  const apiKey = config.credentials?.api;
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return tavily({
+    apiKey,
+    apiBaseURL: config.baseUrl
+  });
+}
+function buildSearchMetadata(response, result) {
+  const metadata = {
+    ...response.answer ? { answer: response.answer } : {},
+    ...response.images?.length ? { images: response.images } : {},
+    ...result.publishedDate ? { publishedDate: result.publishedDate } : {},
+    ...result.favicon ? { favicon: result.favicon } : {},
+    ...result.rawContent ? { rawContent: result.rawContent } : {},
+    ...response.requestId ? { requestId: response.requestId } : {},
+    ...typeof response.responseTime === "number" ? { responseTime: response.responseTime } : {}
+  };
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function buildExtractMetadata(response, result) {
+  const metadata = {
+    ...result.title ? { title: result.title } : {},
+    ...Array.isArray(result.images) ? { images: result.images } : {},
+    ...result.favicon ? { favicon: result.favicon } : {},
+    ...response.requestId ? { requestId: response.requestId } : {},
+    ...typeof response.responseTime === "number" ? { responseTime: response.responseTime } : {}
+  };
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+var adapter = {
+  async search(input, config, context) {
+    return await tavilyImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async contents(input, config, context) {
+    return orderedContents(
+      await tavilyImplementation.contents(
+        input.urls,
+        config,
+        context,
+        input.options
+      )
+    );
+  }
+};
+export {
+  adapter
+};

package/dist/adapter-UAZNLDSS.js

@@ -0,0 +1,237 @@
+import {
+  executeAsyncResearch
+} from "./chunk-EF4VMDZL.js";
+import "./chunk-I2UIACY3.js";
+import {
+  sleep,
+  withSignal
+} from "./chunk-WCTOYZVB.js";
+import {
+  formatJson,
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  orderedContents
+} from "./chunk-YZXM4U2C.js";
+import "./chunk-U4BLULLV.js";
+
+// src/providers/valyu/adapter.ts
+import { Valyu as ValyuClient } from "valyu-js";
+var valyuImplementation = {
+  async search(query, maxResults, config, _context, searchOptions) {
+    const client = createClient(config);
+    const options = {
+      ...searchOptions ?? {},
+      maxNumResults: maxResults
+    };
+    const response = await client.search(query, options);
+    if (!response.success) {
+      throw new Error(response.error || "search failed");
+    }
+    return {
+      provider: "valyu",
+      results: (response.results ?? []).slice(0, maxResults).map((result) => ({
+        title: result.title,
+        url: result.url,
+        snippet: trimSnippet(
+          result.description ?? (typeof result.content === "string" ? result.content : "")
+        ),
+        score: result.relevance_score
+      }))
+    };
+  },
+  async contents(urls, config, context, options) {
+    const client = createClient(config);
+    const response = await client.contents(urls, {
+      ...options ?? {}
+    });
+    let finalResponse;
+    if ("jobId" in response) {
+      while (true) {
+        context.signal?.throwIfAborted();
+        const status = await withSignal(
+          client.getContentsJob(response.jobId),
+          context.signal
+        );
+        if (!status.success || ["completed", "partial", "failed"].includes(status.status)) {
+          finalResponse = status;
+          break;
+        }
+        await sleep(3e3, context.signal);
+      }
+    } else finalResponse = response;
+    if (!finalResponse.success) {
+      throw new Error(finalResponse.error || "contents failed");
+    }
+    const resultsByUrl = new Map(
+      (finalResponse.results ?? []).map(
+        (result) => [result.url, result]
+      )
+    );
+    return {
+      provider: "valyu",
+      answers: urls.map((url) => {
+        const result = resultsByUrl.get(url) ?? (urls.length === 1 && finalResponse.results?.length === 1 ? finalResponse.results[0] : void 0);
+        if (!result) {
+          return {
+            url,
+            error: "No content returned for this URL."
+          };
+        }
+        return result.status === "failed" ? {
+          url,
+          error: result.error ?? formatJson(result)
+        } : {
+          url: result.url,
+          ...typeof result.content === "string" || typeof result.content === "number" ? { content: String(result.content) } : {},
+          ...result.summary !== void 0 ? { summary: result.summary } : {},
+          metadata: result
+        };
+      })
+    };
+  },
+  async answer(query, config, _context, options) {
+    const client = createClient(config);
+    const response = await client.answer(query, {
+      ...options ?? {},
+      streaming: false
+    });
+    if (!("success" in response) || !response.success) {
+      throw new Error(
+        "error" in response && typeof response.error === "string" ? response.error : "answer failed"
+      );
+    }
+    const lines = [];
+    const contents = typeof response.contents === "string" ? response.contents : formatJson(response.contents);
+    lines.push(contents);
+    const sources = response.search_results ?? [];
+    if (sources.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, result] of sources.entries()) {
+        lines.push(`${index + 1}. ${result.title}`);
+        lines.push(`   ${result.url}`);
+      }
+    }
+    return {
+      provider: "valyu",
+      text: lines.join("\n").trimEnd(),
+      itemCount: sources.length
+    };
+  },
+  async research(input, config, context, options) {
+    return await executeAsyncResearch({
+      providerLabel: "Valyu",
+      providerId: "valyu",
+      context,
+      start: (researchContext) => valyuImplementation.startResearch(
+        input,
+        config,
+        researchContext,
+        options
+      ),
+      poll: (id, researchContext) => valyuImplementation.pollResearch(id, config, researchContext, options)
+    });
+  },
+  async startResearch(input, config, _context, options) {
+    const client = createClient(config);
+    const task = await client.deepresearch.create({
+      input,
+      ...options ?? {}
+    });
+    if (!task.success || !task.deepresearch_id) {
+      throw new Error(task.error || "deep research creation failed");
+    }
+    return { id: task.deepresearch_id };
+  },
+  async pollResearch(id, config, _context, _options) {
+    const client = createClient(config);
+    const result = await client.deepresearch.status(id);
+    if (!result.success) {
+      throw new Error(result.error || "deep research failed");
+    }
+    if (result.status === "completed") {
+      const lines = [];
+      lines.push(
+        typeof result.output === "string" ? result.output : result.output ? formatJson(result.output) : "Valyu deep research completed without textual output."
+      );
+      const sources = result.sources ?? [];
+      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 {
+        status: "completed",
+        output: {
+          provider: "valyu",
+          text: lines.join("\n").trimEnd(),
+          itemCount: sources.length
+        }
+      };
+    }
+    if (result.status === "failed") {
+      return {
+        status: "failed",
+        error: result.error || "research failed"
+      };
+    }
+    if (result.status === "cancelled") {
+      return {
+        status: "cancelled",
+        error: result.error || "research was canceled"
+      };
+    }
+    return { status: "in_progress" };
+  }
+};
+function createClient(config) {
+  const apiKey = config.credentials?.api;
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return new ValyuClient(apiKey, config.baseUrl);
+}
+var adapter = {
+  async search(input, config, context) {
+    return await valyuImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async contents(input, config, context) {
+    return orderedContents(
+      await valyuImplementation.contents(
+        input.urls,
+        config,
+        context,
+        input.options
+      )
+    );
+  },
+  async answer(input, config, context) {
+    return await valyuImplementation.answer(
+      input.query,
+      config,
+      context,
+      input.options
+    );
+  },
+  async research(input, config, context) {
+    return await valyuImplementation.research(
+      input.input,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};

package/dist/adapter-XBAQSK7I.js

@@ -0,0 +1,282 @@
+import {
+  formatJson,
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  orderedContents
+} from "./chunk-YZXM4U2C.js";
+import {
+  WebfoxError,
+  asWebfoxError,
+  httpError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/firecrawl/adapter.ts
+import FirecrawlClient from "@mendable/firecrawl-js";
+var FIRECRAWL_CLOUD_HOST = "api.firecrawl.dev";
+var FIRECRAWL_DEFAULT_API_URL = "https://api.firecrawl.dev";
+var FIRECRAWL_QUESTION_LIMIT = 1e4;
+var firecrawlImplementation = {
+  async search(query, maxResults, config, _context, options) {
+    const client = createClient(config);
+    const response = await client.search(query, {
+      ...options ?? {},
+      limit: maxResults
+    });
+    return {
+      provider: "firecrawl",
+      results: flattenSearchResults(response).slice(0, maxResults)
+    };
+  },
+  async contents(urls, config, _context, options) {
+    const client = createClient(config);
+    const scrapeOptions = {
+      formats: ["markdown"],
+      onlyMainContent: true,
+      ...options ?? {},
+      autoResume: false
+    };
+    return {
+      provider: "firecrawl",
+      answers: await Promise.all(
+        urls.map(async (url) => {
+          try {
+            const document = await client.scrape(url, scrapeOptions);
+            const content = getDocumentContent(document);
+            return content ? {
+              url,
+              content,
+              ...document.metadata ? {
+                metadata: document.metadata
+              } : {}
+            } : {
+              url,
+              error: "No content returned for this URL."
+            };
+          } catch (error) {
+            return {
+              url,
+              error: asWebfoxError(error).toJSON()
+            };
+          }
+        })
+      )
+    };
+  },
+  async answer(query, config, context, options) {
+    const question = validateQuestion(query);
+    const mergedOptions = {
+      onlyMainContent: true,
+      ...options ?? {}
+    };
+    const url = validateUrl(mergedOptions.url);
+    const scrapeOptions = stripAnswerOnlyOptions(mergedOptions);
+    const response = await scrapeQuestion(
+      config,
+      url,
+      question,
+      scrapeOptions,
+      context.signal
+    );
+    const document = getFirecrawlDocument(response);
+    const answer = readString(document.answer);
+    if (!answer?.trim()) {
+      throw new Error("No answer returned for this URL.");
+    }
+    return {
+      provider: "firecrawl",
+      text: answer.trim(),
+      itemCount: 1,
+      metadata: {
+        url,
+        ...asRecord(document.metadata) ? { metadata: document.metadata } : {}
+      }
+    };
+  }
+};
+function createClient(config) {
+  const apiUrl = config.baseUrl;
+  const apiKey = config.credentials?.api;
+  if (isFirecrawlCloudApiUrl(apiUrl) && !apiKey) {
+    throw new WebfoxError(
+      "PROVIDER_UNAVAILABLE",
+      "Firecrawl cloud requires FIRECRAWL_API_KEY; self-hosted instances can use baseUrl without a key."
+    );
+  }
+  return new FirecrawlClient({
+    // Firecrawl counts attempts, unlike SDKs whose maxRetries excludes the first call.
+    maxRetries: 1,
+    apiKey,
+    apiUrl
+  });
+}
+function isFirecrawlCloudApiUrl(apiUrl) {
+  return !apiUrl || apiUrl.includes(FIRECRAWL_CLOUD_HOST);
+}
+function validateQuestion(query) {
+  const question = query.trim();
+  if (!question) {
+    throw new Error("question must be a non-empty string.");
+  }
+  if (question.length > FIRECRAWL_QUESTION_LIMIT) {
+    throw new Error(
+      `Firecrawl question must be at most ${FIRECRAWL_QUESTION_LIMIT} characters.`
+    );
+  }
+  return question;
+}
+function validateUrl(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("Firecrawl answer requires options.url.");
+  }
+  return value.trim();
+}
+function stripAnswerOnlyOptions(options) {
+  const { url: _url, formats: _formats, ...scrapeOptions } = options;
+  return scrapeOptions;
+}
+async function scrapeQuestion(config, url, question, options, signal) {
+  const apiUrl = config.baseUrl ?? FIRECRAWL_DEFAULT_API_URL;
+  const apiKey = config.credentials?.api;
+  if (isFirecrawlCloudApiUrl(apiUrl) && !apiKey) {
+    throw new WebfoxError(
+      "PROVIDER_UNAVAILABLE",
+      "Firecrawl cloud requires FIRECRAWL_API_KEY; self-hosted instances can use baseUrl without a key."
+    );
+  }
+  const response = await fetch(joinUrl(apiUrl, "/v2/scrape"), {
+    signal,
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+    },
+    body: JSON.stringify({
+      ...options,
+      url,
+      formats: [{ type: "question", question }]
+    })
+  });
+  const payload = await readJsonResponse(response);
+  if (!response.ok) {
+    throw httpError(response, readFirecrawlError(payload, response.statusText));
+  }
+  if (isFirecrawlFailure(payload)) {
+    throw new Error(readFirecrawlError(payload, "Firecrawl scrape failed."));
+  }
+  return payload;
+}
+function joinUrl(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/g, "")}/${path.replace(/^\/+/g, "")}`;
+}
+async function readJsonResponse(response) {
+  const text = await response.text();
+  if (!text) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function isFirecrawlFailure(value) {
+  const record = asRecord(value);
+  return record?.success === false || record?.error !== void 0;
+}
+function readFirecrawlError(value, fallback) {
+  const record = asRecord(value);
+  return readString(record?.error) ?? readString(record?.message) ?? (typeof value === "string" ? value : void 0) ?? fallback;
+}
+function getFirecrawlDocument(value) {
+  const record = asRecord(value);
+  const data = asRecord(record?.data);
+  if (data) {
+    return data;
+  }
+  if (record) {
+    return record;
+  }
+  throw new Error(`Unexpected Firecrawl response: ${formatJson(value)}`);
+}
+function flattenSearchResults(response) {
+  return ["web", "news", "images"].flatMap(
+    (source) => (response[source] ?? []).map((entry) => toSearchResult(source, entry)).filter((entry) => entry !== null)
+  );
+}
+function toSearchResult(source, value) {
+  const entry = asRecord(value);
+  if (!entry) {
+    return null;
+  }
+  const metadata = asRecord(entry.metadata);
+  const url = readString(entry.url) ?? readString(metadata?.sourceURL) ?? readString(entry.imageUrl) ?? "";
+  const title = readString(entry.title) ?? readString(metadata?.title) ?? url;
+  const snippet = trimSnippet(
+    readString(entry.description) ?? readString(entry.snippet) ?? readString(entry.markdown) ?? readString(metadata?.description) ?? ""
+  );
+  const resultMetadata = {
+    source,
+    ...readString(entry.category) ? { category: entry.category } : {},
+    ...readString(entry.date) ? { date: entry.date } : {},
+    ...readString(entry.imageUrl) ? { imageUrl: entry.imageUrl } : {},
+    ...typeof entry.position === "number" ? { position: entry.position } : {},
+    ...metadata ?? {}
+  };
+  return {
+    title: title || "Untitled",
+    url,
+    snippet,
+    metadata: Object.keys(resultMetadata).length > 1 ? resultMetadata : void 0
+  };
+}
+function getDocumentContent(document) {
+  if (typeof document.markdown === "string" && document.markdown.trim()) {
+    return document.markdown;
+  }
+  if (typeof document.html === "string" && document.html.trim()) {
+    return document.html;
+  }
+  if (typeof document.rawHtml === "string" && document.rawHtml.trim()) {
+    return document.rawHtml;
+  }
+  return document.json !== void 0 ? JSON.stringify(document.json, null, 2) : void 0;
+}
+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;
+}
+var adapter = {
+  async search(input, config, context) {
+    return await firecrawlImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async contents(input, config, context) {
+    return orderedContents(
+      await firecrawlImplementation.contents(
+        input.urls,
+        config,
+        context,
+        input.options
+      )
+    );
+  },
+  async answer(input, config, context) {
+    return await firecrawlImplementation.answer(
+      input.query,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};

package/dist/application-types.d.ts

@@ -0,0 +1,34 @@
+import type { AnswerDocument, AnswerOptions, Capability, ContentsDocument, ContentsOptions, ProviderId, ResearchDocument, ResearchOptions, SearchDocument, SearchOptions } from "./domain.js";
+import type { WebfoxConfig } from "./configuration/types.js";
+import type { ProviderMetadata } from "./providers/metadata.js";
+export type { ProviderMetadata } from "./providers/metadata.js";
+export interface CreateWebfoxOptions {
+    config?: WebfoxConfig;
+    configPath?: string;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}
+export interface ProviderInspection extends ProviderMetadata {
+    configurationRequirements: Record<string, string>;
+    configured: readonly Capability[];
+    selectedDefaults: readonly Capability[];
+}
+export interface CapabilityInspection {
+    capability: Capability;
+    provider?: ProviderId;
+    configured: boolean;
+    optionSchema?: Record<string, unknown>;
+    defaults: {
+        maxResults?: number;
+        options: Record<string, unknown>;
+    };
+}
+export interface WebfoxClient {
+    search(options: SearchOptions): Promise<SearchDocument>;
+    contents(options: ContentsOptions): Promise<ContentsDocument>;
+    answer(options: AnswerOptions): Promise<AnswerDocument>;
+    research(options: ResearchOptions): Promise<ResearchDocument>;
+    listProviders(): readonly ProviderInspection[];
+    getProvider(id: ProviderId): ProviderInspection | undefined;
+    inspectCapability(capability: Capability, provider?: ProviderId): CapabilityInspection;
+}

package/dist/application.d.ts

@@ -0,0 +1,2 @@
+import type { CreateWebfoxOptions, WebfoxClient } from "./application-types.js";
+export declare function createWebfox(options?: CreateWebfoxOptions): WebfoxClient;