webfox 0.0.0-test.0 → 4.0.0

package/dist/adapter-HITGYUXN.js

@@ -0,0 +1,494 @@
+import {
+  executeAsyncResearch
+} from "./chunk-EF4VMDZL.js";
+import "./chunk-I2UIACY3.js";
+import "./chunk-WCTOYZVB.js";
+import {
+  trimSnippet
+} from "./chunk-X6ZBIHZC.js";
+import "./chunk-U4BLULLV.js";
+
+// src/providers/openai/adapter.ts
+import OpenAI from "openai";
+var DEFAULT_SEARCH_MODEL = "gpt-4.1";
+var DEFAULT_ANSWER_MODEL = "gpt-4.1";
+var DEFAULT_RESEARCH_MODEL = "o4-mini-deep-research";
+var searchResultSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["sources"],
+  properties: {
+    sources: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["title", "url", "snippet"],
+        properties: {
+          title: { type: "string" },
+          url: { type: "string" },
+          snippet: { type: "string" }
+        }
+      }
+    }
+  }
+};
+var openaiImplementation = {
+  async search(query, maxResults, config, context, options) {
+    const client = createClient(config);
+    const response = await client.responses.create(
+      buildOpenAISearchRequest(query, maxResults, options),
+      buildRequestOptions(context.signal, context.idempotencyKey)
+    );
+    return parseSearchResponse(response, maxResults);
+  },
+  async answer(query, config, context, options) {
+    const client = createClient(config);
+    const response = await client.responses.create(
+      buildOpenAIAnswerRequest(query, options),
+      buildRequestOptions(context.signal, context.idempotencyKey)
+    );
+    return ensureCompletedResponse(response, "answer");
+  },
+  async research(input, config, context, options) {
+    return await executeAsyncResearch({
+      providerLabel: "OpenAI",
+      providerId: "openai",
+      context,
+      start: (researchContext) => openaiImplementation.startResearch(
+        input,
+        config,
+        researchContext,
+        options
+      ),
+      poll: (id, researchContext) => openaiImplementation.pollResearch(id, config, researchContext, options)
+    });
+  },
+  async startResearch(input, config, context, options) {
+    const client = createClient(config);
+    const response = await client.responses.create(
+      buildOpenAIResearchRequest(input, options),
+      buildRequestOptions(context.signal, context.idempotencyKey)
+    );
+    return { id: response.id };
+  },
+  async pollResearch(id, config, context, _options) {
+    const client = createClient(config);
+    const response = await client.responses.retrieve(
+      id,
+      void 0,
+      buildRequestOptions(context.signal)
+    );
+    const status = response.status ?? "completed";
+    if (status === "completed") {
+      return {
+        status: "completed",
+        output: formatResponseOutput(response, "research")
+      };
+    }
+    if (status === "failed") {
+      return {
+        status: "failed",
+        error: response.error?.message ?? "research failed"
+      };
+    }
+    if (status === "cancelled") {
+      return {
+        status: "cancelled",
+        error: "research was canceled"
+      };
+    }
+    if (status === "incomplete") {
+      return {
+        status: "failed",
+        error: formatIncompleteError(response, "research")
+      };
+    }
+    return {
+      status: "in_progress",
+      statusText: status
+    };
+  }
+};
+function createClient(config) {
+  const apiKey = config.credentials?.api;
+  if (!apiKey) {
+    throw new Error("is missing an API key");
+  }
+  const baseUrl = config.baseUrl;
+  return new OpenAI({
+    maxRetries: 0,
+    apiKey,
+    ...baseUrl ? { baseURL: baseUrl } : {}
+  });
+}
+function generationControls(options) {
+  const reasoning = options?.reasoning;
+  const effort = readStringUnion(reasoning?.effort, [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ]);
+  const maxTokens = readPositiveInteger(options?.max_output_tokens);
+  return {
+    ...effort ? { reasoning: { effort } } : {},
+    ...maxTokens ? { max_output_tokens: maxTokens } : {}
+  };
+}
+function buildOpenAISearchRequest(query, maxResults, options) {
+  const mergedOptions = resolveOpenAISearchOptions(options);
+  const model = mergedOptions.model ?? DEFAULT_SEARCH_MODEL;
+  const instructions = mergedOptions.instructions;
+  return {
+    model,
+    ...generationControls(options),
+    input: [
+      "Search the public web and return only the most relevant sources for the user's query.",
+      `Return at most ${maxResults} sources.`,
+      "Prefer official, primary, or highly reputable sources when available.",
+      "Each snippet should be short, specific, and grounded in the retrieved source.",
+      "Return only data matching the provided JSON schema.",
+      "",
+      `User query: ${query}`
+    ].join("\n"),
+    tools: [buildOpenAIWebSearchTool(mergedOptions)],
+    text: {
+      format: {
+        type: "json_schema",
+        name: "openai_web_search_results",
+        schema: searchResultSchema,
+        strict: true
+      }
+    },
+    ...instructions ? { instructions } : {}
+  };
+}
+function buildOpenAIAnswerRequest(query, options) {
+  const mergedOptions = resolveOpenAIAnswerOptions(options);
+  const model = mergedOptions.model ?? DEFAULT_ANSWER_MODEL;
+  const instructions = mergedOptions.instructions;
+  return {
+    model,
+    ...generationControls(options),
+    input: query,
+    tools: [buildOpenAIWebSearchTool(mergedOptions)],
+    ...instructions ? { instructions } : {}
+  };
+}
+function buildOpenAIResearchRequest(input, options) {
+  const mergedOptions = resolveOpenAIResearchOptions(options);
+  const model = mergedOptions.model ?? DEFAULT_RESEARCH_MODEL;
+  const instructions = mergedOptions.instructions;
+  const maxToolCalls = mergedOptions.max_tool_calls;
+  return {
+    model,
+    ...generationControls(options),
+    input,
+    background: true,
+    tools: [buildOpenAIWebSearchTool(mergedOptions)],
+    ...instructions ? { instructions } : {},
+    ...maxToolCalls ? { max_tool_calls: maxToolCalls } : {}
+  };
+}
+function buildOpenAIWebSearchTool(options) {
+  const tool = { type: "web_search" };
+  if (options.externalWebAccess !== void 0)
+    tool.external_web_access = options.externalWebAccess;
+  if (options.searchContextSize) {
+    tool.search_context_size = options.searchContextSize;
+  }
+  if (options.allowedDomains && options.allowedDomains.length > 0) {
+    tool.filters = { allowed_domains: options.allowedDomains };
+  }
+  if (options.userLocation) {
+    tool.user_location = {
+      type: "approximate",
+      ...options.userLocation
+    };
+  }
+  return tool;
+}
+function resolveOpenAIWebSearchToolOptions(merged) {
+  const searchContextSize = readStringUnion(merged.searchContextSize, [
+    "low",
+    "medium",
+    "high"
+  ]);
+  const allowedDomains = readStringArray(merged.allowedDomains);
+  const userLocation = readUserLocation(merged.userLocation);
+  return {
+    ...typeof merged.externalWebAccess === "boolean" ? { externalWebAccess: merged.externalWebAccess } : {},
+    ...searchContextSize ? { searchContextSize } : {},
+    ...allowedDomains ? { allowedDomains } : {},
+    ...userLocation ? { userLocation } : {}
+  };
+}
+function resolveOpenAISearchOptions(options) {
+  const mergedOptions = {
+    ...options ?? {}
+  };
+  const model = readNonEmptyString(mergedOptions.model);
+  const instructions = readNonEmptyString(mergedOptions.instructions);
+  return {
+    ...model ? { model } : {},
+    ...instructions ? { instructions } : {},
+    ...resolveOpenAIWebSearchToolOptions(mergedOptions)
+  };
+}
+function resolveOpenAIAnswerOptions(options) {
+  const mergedOptions = {
+    ...options ?? {}
+  };
+  const model = readNonEmptyString(mergedOptions.model);
+  const instructions = readNonEmptyString(mergedOptions.instructions);
+  return {
+    ...model ? { model } : {},
+    ...instructions ? { instructions } : {},
+    ...resolveOpenAIWebSearchToolOptions(mergedOptions)
+  };
+}
+function resolveOpenAIResearchOptions(options) {
+  const mergedOptions = {
+    ...options ?? {}
+  };
+  const model = readNonEmptyString(mergedOptions.model);
+  const instructions = readNonEmptyString(mergedOptions.instructions);
+  const maxToolCalls = readPositiveInteger(mergedOptions.max_tool_calls);
+  return {
+    ...model ? { model } : {},
+    ...instructions ? { instructions } : {},
+    ...maxToolCalls ? { max_tool_calls: maxToolCalls } : {},
+    ...resolveOpenAIWebSearchToolOptions(mergedOptions)
+  };
+}
+function buildRequestOptions(signal, idempotencyKey) {
+  if (!signal && !idempotencyKey) {
+    return void 0;
+  }
+  return {
+    ...signal ? { signal } : {},
+    ...idempotencyKey ? { idempotencyKey } : {}
+  };
+}
+function parseSearchResponse(response, maxResults) {
+  const status = response.status ?? "completed";
+  if (status === "failed") {
+    throw new Error(response.error?.message ?? "search failed");
+  }
+  if (status === "cancelled") {
+    throw new Error("search was canceled");
+  }
+  if (status === "incomplete") {
+    throw new Error(formatIncompleteError(response, "search"));
+  }
+  if (status !== "completed") {
+    throw new Error(`search did not complete (status: ${status})`);
+  }
+  const payload = parseSearchPayload(response.output_text);
+  return {
+    provider: "openai",
+    results: payload.sources.slice(0, maxResults).map((source) => ({
+      title: source.title.trim(),
+      url: source.url.trim(),
+      snippet: trimSnippet(source.snippet)
+    }))
+  };
+}
+function ensureCompletedResponse(response, operation) {
+  const status = response.status ?? "completed";
+  if (status === "completed") {
+    return formatResponseOutput(response, operation);
+  }
+  if (status === "failed") {
+    throw new Error(response.error?.message ?? `${operation} failed`);
+  }
+  if (status === "cancelled") {
+    throw new Error(`${operation} was canceled`);
+  }
+  if (status === "incomplete") {
+    throw new Error(formatIncompleteError(response, operation));
+  }
+  throw new Error(`${operation} did not complete (status: ${status})`);
+}
+function formatResponseOutput(response, operation) {
+  const lines = [];
+  lines.push(
+    response.output_text?.trim() || `OpenAI ${operation} completed without textual output.`
+  );
+  const citations = extractUrlCitations(response);
+  if (citations.length > 0) {
+    lines.push("");
+    lines.push("Sources:");
+    for (const [index, citation] of citations.entries()) {
+      lines.push(`${index + 1}. ${citation.title}`);
+      lines.push(`   ${citation.url}`);
+    }
+  }
+  return {
+    provider: "openai",
+    text: lines.join("\n").trimEnd(),
+    itemCount: citations.length,
+    metadata: {
+      responseId: response.id,
+      model: response.model,
+      citations
+    }
+  };
+}
+function extractUrlCitations(response) {
+  const citations = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of response.output) {
+    if (item.type !== "message" || !item.content) {
+      continue;
+    }
+    for (const content of item.content) {
+      if (content.type !== "output_text" || !content.annotations) {
+        continue;
+      }
+      for (const annotation of content.annotations) {
+        if (annotation.type !== "url_citation") {
+          continue;
+        }
+        const title = readNonEmptyString(annotation.title);
+        const url = readNonEmptyString(annotation.url);
+        const startIndex = readInteger(annotation.start_index);
+        const endIndex = readInteger(annotation.end_index);
+        if (!title || !url || startIndex === void 0 || endIndex === void 0) {
+          continue;
+        }
+        const citation = {
+          title,
+          url,
+          startIndex,
+          endIndex
+        };
+        const key = [
+          citation.title,
+          citation.url,
+          String(citation.startIndex),
+          String(citation.endIndex)
+        ].join("::");
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        citations.push(citation);
+      }
+    }
+  }
+  return citations;
+}
+function parseSearchPayload(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text ?? "");
+  } catch (error) {
+    throw new Error(
+      `search returned invalid JSON: ${error.message}`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || !("sources" in parsed) || !Array.isArray(parsed.sources)) {
+    throw new Error("search output must include a 'sources' array");
+  }
+  return {
+    sources: parsed.sources.map((source, index) => {
+      if (typeof source !== "object" || source === null) {
+        throw new Error(`search source at index ${index} must be an object`);
+      }
+      const entry = source;
+      const title = readNonEmptyString(entry.title);
+      const url = readNonEmptyString(entry.url);
+      const snippet = readNonEmptyString(entry.snippet);
+      if (!title) {
+        throw new Error(`search source at index ${index} is missing title`);
+      }
+      if (!url) {
+        throw new Error(`search source at index ${index} is missing url`);
+      }
+      if (!snippet) {
+        throw new Error(`search source at index ${index} is missing snippet`);
+      }
+      return { title, url, snippet };
+    })
+  };
+}
+function formatIncompleteError(response, operation) {
+  const reason = response.incomplete_details?.reason;
+  if (reason) {
+    return `${operation} ended incomplete (${reason})`;
+  }
+  return `${operation} ended incomplete`;
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const strings = value.filter(
+    (item) => typeof item === "string" && item.trim() !== ""
+  );
+  return strings.length > 0 ? strings : void 0;
+}
+function readStringUnion(value, values) {
+  return typeof value === "string" && values.includes(value) ? value : void 0;
+}
+function readUserLocation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const location = value;
+  const city = readNonEmptyString(location.city);
+  const country = readNonEmptyString(location.country);
+  const region = readNonEmptyString(location.region);
+  const timezone = readNonEmptyString(location.timezone);
+  const result = {
+    ...city ? { city } : {},
+    ...country ? { country } : {},
+    ...region ? { region } : {},
+    ...timezone ? { timezone } : {}
+  };
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function readPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function readInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : void 0;
+}
+var adapter = {
+  async search(input, config, context) {
+    return await openaiImplementation.search(
+      input.query,
+      input.maxResults,
+      config,
+      context,
+      input.options
+    );
+  },
+  async answer(input, config, context) {
+    return await openaiImplementation.answer(
+      input.query,
+      config,
+      context,
+      input.options
+    );
+  },
+  async research(input, config, context) {
+    return await openaiImplementation.research(
+      input.input,
+      config,
+      context,
+      input.options
+    );
+  }
+};
+export {
+  adapter
+};