webfox 0.0.0-test.0 → 4.0.0

package/dist/adapter-AB7LKV7N.js

@@ -0,0 +1,324 @@
+import {
+  executeAsyncResearch
+} from "./chunk-EF4VMDZL.js";
+import "./chunk-I2UIACY3.js";
+import "./chunk-WCTOYZVB.js";
+import "./chunk-U4BLULLV.js";
+
+// src/providers/gemini/adapter.ts
+import { GoogleGenAI } from "@google/genai";
+var DEFAULT_ANSWER_MODEL = "gemini-3.8-flash";
+var DEFAULT_RESEARCH_AGENT = "deep-research-preview-04-2026";
+var geminiImplementation = {
+  async answer(query, config, context, options) {
+    const ai = this.createClient(config);
+    const request = buildGeminiGenerateContentRequest({
+      defaultModel: DEFAULT_ANSWER_MODEL,
+      prompt: query,
+      options,
+      toolConfig: { googleSearch: {} }
+    });
+    const response = await ai.models.generateContent({
+      model: request.model,
+      contents: request.contents,
+      config: addAbortSignalToGeminiConfig(request.config, context.signal)
+    });
+    const lines = [];
+    lines.push(response.text?.trim() || "No answer returned.");
+    const sources = extractGroundingSources(
+      response.candidates?.[0]?.groundingMetadata?.groundingChunks
+    );
+    if (sources.length > 0) {
+      lines.push("");
+      lines.push("Sources:");
+      for (const [index, source] of sources.entries()) {
+        lines.push(`${index + 1}. ${source.title}`);
+        if (source.url) {
+          lines.push(`   ${source.url}`);
+        }
+      }
+    }
+    return {
+      provider: "gemini",
+      text: lines.join("\n").trimEnd(),
+      itemCount: sources.length
+    };
+  },
+  async research(input, config, context, options) {
+    return await executeAsyncResearch({
+      providerLabel: "Gemini",
+      providerId: "gemini",
+      context,
+      start: (researchContext) => this.startResearch(input, config, researchContext, options),
+      poll: (id, researchContext) => this.pollResearch(id, config, researchContext, options)
+    });
+  },
+  async startResearch(input, config, context, options) {
+    const ai = this.createClient(config);
+    const requestOptions = getGeminiResearchRequestOptions(options);
+    const interaction = await ai.interactions.create(
+      {
+        ...requestOptions,
+        input,
+        agent: DEFAULT_RESEARCH_AGENT,
+        background: true
+      },
+      buildGeminiRequestOptions(context.signal, context.idempotencyKey)
+    );
+    return { id: interaction.id };
+  },
+  async pollResearch(id, config, context, _options) {
+    const ai = this.createClient(config);
+    const interaction = await ai.interactions.get(
+      id,
+      void 0,
+      buildGeminiRequestOptions(context.signal)
+    );
+    const status = readNonEmptyString(interaction.status) ?? "unknown";
+    if (status === "completed") {
+      const text = formatInteractionSteps(readInteractionSteps(interaction));
+      return {
+        status: "completed",
+        output: {
+          provider: "gemini",
+          text: text || "Gemini research completed without textual output."
+        }
+      };
+    }
+    if (status === "failed") {
+      return {
+        status: "failed",
+        error: "research failed"
+      };
+    }
+    if (status === "cancelled") {
+      return {
+        status: "cancelled",
+        error: "research was canceled"
+      };
+    }
+    if (status === "incomplete") {
+      return {
+        status: "failed",
+        error: "research ended incomplete"
+      };
+    }
+    if (status === "requires_action") {
+      return {
+        status: "failed",
+        error: describeGeminiRequiredAction(readInteractionSteps(interaction))
+      };
+    }
+    return status === "in_progress" ? { status: "in_progress" } : { status: "in_progress", statusText: status };
+  },
+  createClient(config) {
+    const apiKey = config.credentials?.api;
+    if (!apiKey) {
+      throw new Error("is missing an API key");
+    }
+    return new GoogleGenAI({
+      httpOptions: { retryOptions: { attempts: 1 } },
+      apiKey
+    });
+  }
+};
+function buildGeminiRequestOptions(signal, idempotencyKey) {
+  return {
+    maxRetries: 0,
+    ...signal ? { signal } : {},
+    ...idempotencyKey ? { idempotencyKey } : {}
+  };
+}
+function addAbortSignalToGeminiConfig(config, signal) {
+  if (!signal) {
+    return config;
+  }
+  return {
+    ...config ?? {},
+    abortSignal: signal
+  };
+}
+function readInteractionSteps(interaction) {
+  return typeof interaction === "object" && interaction !== null ? interaction.steps : void 0;
+}
+function extractGroundingSources(chunks) {
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  const maxSources = 5;
+  if (!Array.isArray(chunks)) {
+    return sources;
+  }
+  for (const chunk of chunks) {
+    const web = typeof chunk === "object" && chunk !== null && "web" in chunk && typeof chunk.web === "object" && chunk.web !== null ? chunk.web : void 0;
+    if (!web) continue;
+    const rawUrl = typeof web.uri === "string" ? web.uri : "";
+    const title = formatGroundingSourceTitle(
+      typeof web.title === "string" ? web.title : rawUrl,
+      rawUrl
+    );
+    const url = formatGroundingSourceUrl(rawUrl);
+    const key = [title.toLowerCase(), url.toLowerCase()].join("::");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    sources.push({
+      title,
+      url
+    });
+    if (sources.length >= maxSources) {
+      break;
+    }
+  }
+  return sources;
+}
+function formatInteractionSteps(steps) {
+  const lines = [];
+  if (!Array.isArray(steps)) {
+    return "";
+  }
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null || !("type" in step) || step.type !== "model_output" || !("content" in step) || !Array.isArray(step.content)) {
+      continue;
+    }
+    for (const part of step.content) {
+      if (typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
+        const text = part.text.trim();
+        if (text) {
+          lines.push(text);
+        }
+      }
+    }
+  }
+  return lines.join("\n\n").trim();
+}
+function formatGroundingSourceTitle(title, url) {
+  const trimmedTitle = title?.trim();
+  if (trimmedTitle) {
+    return trimmedTitle;
+  }
+  if (url) {
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return url;
+    }
+  }
+  return "Untitled";
+}
+function formatGroundingSourceUrl(url) {
+  if (!url) {
+    return "";
+  }
+  if (isGoogleGroundingRedirect(url)) {
+    return "";
+  }
+  return url;
+}
+function isGoogleGroundingRedirect(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === "vertexaisearch.cloud.google.com" && parsed.pathname.startsWith("/grounding-api-redirect/");
+  } catch {
+    return false;
+  }
+}
+function buildGeminiGenerateContentRequest({
+  defaultModel,
+  prompt,
+  options,
+  toolConfig
+}) {
+  const requestOptions = isPlainObject(options) ? options : {};
+  const explicitConfig = isPlainObject(requestOptions.config) ? requestOptions.config : {};
+  return {
+    model: readNonEmptyString(requestOptions.model) ?? defaultModel,
+    contents: prompt,
+    config: {
+      ...explicitConfig,
+      tools: [toolConfig]
+    }
+  };
+}
+function describeGeminiRequiredAction(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) {
+    return "research requires additional action";
+  }
+  const lastStep = [...steps].reverse().find((value) => typeof value === "object" && value !== null);
+  const type = readNonEmptyString(lastStep?.type);
+  if (!type) {
+    return "research requires additional action";
+  }
+  return `research requires additional action (${type})`;
+}
+function getGeminiResearchRequestOptions(options) {
+  if (!isPlainObject(options)) {
+    return {};
+  }
+  const unknownKeys = Object.keys(options).filter(
+    (key) => key !== "agent_config"
+  );
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `Unsupported Gemini research options: ${unknownKeys.join(", ")}.`
+    );
+  }
+  const requestOptions = {};
+  const agentConfig = getGeminiDeepResearchAgentConfig(options.agent_config);
+  if (agentConfig) {
+    requestOptions.agent_config = agentConfig;
+  }
+  return requestOptions;
+}
+function getGeminiDeepResearchAgentConfig(value) {
+  if (!isPlainObject(value)) {
+    return void 0;
+  }
+  if (Object.keys(value).length === 0) {
+    return void 0;
+  }
+  const unknownKeys = Object.keys(value).filter(
+    (key) => key !== "thinking_summaries"
+  );
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `Unsupported Gemini agent_config options: ${unknownKeys.join(", ")}.`
+    );
+  }
+  const thinkingSummaries = readNonEmptyString(value.thinking_summaries);
+  if (thinkingSummaries !== "auto" && thinkingSummaries !== "none") {
+    throw new Error(
+      "Gemini agent_config.thinking_summaries must be 'auto' or 'none'."
+    );
+  }
+  return {
+    type: "deep-research",
+    thinking_summaries: thinkingSummaries
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+var adapter = {
+  async answer(input, config, context) {
+    return await geminiImplementation.answer(
+      input.query,
+      config,
+      context,
+      input.options
+    );
+  },
+  async research(input, config, context) {
+    return await geminiImplementation.research(
+      input.input,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter,
+  geminiImplementation
+};

package/dist/adapter-AUYLTDPM.js

@@ -0,0 +1,73 @@
+import {
+  orderedContents
+} from "./chunk-YZXM4U2C.js";
+import {
+  asWebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/providers/cloudflare/adapter.ts
+import CloudflareClient from "cloudflare";
+var cloudflareImplementation = {
+  async contents(urls, config, context, options) {
+    const client = createClient(config);
+    const accountId = config.accountId;
+    if (!accountId) {
+      throw new Error("is missing an account ID");
+    }
+    const answers = await Promise.all(
+      urls.map(async (url) => {
+        try {
+          const markdown = await client.browserRendering.markdown.create(
+            {
+              ...options ?? {},
+              account_id: accountId,
+              url
+            },
+            buildRequestOptions(context)
+          );
+          return {
+            url,
+            content: markdown
+          };
+        } catch (error) {
+          return {
+            url,
+            error: asWebfoxError(error).toJSON()
+          };
+        }
+      })
+    );
+    return {
+      provider: "cloudflare",
+      answers
+    };
+  }
+};
+function createClient(config) {
+  const apiToken = config.credentials?.api;
+  if (!apiToken) {
+    throw new Error("is missing an API token");
+  }
+  return new CloudflareClient({
+    maxRetries: 0,
+    apiToken
+  });
+}
+function buildRequestOptions(context) {
+  return context.signal ? { signal: context.signal } : void 0;
+}
+var adapter = {
+  async contents(input, config, context) {
+    return orderedContents(
+      await cloudflareImplementation.contents(
+        input.urls,
+        config,
+        context,
+        input.options
+      )
+    );
+  }
+};
+export {
+  adapter
+};