@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

package/dist/node-runtime/openai-search-B3MSNCQA.js

@@ -0,0 +1,288 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/openai-search.js
+import { existsSync, readFileSync } from "node:fs";
+var OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses", CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses", CONFIG_PATH = getWebSearchConfigPath(), SEARCH_TIMEOUT_MS = 6e4, AUTH_MODEL_CANDIDATES = [
+  { provider: "openai-codex", models: ["gpt-5.4", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.2", "gpt-5.2-codex"] },
+  { provider: "openai", models: ["gpt-5.4", "gpt-5.2", "gpt-4.1-mini", "gpt-4o"] }
+], cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedConfig = {}, cachedConfig;
+  let raw = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    return cachedConfig = JSON.parse(raw), cachedConfig;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input || (input.startsWith("-") && (input = input.slice(1).trim()), !input))
+    return null;
+  try {
+    input = (input.includes("://") ? new URL(input) : new URL(`https://${input}`)).hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  return input = input.replace(/^\.+|\.+$/g, ""), /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function normalizeDomainFilters(domainFilter) {
+  if (!domainFilter?.length)
+    return null;
+  let allowedDomains = [], blockedDomains = [];
+  for (let raw of domainFilter) {
+    let domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    let target = raw.trim().startsWith("-") ? blockedDomains : allowedDomains;
+    target.includes(domain) || target.push(domain);
+  }
+  return allowedDomains.length > 0 || blockedDomains.length > 0 ? {
+    ...allowedDomains.length > 0 ? { allowedDomains: allowedDomains.slice(0, 100) } : {},
+    ...blockedDomains.length > 0 ? { blockedDomains: blockedDomains.slice(0, 100) } : {}
+  } : null;
+}
+function decodeJwtPayload(token) {
+  let parts = token.split(".");
+  if (parts.length !== 3 || !parts[1])
+    return null;
+  try {
+    let padded = parts[1].replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(parts[1].length / 4) * 4, "="), parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+    return parsed && typeof parsed == "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isCodexJwt(token) {
+  return !!decodeJwtPayload(token)?.["https://api.openai.com/auth"];
+}
+function extractAccountId(token) {
+  let auth = decodeJwtPayload(token)?.["https://api.openai.com/auth"];
+  if (!auth || typeof auth != "object")
+    return;
+  let id = auth.chatgpt_account_id;
+  return typeof id == "string" && id.trim().length > 0 ? id.trim() : void 0;
+}
+async function resolveOpenAIAuth(ctx) {
+  if (ctx) {
+    let { getModel } = await import("@ashx-j/lunr-ai/compat");
+    for (let candidate of AUTH_MODEL_CANDIDATES)
+      for (let modelId of candidate.models) {
+        let model = getModel(candidate.provider, modelId);
+        if (model)
+          try {
+            let resolved = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+            if (resolved.ok && resolved.apiKey)
+              return {
+                provider: candidate.provider,
+                apiKey: resolved.apiKey,
+                model: modelId,
+                headers: resolved.headers ?? {}
+              };
+          } catch {
+          }
+      }
+  }
+  let apiKey = normalizeApiKey(process.env.OPENAI_API_KEY) ?? normalizeApiKey(loadConfig().openaiApiKey);
+  return apiKey ? { provider: "openai", apiKey, model: "gpt-5.4", headers: {} } : void 0;
+}
+async function isOpenAISearchAvailable(ctx) {
+  return !!await resolveOpenAIAuth(ctx);
+}
+function buildInstructions(options) {
+  let lines = [
+    "Search the web and return a concise answer grounded only in the web results.",
+    "Include clickable source citations in the response text when possible."
+  ];
+  if (options.recencyFilter) {
+    let labels = {
+      day: "past 24 hours",
+      week: "past week",
+      month: "past month",
+      year: "past year"
+    };
+    lines.push(`Prefer sources from the ${labels[options.recencyFilter]}.`);
+  }
+  typeof options.numResults == "number" && Number.isFinite(options.numResults) && options.numResults > 0 && lines.push(`Prefer around ${Math.min(Math.floor(options.numResults), 20)} distinct sources.`);
+  let filters = normalizeDomainFilters(options.domainFilter);
+  return filters?.allowedDomains?.length && lines.push(`Only use sources from: ${filters.allowedDomains.join(", ")}.`), filters?.blockedDomains?.length && lines.push(`Do not use sources from: ${filters.blockedDomains.join(", ")}.`), lines.join(" ");
+}
+function buildWebSearchTool(options) {
+  let tool = { type: "web_search" }, filters = normalizeDomainFilters(options.domainFilter);
+  return filters && (tool.filters = {
+    ...filters.allowedDomains ? { allowed_domains: filters.allowedDomains } : {},
+    ...filters.blockedDomains ? { blocked_domains: filters.blockedDomains } : {}
+  }), tool;
+}
+async function parseOpenAIResponse(response) {
+  let text = await response.text(), trimmed = text.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("["))
+    try {
+      let parsed = JSON.parse(trimmed);
+      return Array.isArray(parsed) ? { output: parsed } : parsed && typeof parsed == "object" ? parsed : { output: [] };
+    } catch (err) {
+      let message = err instanceof Error ? err.message : String(err);
+      throw new Error(`OpenAI API returned invalid JSON: ${message}`);
+    }
+  let outputItems = [], completedResponse = null;
+  for (let line of text.split(`
+`)) {
+    if (!line.startsWith("data: "))
+      continue;
+    let data = line.slice(6).trim();
+    if (!(!data || data === "[DONE]"))
+      try {
+        let parsed = JSON.parse(data);
+        parsed.type === "response.output_item.done" && parsed.item && outputItems.push(parsed.item), (parsed.type === "response.done" || parsed.type === "response.completed") && parsed.response && typeof parsed.response == "object" && (completedResponse = parsed.response);
+      } catch {
+      }
+  }
+  if (completedResponse)
+    return (Array.isArray(completedResponse.output) ? completedResponse.output : []).length > 0 ? completedResponse : { ...completedResponse, output: outputItems };
+  if (outputItems.length > 0)
+    return { output: outputItems };
+  throw new Error("OpenAI API returned no parseable response output");
+}
+function cleanSourceUrl(rawUrl) {
+  try {
+    let url = new URL(rawUrl);
+    return url.searchParams.get("utm_source") === "openai" && url.searchParams.delete("utm_source"), url.toString();
+  } catch {
+    return rawUrl.replace(/[?&]utm_source=openai$/, "");
+  }
+}
+function extractSnippetAround(text, start, end) {
+  if (typeof start != "number" || typeof end != "number" || !text)
+    return "";
+  let before = Math.max(0, start - 100), after = Math.min(text.length, end + 100), snippet = text.slice(before, after).replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").trim();
+  return snippet.length > 300 ? `${snippet.slice(0, 297)}...` : snippet;
+}
+function addResult(results, seen, url, title, snippet = "") {
+  if (typeof url != "string" || url.trim().length === 0)
+    return;
+  let cleanUrl = cleanSourceUrl(url);
+  seen.has(cleanUrl) || (seen.add(cleanUrl), results.push({
+    title: typeof title == "string" && title.trim().length > 0 ? title : cleanUrl,
+    url: cleanUrl,
+    snippet
+  }));
+}
+function extractSearchResults(output, numResults) {
+  let results = [], seenUrls = /* @__PURE__ */ new Set();
+  for (let item of output) {
+    if (!item || typeof item != "object" || item.type !== "message")
+      continue;
+    let content = item.content;
+    if (Array.isArray(content))
+      for (let part of content) {
+        if (!part || typeof part != "object")
+          continue;
+        let text = typeof part.text == "string" ? part.text : "", annotations = part.annotations;
+        if (Array.isArray(annotations))
+          for (let annotation of annotations)
+            !annotation || typeof annotation != "object" || annotation.type !== "url_citation" || addResult(results, seenUrls, annotation.url, annotation.title, extractSnippetAround(text, annotation.start_index, annotation.end_index));
+      }
+  }
+  for (let item of output) {
+    if (!item || typeof item != "object" || item.type !== "web_search_call")
+      continue;
+    let value = item, sourceGroups = [value.action && typeof value.action == "object" ? value.action.sources : void 0, value.sources, value.results];
+    for (let group of sourceGroups)
+      if (Array.isArray(group))
+        for (let source of group) {
+          if (!source || typeof source != "object")
+            continue;
+          let record = source;
+          addResult(results, seenUrls, record.url ?? record.source_website_url, record.title ?? record.caption);
+        }
+  }
+  return typeof numResults == "number" && Number.isFinite(numResults) && numResults > 0 ? results.slice(0, Math.min(Math.floor(numResults), 20)) : results;
+}
+function extractAnswer(output) {
+  let parts = [];
+  for (let item of output) {
+    if (!item || typeof item != "object" || item.type !== "message")
+      continue;
+    let content = item.content;
+    if (Array.isArray(content))
+      for (let part of content) {
+        if (!part || typeof part != "object")
+          continue;
+        let text = part.text;
+        typeof text == "string" && text.trim().length > 0 && parts.push(text);
+      }
+  }
+  return parts.join(`
+`).trim();
+}
+async function searchWithOpenAI(query, options = {}, ctx) {
+  let auth = await resolveOpenAIAuth(ctx);
+  if (!auth)
+    throw new Error(`OpenAI web search unavailable. Either:
+  1. Use /login to sign in with a Codex subscription
+  2. Create ${CONFIG_PATH} with { "openaiApiKey": "your-key" }
+  3. Set OPENAI_API_KEY environment variable`);
+  let activityId = activityMonitor.logStart({ type: "api", query }), headers = {
+    ...auth.headers,
+    Authorization: `Bearer ${auth.apiKey}`,
+    "Content-Type": "application/json",
+    "OpenAI-Beta": "responses=experimental"
+  }, useCodexEndpoint = auth.provider === "openai-codex" || isCodexJwt(auth.apiKey);
+  if (useCodexEndpoint) {
+    let accountId = extractAccountId(auth.apiKey);
+    accountId && (headers["chatgpt-account-id"] = accountId), headers.originator = "pi";
+  }
+  let body = {
+    model: auth.model,
+    instructions: buildInstructions(options),
+    input: [{ role: "user", content: [{ type: "input_text", text: query }] }],
+    tools: [buildWebSearchTool(options)],
+    include: ["web_search_call.action.sources"],
+    store: !1,
+    stream: !0,
+    tool_choice: "required",
+    parallel_tool_calls: !0
+  };
+  try {
+    let response = await fetch(useCodexEndpoint ? CODEX_RESPONSES_URL : OPENAI_RESPONSES_URL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      activityMonitor.logError(activityId, `HTTP ${response.status}`);
+      let errorText = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${errorText.slice(0, 300)}`);
+    }
+    let parsed = await parseOpenAIResponse(response), output = Array.isArray(parsed.output) ? parsed.output : [], answer = extractAnswer(output), results = extractSearchResults(output, options.numResults);
+    if (!answer && results.length === 0)
+      throw new Error("OpenAI web_search returned no answer or sources");
+    return activityMonitor.logComplete(activityId, response.status), { answer, results };
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+}
+export {
+  isOpenAISearchAvailable,
+  resolveOpenAIAuth,
+  searchWithOpenAI
+};