webfox 0.0.0-test.0 → 4.0.0

package/dist/adapter-MAG7X663.js

@@ -0,0 +1,230 @@
+import {
+  cancelProcessGroup,
+  killProcessGroup
+} from "./chunk-ZVTVERW5.js";
+import {
+  WEBFOX_ERROR_CODES
+} from "./chunk-G2YAQEET.js";
+import {
+  WebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/cli-json.ts
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+async function runCliJsonCommand({
+  command,
+  payload,
+  context,
+  label
+}) {
+  context.signal?.throwIfAborted();
+  if (!command.argv.length)
+    throw new WebfoxError("INVALID_CONFIG", `${label} requires argv.`);
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command.argv[0], command.argv.slice(1), {
+      detached: process.platform !== "win32",
+      cwd: resolve(context.cwd, command.cwd ?? "."),
+      env: { ...context.env, ...command.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let progress = "";
+    const abort = () => {
+      cancelProcessGroup(child);
+      reject(context.signal?.reason);
+    };
+    context.signal?.addEventListener("abort", abort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      if (Buffer.byteLength(stdout) > 16 * 1024 * 1024) {
+        killProcessGroup(child, "SIGKILL");
+        reject(
+          new WebfoxError(
+            "PROVIDER_FAILURE",
+            `${label} output exceeded 16 MiB.`
+          )
+        );
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = (stderr + chunk).slice(-64 * 1024);
+      progress += chunk;
+      const lines = progress.split(/\r?\n/);
+      progress = lines.pop();
+      for (const line of lines)
+        if (line.trim()) context.onProgress?.(line.trim());
+      if (progress.length > 64 * 1024) {
+        progress = "";
+        killProcessGroup(child, "SIGKILL");
+        reject(
+          new WebfoxError(
+            "PROVIDER_FAILURE",
+            `${label} progress line exceeded 64 KiB.`
+          )
+        );
+      }
+    });
+    child.on(
+      "error",
+      () => reject(
+        new WebfoxError(
+          "PROVIDER_FAILURE",
+          `${label} could not start. Check the command executable and working directory.`
+        )
+      )
+    );
+    child.on("close", (code) => {
+      context.signal?.removeEventListener("abort", abort);
+      if (context.signal?.aborted) {
+        reject(context.signal.reason);
+        return;
+      }
+      if (progress.trim()) context.onProgress?.(progress.trim());
+      if (code !== 0) {
+        reject(
+          new WebfoxError(
+            "PROVIDER_FAILURE",
+            `${label} failed (exit ${code}): ${stderr.trim()}`,
+            { retryable: false }
+          )
+        );
+        return;
+      }
+      try {
+        resolvePromise(JSON.parse(stdout));
+      } catch {
+        reject(
+          new WebfoxError(
+            "PROVIDER_FAILURE",
+            `${label} must write one valid JSON object to stdout.`
+          )
+        );
+      }
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(`${JSON.stringify(payload)}
+`);
+  });
+}
+
+// src/providers/custom/adapter.ts
+async function run(request, config, context) {
+  const command = config.commands?.[request.capability];
+  if (!command)
+    throw new WebfoxError(
+      "PROVIDER_UNAVAILABLE",
+      `Configure a custom ${request.capability} command.`
+    );
+  const { capability, options, ...input } = request;
+  const output = await runCliJsonCommand({
+    command,
+    payload: {
+      schemaVersion: 1,
+      capability,
+      input,
+      options: options ?? {},
+      cwd: context.cwd
+    },
+    context,
+    label: `Custom ${capability}`
+  });
+  return object(output, "Custom output must be a JSON object.");
+}
+var adapter = {
+  async search(request, config, context) {
+    const output = await run(request, config, context);
+    if (!Array.isArray(output.results))
+      invalid("Custom search output requires a results array.");
+    return {
+      provider: "custom",
+      results: output.results.map((entry) => {
+        const result = object(entry, "Search results must be objects.");
+        return {
+          title: string(result.title, "title"),
+          url: string(result.url, "url"),
+          snippet: string(result.snippet, "snippet"),
+          ...typeof result.score === "number" ? { score: result.score } : {},
+          ...result.metadata ? {
+            metadata: object(result.metadata, "metadata must be an object")
+          } : {}
+        };
+      })
+    };
+  },
+  async contents(request, config, context) {
+    const output = await run(request, config, context);
+    if (!Array.isArray(output.answers))
+      invalid("Custom contents output requires an answers array.");
+    return {
+      provider: "custom",
+      answers: output.answers.map((entry) => {
+        const answer = object(entry, "Contents answers must be objects.");
+        if (!Number.isInteger(answer.inputIndex))
+          invalid(
+            "Every custom contents answer requires inputIndex (the zero-based requested URL index)."
+          );
+        const error = answer.error === void 0 ? void 0 : parseError(answer.error);
+        if (answer.content === void 0 && answer.summary === void 0 && error === void 0)
+          invalid("Contents answers require content, summary, or error.");
+        return {
+          inputIndex: answer.inputIndex,
+          url: string(answer.url, "url"),
+          ...answer.content === void 0 ? {} : { content: string(answer.content, "content") },
+          ...answer.summary === void 0 ? {} : { summary: answer.summary },
+          ...answer.metadata ? {
+            metadata: object(answer.metadata, "metadata must be an object")
+          } : {},
+          ...error ? { error } : {}
+        };
+      })
+    };
+  },
+  async answer(request, config, context) {
+    return textOutput(await run(request, config, context));
+  },
+  async research(request, config, context) {
+    return textOutput(await run(request, config, context));
+  }
+};
+function textOutput(output) {
+  return {
+    provider: "custom",
+    text: string(output.text, "text"),
+    ...typeof output.itemCount === "number" && Number.isSafeInteger(output.itemCount) && output.itemCount >= 0 ? { itemCount: output.itemCount } : {},
+    ...output.metadata ? { metadata: object(output.metadata, "metadata must be an object") } : {}
+  };
+}
+function parseError(value) {
+  const error = object(
+    value,
+    "Custom contents errors must be structured objects with code and message."
+  );
+  if (!WEBFOX_ERROR_CODES.includes(error.code))
+    invalid("Custom contents error has an unknown code.");
+  return {
+    code: error.code,
+    message: string(error.message, "error.message"),
+    ...typeof error.retryable === "boolean" ? { retryable: error.retryable } : {}
+  };
+}
+function object(value, message) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    invalid(message);
+  return value;
+}
+function string(value, name) {
+  if (typeof value !== "string")
+    invalid(`Custom output field ${name} must be a string.`);
+  return value;
+}
+function invalid(message) {
+  throw new WebfoxError("PROVIDER_FAILURE", message, { retryable: false });
+}
+export {
+  adapter
+};

package/dist/adapter-NEXSOHGT.js

@@ -0,0 +1,232 @@
+import {
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+
+// src/providers/perplexity/adapter.ts
+import PerplexityClient from "@perplexity-ai/perplexity_ai";
+var DEFAULT_ANSWER_MODEL = "sonar";
+var DEFAULT_RESEARCH_MODEL = "sonar-deep-research";
+var perplexityImplementation = {
+  async search(query, maxResults, config, context, options) {
+    const client = createClient(config);
+    const request = {
+      ...options ?? {},
+      query,
+      max_results: maxResults
+    };
+    const response = await client.search.create(
+      request,
+      buildRequestOptions(context)
+    );
+    return {
+      provider: "perplexity",
+      results: response.results.slice(0, maxResults).map((result) => ({
+        title: result.title,
+        url: result.url,
+        snippet: trimSnippet(result.snippet),
+        metadata: result.date || result.last_updated ? {
+          ...result.date ? { date: result.date } : {},
+          ...result.last_updated ? { last_updated: result.last_updated } : {}
+        } : void 0
+      }))
+    };
+  },
+  async answer(query, config, context, options) {
+    return runSilentForegroundChatTool(
+      query,
+      config,
+      context,
+      DEFAULT_ANSWER_MODEL,
+      "Answer",
+      options
+    );
+  },
+  async research(input, config, context, options) {
+    return runStreamingForegroundChatTool(
+      input,
+      config,
+      context,
+      DEFAULT_RESEARCH_MODEL,
+      "Research",
+      options
+    );
+  }
+};
+async function runSilentForegroundChatTool(input, config, context, fallbackModel, label, options) {
+  const client = createClient(config);
+  const request = {
+    ...options ?? {},
+    messages: [{ role: "user", content: input }],
+    model: resolveModel(options?.model, fallbackModel),
+    stream: false
+  };
+  const response = await client.chat.completions.create(
+    request,
+    buildRequestOptions(context)
+  );
+  const content = extractMessageText(response.choices[0]?.message?.content);
+  const sources = dedupeSources(extractSources(response));
+  const lines = [];
+  lines.push(content || `No ${label.toLowerCase()} returned.`);
+  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: "perplexity",
+    text: lines.join("\n").trimEnd(),
+    itemCount: sources.length
+  };
+}
+async function runStreamingForegroundChatTool(input, config, context, fallbackModel, label, options) {
+  const client = createClient(config);
+  const request = {
+    ...options ?? {},
+    messages: [{ role: "user", content: input }],
+    model: resolveModel(options?.model, fallbackModel),
+    stream: true
+  };
+  const stream = await client.chat.completions.create(
+    request,
+    buildRequestOptions(context)
+  );
+  let partialText = "";
+  let lastChunk;
+  const sources = [];
+  for await (const chunk of stream) {
+    lastChunk = chunk;
+    const deltaText = extractDeltaText(chunk.choices[0]?.delta?.content);
+    if (deltaText) {
+      partialText = `${partialText}${deltaText}`;
+    }
+    sources.push(...extractSources(chunk));
+  }
+  const finalText = partialText.trim() || extractMessageText(lastChunk?.choices?.[0]?.message?.content) || `No ${label.toLowerCase()} returned.`;
+  const dedupedSources = dedupeSources(sources);
+  const lines = [finalText];
+  if (dedupedSources.length > 0) {
+    lines.push("");
+    lines.push("Sources:");
+    for (const [index, source] of dedupedSources.entries()) {
+      lines.push(`${index + 1}. ${source.title}`);
+      lines.push(`   ${source.url}`);
+    }
+  }
+  return {
+    provider: "perplexity",
+    text: lines.join("\n").trimEnd(),
+    itemCount: dedupedSources.length
+  };
+}
+function createClient(config) {
+  const apiKey = config.credentials?.api;
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return new PerplexityClient({
+    maxRetries: 0,
+    apiKey,
+    baseURL: config.baseUrl
+  });
+}
+function resolveModel(optionModel, fallbackModel) {
+  if (typeof optionModel === "string" && optionModel.trim().length > 0) {
+    return optionModel;
+  }
+  return fallbackModel;
+}
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.flatMap((chunk) => {
+    if (typeof chunk === "object" && chunk !== null && "type" in chunk && chunk.type === "text" && "text" in chunk && typeof chunk.text === "string") {
+      return [chunk.text.trim()];
+    }
+    return [];
+  }).filter((text) => text.length > 0).join("\n\n").trim();
+}
+function extractDeltaText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.flatMap((chunk) => {
+    if (typeof chunk === "object" && chunk !== null && "type" in chunk && chunk.type === "text" && "text" in chunk && typeof chunk.text === "string") {
+      return [chunk.text];
+    }
+    return [];
+  }).join("");
+}
+function dedupeSources(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const source of sources) {
+    const title = source.title.trim() || source.url.trim() || "Untitled";
+    const url = source.url.trim();
+    if (!url) continue;
+    const key = `${title.toLowerCase()}::${url.toLowerCase()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push({ title, url });
+  }
+  return unique;
+}
+function extractSources(response) {
+  const searchResults = response.search_results?.flatMap((result) => {
+    const url = result.url?.trim() ?? "";
+    if (!url) {
+      return [];
+    }
+    return [{ title: result.title?.trim() ?? url, url }];
+  }) ?? [];
+  if (searchResults.length > 0) {
+    return searchResults;
+  }
+  return response.citations?.flatMap((citation) => {
+    const url = citation?.trim() ?? "";
+    return url ? [{ title: url, url }] : [];
+  }) ?? [];
+}
+function buildRequestOptions(context) {
+  return context.signal ? { signal: context.signal } : void 0;
+}
+var adapter = {
+  async search(input, config, context) {
+    return await perplexityImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async answer(input, config, context) {
+    return await perplexityImplementation.answer(
+      input.query,
+      config,
+      context,
+      input.options
+    );
+  },
+  async research(input, config, context) {
+    return await perplexityImplementation.research(
+      input.input,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};

package/dist/adapter-PADXKW43.js

@@ -0,0 +1,162 @@
+import {
+  formatJson,
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import {
+  orderedContents
+} from "./chunk-YZXM4U2C.js";
+import {
+  WebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/exa/adapter.ts
+import { Exa as ExaClient } from "exa-js";
+var exaImplementation = {
+  async search(query, maxResults, config, _context, searchOptions) {
+    const client = createClient(config);
+    const options = {
+      ...searchOptions ?? {},
+      numResults: maxResults
+    };
+    const response = await client.search(query, options);
+    return {
+      provider: "exa",
+      results: (response.results ?? []).slice(0, maxResults).map((result) => ({
+        title: String(result.title ?? result.url ?? "Untitled"),
+        url: String(result.url ?? ""),
+        snippet: trimSnippet(
+          typeof result.text === "string" ? result.text : Array.isArray(result.highlights) ? result.highlights.join(" ") : typeof result.summary === "string" ? result.summary : ""
+        ),
+        score: typeof result.score === "number" ? result.score : void 0
+      }))
+    };
+  },
+  async contents(urls, config, _context, options) {
+    const client = createClient(config);
+    const response = await client.getContents(urls, options);
+    const results = response.results ?? [];
+    return {
+      provider: "exa",
+      answers: urls.map((url, index) => {
+        const result = results[index];
+        if (!result) {
+          return {
+            url,
+            error: "No content returned for this URL."
+          };
+        }
+        return {
+          url: typeof result.url === "string" ? result.url : url,
+          ...typeof result.text === "string" ? { content: result.text } : {},
+          ...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);
+    const lines = [];
+    lines.push(
+      typeof response.answer === "string" ? response.answer : formatJson(response.answer)
+    );
+    const citations = response.citations ?? [];
+    if (citations.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, citation] of citations.entries()) {
+        lines.push(
+          `${index + 1}. ${String(citation.title ?? citation.url ?? "Untitled")}`
+        );
+        lines.push(`   ${String(citation.url ?? "")}`);
+      }
+    }
+    return {
+      provider: "exa",
+      text: lines.join("\n").trimEnd(),
+      itemCount: citations.length
+    };
+  },
+  async research(input, config, context, options) {
+    context.signal?.throwIfAborted();
+    context.onProgress?.("Exa is researching and synthesizing the report.");
+    const client = createClient(config);
+    const result = await client.search(input, {
+      ...options ?? {},
+      type: "deep-reasoning",
+      outputSchema: {
+        type: "text",
+        description: "A detailed Markdown research report answering the query. Cite sources with links, distinguish evidence from uncertainty, and include a conclusion."
+      }
+    });
+    const content = result.output?.content;
+    if (typeof content !== "string" || !content.trim())
+      throw new WebfoxError(
+        "PROVIDER_FAILURE",
+        "Exa returned no research report."
+      );
+    const sources = result.results ?? [];
+    const lines = [content.trim()];
+    if (sources.length) {
+      lines.push("", "Sources:");
+      for (const [index, source] of sources.entries())
+        lines.push(
+          `${index + 1}. ${source.title || source.url}`,
+          `   ${source.url}`
+        );
+    }
+    return {
+      provider: "exa",
+      text: lines.join("\n"),
+      itemCount: sources.length
+    };
+  }
+};
+function createClient(config) {
+  const apiKey = config.credentials?.api;
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  return new ExaClient(apiKey, config.baseUrl);
+}
+var adapter = {
+  async search(input, config, context) {
+    return await exaImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async contents(input, config, context) {
+    return orderedContents(
+      await exaImplementation.contents(
+        input.urls,
+        config,
+        context,
+        input.options
+      )
+    );
+  },
+  async answer(input, config, context) {
+    return await exaImplementation.answer(
+      input.query,
+      config,
+      context,
+      input.options
+    );
+  },
+  async research(input, config, context) {
+    return await exaImplementation.research(
+      input.input,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};