@mini-z/dsh-search-providers 0.1.2

package/dsh/index.js

@@ -0,0 +1,1211 @@
+import { randomUUID } from "node:crypto";
+import { statSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+const DEFAULT_TIMEOUT_MS = 55e3;
+function resolveProviderConfig(pluginConfig, providerId, envPrefix) {
+  const pc = pluginConfig.providers?.[providerId] ?? {};
+  const apiKey = process.env[`${envPrefix}_API_KEY`] ?? pc.apiKey;
+  const baseUrl = process.env[`${envPrefix}_BASE_URL`] ?? pc.baseUrl;
+  const timeoutMs = Number(process.env[`${envPrefix}_TIMEOUT_MS`]) || pc.timeoutMs || DEFAULT_TIMEOUT_MS;
+  return {
+    apiKey,
+    baseUrl,
+    timeoutMs,
+    options: pc.options ?? {}
+  };
+}
+class ProviderAuthenticationError extends Error {
+  kind = "provider-auth";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProviderAuthenticationError";
+  }
+}
+class ProviderHttpError extends Error {
+  constructor(message, status, options) {
+    super(message, options);
+    this.status = status;
+    this.name = "ProviderHttpError";
+  }
+  kind = "provider-http";
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)),
+    timeoutMs
+  );
+  try {
+    const signal = init.signal ? combineSignals(init.signal, controller.signal) : controller.signal;
+    return await fetch(url, { ...init, signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function combineSignals(a, b) {
+  return AbortSignal.any([a, b]);
+}
+async function throwOnError(response, label) {
+  if (response.ok) return;
+  const text = await response.text().catch(() => "");
+  let detail = text.slice(0, 500);
+  if (response.status === 401) {
+    detail = "Invalid or missing API key";
+  } else if (response.status === 429) {
+    detail = "Rate limit exceeded";
+  } else if (response.status === 432) {
+    detail = "Usage limit exceeded";
+  }
+  const message = `${label} returned ${response.status}: ${detail}`;
+  if (response.status === 401) {
+    throw new ProviderAuthenticationError(message);
+  }
+  throw new ProviderHttpError(message, response.status);
+}
+class CooldownController {
+  disabled = /* @__PURE__ */ new Map();
+  cooling = /* @__PURE__ */ new Map();
+  /** Record one capability failure. Confirmed authentication failures are provider-global. */
+  record(providerId, capability, error) {
+    if (error instanceof ProviderAuthenticationError) {
+      this.disabled.set(providerId, {
+        until: Number.POSITIVE_INFINITY,
+        reason: "invalid credentials"
+      });
+      return true;
+    }
+    this.cooling.set(this.capabilityKey(providerId, capability), {
+      until: Date.now() + this.cooldownDuration(error),
+      reason: this.classifyError(error)
+    });
+    return true;
+  }
+  /** Check whether one provider capability is temporarily cooling. */
+  isCooling(providerId, capability) {
+    return this.getEntry(this.cooling, this.capabilityKey(providerId, capability)) !== void 0;
+  }
+  /** Check whether confirmed authentication failure disabled the provider until restart. */
+  isDisabled(providerId) {
+    return this.getEntry(this.disabled, providerId) !== void 0;
+  }
+  /** Get the current failure reason, if any. */
+  getReason(providerId, capability) {
+    return this.getEntry(this.disabled, providerId)?.reason ?? this.getEntry(this.cooling, this.capabilityKey(providerId, capability))?.reason;
+  }
+  /** Build candidates while separating global disablement from capability cooldown. */
+  filter(chain, capability) {
+    const ready = [];
+    const cooling = [];
+    const disabled = [];
+    for (const id of chain) {
+      if (this.isDisabled(id)) {
+        disabled.push(id);
+      } else if (this.isCooling(id, capability)) {
+        cooling.push(id);
+      } else {
+        ready.push(id);
+      }
+    }
+    return { ready, cooling, disabled };
+  }
+  capabilityKey(providerId, capability) {
+    return `${providerId}:${capability}`;
+  }
+  getEntry(map, key) {
+    const entry = map.get(key);
+    if (!entry) return void 0;
+    if (Date.now() >= entry.until) {
+      map.delete(key);
+      return void 0;
+    }
+    return entry;
+  }
+  classifyError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (this.isRateLimitError(error, message)) return "rate limit or quota exceeded";
+    if (/timeout|timed out/i.test(message)) return "timeout";
+    if (/network|ENOTFOUND|ECONNREFUSED|fetch failed/i.test(message)) return "network error";
+    return "request failed";
+  }
+  cooldownDuration(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (this.isRateLimitError(error, message)) return 5 * 60 * 1e3;
+    if (/timeout|timed out|network|ENOTFOUND|ECONNREFUSED|fetch failed/i.test(message)) {
+      return 30 * 1e3;
+    }
+    return 10 * 1e3;
+  }
+  isRateLimitError(error, message) {
+    return error instanceof ProviderHttpError && (error.status === 429 || error.status === 432) || /429|432|rate.?limit|quota|usage limit|out of credits|monthly quota/i.test(message);
+  }
+}
+class ProviderRegistry {
+  providers = /* @__PURE__ */ new Map();
+  activeId;
+  register(provider) {
+    if (this.providers.has(provider.id)) {
+      console.warn(`[search-providers] provider '${provider.id}' already registered; overwriting`);
+    }
+    this.providers.set(provider.id, provider);
+    if (this.activeId === void 0) {
+      this.activeId = provider.id;
+    }
+  }
+  setActive(id) {
+    if (!this.providers.has(id)) {
+      throw new Error(`Provider '${id}' is not registered`);
+    }
+    this.activeId = id;
+  }
+  getActive() {
+    if (this.activeId === void 0) {
+      throw new Error("No search provider registered");
+    }
+    const provider = this.providers.get(this.activeId);
+    if (!provider) {
+      throw new Error(`Active provider '${this.activeId}' disappeared`);
+    }
+    return provider;
+  }
+  get(id) {
+    return this.providers.get(id);
+  }
+  list() {
+    return Array.from(this.providers.keys());
+  }
+}
+class TinyfishProvider {
+  id = "tinyfish";
+  name = "TinyFish";
+  description = "TinyFish Search & Fetch (free tier, live web results)";
+  searchable = true;
+  fetchable = true;
+  apiKey;
+  searchBaseUrl;
+  fetchBaseUrl;
+  timeoutMs;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.searchBaseUrl = config.baseUrl ?? "https://api.search.tinyfish.ai";
+    this.fetchBaseUrl = config.options?.fetchBaseUrl ?? "https://api.fetch.tinyfish.ai";
+    this.timeoutMs = config.timeoutMs;
+  }
+  available() {
+    return typeof this.apiKey === "string" && this.apiKey !== "";
+  }
+  async search(request, signal) {
+    this.ensureKey();
+    const url = new URL(this.searchBaseUrl);
+    url.searchParams.set("query", request.query);
+    if (request.maxResults && request.maxResults > 0) {
+      url.searchParams.set("max_results", String(Math.floor(request.maxResults)));
+    }
+    if (typeof request.recencyDays === "number" && request.recencyDays > 0) {
+      url.searchParams.set("recency_minutes", String(Math.floor(request.recencyDays * 24 * 60)));
+    }
+    if (request.purpose) {
+      url.searchParams.set("purpose", request.purpose);
+    }
+    if (request.location) {
+      url.searchParams.set("location", request.location);
+    }
+    if (request.language) {
+      url.searchParams.set("language", request.language);
+    }
+    if (request.domainType) {
+      url.searchParams.set("domain_type", request.domainType);
+    }
+    if (request.includeDomains && request.includeDomains.length > 0) {
+      url.searchParams.set("include_domains", request.includeDomains.join(","));
+    }
+    if (request.excludeDomains && request.excludeDomains.length > 0) {
+      url.searchParams.set("exclude_domains", request.excludeDomains.join(","));
+    }
+    const response = await fetchWithTimeout(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": this.apiKey,
+        Accept: "application/json"
+      },
+      signal
+    }, this.timeoutMs);
+    await throwOnError(response, "TinyFish Search");
+    const body = await response.json();
+    const items = (body.results ?? []).map((r) => ({
+      title: r.title,
+      url: r.url,
+      snippet: r.snippet,
+      source: r.site_name
+    }));
+    return {
+      status: "ok",
+      source: this.name,
+      summary: items.length > 0 ? `Found ${body.total_results ?? items.length} result(s) for "${request.query}"` : `No results found for "${request.query}"`,
+      items,
+      uncertainty: items.length === 0 ? ["No search results returned"] : []
+    };
+  }
+  async fetch(request, signal) {
+    this.ensureKey();
+    const body = {
+      urls: [request.url],
+      format: request.format ?? "markdown"
+    };
+    if (request.query) {
+      body.purpose = request.query;
+    }
+    if (typeof request.ttl === "number") {
+      body.ttl = request.ttl;
+    }
+    const response = await fetchWithTimeout(this.fetchBaseUrl, {
+      method: "POST",
+      headers: {
+        "X-API-Key": this.apiKey,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal
+    }, this.timeoutMs);
+    await throwOnError(response, "TinyFish Fetch");
+    const data = await response.json();
+    const page = data.results?.[0];
+    const error = data.errors?.[0];
+    if (!page && error) {
+      throw new Error(`TinyFish Fetch failed for ${error.url}: ${error.error}`);
+    }
+    if (!page) {
+      throw new Error("TinyFish Fetch returned no content");
+    }
+    return {
+      summary: page.title ?? page.description ?? "Fetched page content",
+      content: page.text ?? "",
+      uncertainty: [],
+      warnings: []
+    };
+  }
+  ensureKey() {
+    if (!this.apiKey) {
+      throw new Error(
+        "TinyFish API key is missing. Set TINYFISH_API_KEY or configure providers.tinyfish.apiKey."
+      );
+    }
+  }
+}
+class TavilyProvider {
+  id = "tavily";
+  name = "Tavily";
+  description = "Tavily web search";
+  searchable = true;
+  fetchable = false;
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.tavily.com";
+    this.timeoutMs = config.timeoutMs;
+  }
+  available() {
+    return typeof this.apiKey === "string" && this.apiKey !== "";
+  }
+  async search(request, signal) {
+    this.ensureKey();
+    const body = {
+      query: request.query,
+      search_depth: "basic",
+      max_results: request.maxResults ?? 5
+    };
+    if (request.includeDomains && request.includeDomains.length > 0) {
+      body.include_domains = request.includeDomains;
+    }
+    if (request.excludeDomains && request.excludeDomains.length > 0) {
+      body.exclude_domains = request.excludeDomains;
+    }
+    const response = await fetchWithTimeout(`${this.baseUrl}/search`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal
+    }, this.timeoutMs);
+    await throwOnError(response, "Tavily Search");
+    const data = await response.json();
+    const items = (data.results ?? []).map((r) => ({
+      title: r.title,
+      url: r.url,
+      snippet: r.content ?? r.raw_content ?? ""
+    }));
+    return {
+      status: "ok",
+      source: this.name,
+      summary: items.length > 0 ? `Found ${items.length} result(s) for "${request.query}"` : `No results found for "${request.query}"`,
+      items,
+      uncertainty: items.length === 0 ? ["No search results returned"] : []
+    };
+  }
+  ensureKey() {
+    if (!this.apiKey) {
+      throw new Error("Tavily API key is missing. Set TAVILY_API_KEY or configure providers.tavily.apiKey.");
+    }
+  }
+}
+class ExaProvider {
+  id = "exa";
+  name = "Exa";
+  description = "Exa neural web search and contents fetch";
+  searchable = true;
+  fetchable = true;
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.exa.ai";
+    this.timeoutMs = config.timeoutMs;
+  }
+  available() {
+    return typeof this.apiKey === "string" && this.apiKey !== "";
+  }
+  async search(request, signal) {
+    this.ensureKey();
+    const body = {
+      query: request.query,
+      num_results: request.maxResults ?? 5,
+      type: "auto"
+    };
+    if (request.includeDomains && request.includeDomains.length > 0) {
+      body.include_domains = request.includeDomains;
+    }
+    if (request.excludeDomains && request.excludeDomains.length > 0) {
+      body.exclude_domains = request.excludeDomains;
+    }
+    const response = await fetchWithTimeout(`${this.baseUrl}/search`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal
+    }, this.timeoutMs);
+    await throwOnError(response, "Exa Search");
+    const data = await response.json();
+    const items = (data.results ?? []).map((r) => ({
+      title: r.title ?? r.url,
+      url: r.url,
+      snippet: r.text ?? "",
+      publishedAt: r.publishedDate
+    }));
+    return {
+      status: "ok",
+      source: this.name,
+      summary: items.length > 0 ? `Found ${items.length} result(s) for "${request.query}"` : `No results found for "${request.query}"`,
+      items,
+      uncertainty: items.length === 0 ? ["No search results returned"] : []
+    };
+  }
+  async fetch(request, signal) {
+    this.ensureKey();
+    const body = {
+      urls: [request.url],
+      text: true
+    };
+    const response = await fetchWithTimeout(`${this.baseUrl}/contents`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal
+    }, this.timeoutMs);
+    await throwOnError(response, "Exa Contents");
+    const data = await response.json();
+    const page = data.results?.[0];
+    if (!page) {
+      throw new Error("Exa Contents returned no content");
+    }
+    return {
+      summary: page.title ?? "Fetched page content",
+      content: page.text ?? "",
+      uncertainty: [],
+      warnings: []
+    };
+  }
+  ensureKey() {
+    if (!this.apiKey) {
+      throw new Error("Exa API key is missing. Set EXA_API_KEY or configure providers.exa.apiKey.");
+    }
+  }
+}
+class FirecrawlProvider {
+  id = "firecrawl";
+  name = "Firecrawl";
+  description = "Firecrawl web search and page scrape";
+  searchable = true;
+  fetchable = true;
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.firecrawl.dev";
+    this.timeoutMs = config.timeoutMs;
+  }
+  available() {
+    return typeof this.apiKey === "string" && this.apiKey !== "";
+  }
+  async search(request, signal) {
+    this.ensureKey();
+    const body = {
+      query: request.query,
+      limit: request.maxResults ?? 5,
+      sources: ["web"]
+    };
+    if (request.includeDomains && request.includeDomains.length > 0) {
+      body.includeDomains = request.includeDomains;
+    }
+    if (request.excludeDomains && request.excludeDomains.length > 0) {
+      body.excludeDomains = request.excludeDomains;
+    }
+    const response = await fetchWithTimeout(`${this.baseUrl}/v2/search`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal
+    }, this.timeoutMs);
+    await throwOnError(response, "Firecrawl Search");
+    const data = await response.json();
+    if (data.success === false) {
+      throw new Error("Firecrawl Search returned success: false");
+    }
+    const rawItems = data.data?.web ?? [];
+    const items = rawItems.map((r) => ({
+      title: r.title ?? r.url,
+      url: r.url,
+      snippet: r.description ?? r.markdown ?? ""
+    }));
+    return {
+      status: "ok",
+      source: this.name,
+      summary: items.length > 0 ? `Found ${items.length} result(s) for "${request.query}"` : `No results found for "${request.query}"`,
+      items,
+      uncertainty: items.length === 0 ? ["No search results returned"] : []
+    };
+  }
+  async fetch(request, signal) {
+    this.ensureKey();
+    const body = {
+      url: request.url,
+      formats: ["markdown"]
+    };
+    const response = await fetchWithTimeout(`${this.baseUrl}/v2/scrape`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal
+    }, this.timeoutMs);
+    await throwOnError(response, "Firecrawl Scrape");
+    const data = await response.json();
+    if (data.success === false) {
+      throw new Error("Firecrawl Scrape returned success: false");
+    }
+    return {
+      summary: data.data?.metadata?.title ?? "Fetched page content",
+      content: data.data?.markdown ?? "",
+      uncertainty: [],
+      warnings: []
+    };
+  }
+  ensureKey() {
+    if (!this.apiKey) {
+      throw new Error("Firecrawl API key is missing. Set FIRECRAWL_API_KEY or configure providers.firecrawl.apiKey.");
+    }
+  }
+}
+const CODEX_SEARCH_URL = "https://chatgpt.com/backend-api/codex/alpha/search";
+const MAX_CREDENTIAL_BYTES = 128 * 1024;
+const MAX_SUCCESS_RESPONSE_BYTES = 4 * 1024 * 1024;
+const MAX_ERROR_RESPONSE_BYTES = 64 * 1024;
+class CodexProvider {
+  id = "codex";
+  name = "OpenAI Codex";
+  description = "ChatGPT Codex standalone web search";
+  searchable = true;
+  fetchable = false;
+  credentialFile;
+  timeoutMs;
+  constructor(config) {
+    this.credentialFile = configuredCredentialFile();
+    this.timeoutMs = Number.isFinite(config.timeoutMs) && config.timeoutMs > 0 ? config.timeoutMs : 55e3;
+  }
+  available() {
+    return this.credentialFile !== void 0 && loadStaticCredential(this.credentialFile) !== void 0;
+  }
+  async search(request, signal) {
+    throwIfAborted$1(signal);
+    const credential = this.credentialFile === void 0 ? void 0 : loadStaticCredential(this.credentialFile);
+    if (!credential) {
+      throw new Error("OpenAI Codex credential file is not configured, missing or invalid");
+    }
+    const body = {
+      id: randomUUID(),
+      model: "gpt-5.6-sol",
+      input: [{
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: request.query }]
+      }],
+      commands: { search_query: [{ q: request.query }] },
+      settings: {
+        search_context_size: "medium",
+        allowed_callers: ["direct"],
+        external_web_access: false
+      },
+      max_output_tokens: 1e4
+    };
+    const requestTimeout = AbortSignal.timeout(this.timeoutMs);
+    const requestSignal = signal ? AbortSignal.any([signal, requestTimeout]) : requestTimeout;
+    let response;
+    try {
+      response = await fetch(CODEX_SEARCH_URL, {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          Authorization: `Bearer ${credential.accessToken}`,
+          "chatgpt-account-id": credential.accountId,
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          originator: "deepseek-harness"
+        },
+        body: JSON.stringify(body),
+        signal: requestSignal
+      });
+    } catch (error) {
+      throwIfAborted$1(signal);
+      if (requestTimeout.aborted) {
+        throw new Error(`OpenAI Codex search timed out after ${this.timeoutMs}ms`, { cause: error });
+      }
+      throw new Error("OpenAI Codex search request failed", { cause: error });
+    }
+    let payload;
+    try {
+      payload = await readBoundedJson(
+        response,
+        response.ok ? MAX_SUCCESS_RESPONSE_BYTES : MAX_ERROR_RESPONSE_BYTES,
+        requestSignal
+      );
+    } catch (error) {
+      throwIfAborted$1(signal);
+      if (requestTimeout.aborted) {
+        throw new Error(`OpenAI Codex search timed out after ${this.timeoutMs}ms`, { cause: error });
+      }
+      if (error instanceof ResponseTooLargeError) throw error;
+      throw new Error(`OpenAI Codex returned invalid JSON (HTTP ${response.status})`, { cause: error });
+    }
+    if (!response.ok) {
+      const detail = providerMessage(payload);
+      const suffix = detail ? `: ${detail}` : "";
+      if (response.status === 401 || response.status === 403) {
+        throw new ProviderAuthenticationError(
+          `OpenAI Codex credential is invalid or expired (HTTP ${response.status})${suffix}`
+        );
+      }
+      throw new Error(`OpenAI Codex search failed (HTTP ${response.status})${suffix}`);
+    }
+    return mapCodexSearchResponse(payload);
+  }
+}
+function configuredCredentialFile() {
+  const filename = readNonEmptyString(process.env.CODEX_CREDENTIAL_FILE);
+  return filename === void 0 ? void 0 : resolve(filename);
+}
+function loadStaticCredential(filename) {
+  try {
+    const stats = statSync(filename);
+    if (!stats.isFile() || stats.size <= 0 || stats.size > MAX_CREDENTIAL_BYTES) return void 0;
+    const value = JSON.parse(readFileSync(filename, "utf8"));
+    return parseStaticCredential(value);
+  } catch {
+    return void 0;
+  }
+}
+function mapCodexSearchResponse(value) {
+  if (!isRecord(value) || typeof value.output !== "string") {
+    throw new Error("OpenAI Codex returned a search response without string output");
+  }
+  if (value.results !== void 0 && !Array.isArray(value.results)) {
+    throw new Error("OpenAI Codex returned a search response with non-array results");
+  }
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value.results ?? []) {
+    if (!isRecord(item) || item.type !== "text_result") continue;
+    const url = citeableUrl(item.url);
+    if (!url || seen.has(url)) continue;
+    seen.add(url);
+    items.push({
+      title: readNonEmptyString(item.title) ?? url,
+      url,
+      snippet: readNonEmptyString(item.snippet) ?? ""
+    });
+  }
+  const summary = value.output;
+  return {
+    status: summary.length > 0 ? "ok" : "degraded",
+    source: "OpenAI Codex",
+    summary: summary || `Codex returned ${items.length} source(s) without summary text`,
+    items,
+    uncertainty: summary.length > 0 ? [] : ["Codex returned no summary text"]
+  };
+}
+function parseStaticCredential(value) {
+  if (!isRecord(value)) return void 0;
+  const candidates = [
+    value,
+    isRecord(value.credential) ? value.credential : void 0,
+    isRecord(value.tokens) ? value.tokens : void 0
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const accessToken = readNonEmptyString(candidate.access_token) ?? readNonEmptyString(candidate.access);
+    if (!accessToken) continue;
+    const accountId = readNonEmptyString(candidate.account_id) ?? readNonEmptyString(candidate.accountId) ?? accountIdFromToken(accessToken);
+    if (!accountId) continue;
+    return { accessToken, accountId };
+  }
+  return void 0;
+}
+function decodeJwtPayload(accessToken) {
+  try {
+    const parts = accessToken.split(".");
+    if (parts.length !== 3 || !parts[1]) return void 0;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    return isRecord(payload) ? payload : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function accountIdFromToken(accessToken) {
+  const auth = decodeJwtPayload(accessToken)?.["https://api.openai.com/auth"];
+  return isRecord(auth) ? readNonEmptyString(auth.chatgpt_account_id) : void 0;
+}
+class ResponseTooLargeError extends Error {
+  constructor(limit) {
+    super(`OpenAI Codex search response exceeded ${limit} bytes`);
+    this.name = "ResponseTooLargeError";
+  }
+}
+async function readBoundedJson(response, maxBytes, signal) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+    await response.body?.cancel().catch(() => {
+    });
+    throw new ResponseTooLargeError(maxBytes);
+  }
+  if (!response.body) throw new SyntaxError("empty response body");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await abortable(reader.read(), signal);
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > maxBytes) throw new ResponseTooLargeError(maxBytes);
+      chunks.push(value);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {
+    });
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  return JSON.parse(Buffer.concat(chunks, total).toString("utf8"));
+}
+function abortable(operation, signal) {
+  if (signal.aborted) return Promise.reject(abortedError(signal));
+  return new Promise((resolve2, reject) => {
+    const onAbort = () => reject(abortedError(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve2(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function throwIfAborted$1(signal) {
+  if (signal?.aborted) throw abortedError(signal);
+}
+function abortedError(signal) {
+  return new Error("OpenAI Codex search aborted", { cause: signal.reason });
+}
+function providerMessage(value) {
+  if (!isRecord(value)) return void 0;
+  const raw = typeof value.error === "string" ? value.error : isRecord(value.error) && typeof value.error.message === "string" ? value.error.message : typeof value.message === "string" ? value.message : void 0;
+  return raw?.replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[REDACTED]").slice(0, 1e3);
+}
+function citeableUrl(value) {
+  if (typeof value !== "string") return void 0;
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+class DemoProvider {
+  id = "demo";
+  name = "Demo Provider";
+  description = "Returns canned results for integration testing without calling any external API.";
+  searchable = true;
+  fetchable = true;
+  constructor(_config) {
+  }
+  available() {
+    return true;
+  }
+  async search(request) {
+    return {
+      status: "ok",
+      source: this.name,
+      summary: `Demo search results for "${request.query}"`,
+      items: [
+        {
+          title: "Demo Result 1",
+          url: "https://example.com/demo1",
+          snippet: "This is a demo search result used to verify the DSH plugin wiring."
+        },
+        {
+          title: "Demo Result 2",
+          url: "https://example.com/demo2",
+          snippet: "Another canned result so citation cards have something to render."
+        }
+      ],
+      uncertainty: ["Demo mode: results are not from a real search engine."]
+    };
+  }
+  async fetch(request) {
+    return {
+      summary: `Demo fetch of ${request.url}`,
+      content: `# Demo Page
+
+This is canned content for the URL "${request.url}".`,
+      links: [
+        { text: "Example", url: "https://example.com" }
+      ],
+      uncertainty: ["Demo mode: content is not from a real web page."],
+      warnings: []
+    };
+  }
+}
+const fetchSchema = {
+  type: "object",
+  properties: {
+    summary: { type: "string" },
+    content: { type: "string" },
+    links: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          text: { type: "string" },
+          url: { type: "string" }
+        },
+        required: ["text", "url"]
+      }
+    },
+    uncertainty: {
+      type: "array",
+      items: { type: "string" }
+    },
+    warnings: {
+      type: "array",
+      items: { type: "string" }
+    }
+  },
+  required: ["summary", "content", "uncertainty"]
+};
+const FALLBACK_ATTEMPT_TIMEOUT_MS = 2e4;
+function resolveCandidateIds(registry, fallbackChain) {
+  let activeId;
+  try {
+    activeId = registry.getActive().id;
+  } catch {
+  }
+  const configured = fallbackChain === void 0 ? registry.list() : fallbackChain;
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const id of activeId ? [activeId, ...configured] : configured) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    candidates.push(id);
+  }
+  return candidates;
+}
+function createAttemptContext(parent, timeoutMs) {
+  const controller = new AbortController();
+  let didTimeOut = false;
+  let timer;
+  let onParentAbort;
+  if (parent?.aborted) {
+    controller.abort(parent.reason);
+  } else {
+    if (parent) {
+      onParentAbort = () => controller.abort(parent.reason);
+      parent.addEventListener("abort", onParentAbort, { once: true });
+    }
+    timer = setTimeout(() => {
+      didTimeOut = true;
+      controller.abort(new Error(`fallback attempt timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  }
+  return {
+    signal: controller.signal,
+    timedOut: () => didTimeOut,
+    dispose() {
+      if (timer !== void 0) clearTimeout(timer);
+      if (parent && onParentAbort) parent.removeEventListener("abort", onParentAbort);
+    }
+  };
+}
+function raceWithSignal(operation, signal) {
+  if (!signal) return operation;
+  if (signal.aborted) {
+    operation.catch(() => {
+    });
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve2, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve2(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw signal.reason;
+}
+const READ_PAGE_TIMEOUT_MS = 18e4;
+const RENDER_CONTENT_CAP = 2e4;
+const RENDER_LINK_CAP = 20;
+function registerReadPageTool(ctx, registry, cooldown, fallbackChain) {
+  if (typeof ctx.tools?.register !== "function") {
+    console.error("[search-providers] ctx.tools.register is not available; read_page tool skipped");
+    return;
+  }
+  ctx.tools.register({
+    name: "read_page",
+    description: 'Read one web page through the configured search provider. Use when a message references a specific http(s) URL whose content matters: docs, an article, a changelog, a thread. Returns structured evidence with a summary, the extracted content, outgoing links, uncertainty, and operational warnings. Pass "query" to focus the reading on one question.',
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The http(s) URL to read"
+        },
+        query: {
+          type: "string",
+          description: 'Optional question to focus the reading on (e.g. "what are the rate limits")'
+        }
+      },
+      required: ["url"]
+    },
+    output: {
+      schema: fetchSchema,
+      render: (_args, value) => [
+        { type: "text", text: renderFetchEvidence(value) }
+      ]
+    },
+    timeoutMs: READ_PAGE_TIMEOUT_MS + 2e4,
+    isConcurrencySafe: () => true,
+    presentCall: (args) => ({
+      card: "generic",
+      title: "read_page",
+      kind: "fetch",
+      rawInput: args
+    }),
+    async execute(args, exec) {
+      if (typeof args?.url !== "string" || !/^https?:\/\//i.test(args.url.trim())) {
+        throw new Error('read_page needs an http(s) "url".');
+      }
+      const request = {
+        url: args.url.trim(),
+        query: args.query,
+        format: "markdown"
+      };
+      return fetchWithFallback(registry, cooldown, fallbackChain, request, exec.signal);
+    }
+  });
+}
+function resolveFetchCandidateIds(registry, fallbackChain) {
+  return resolveCandidateIds(registry, fallbackChain).filter((id) => {
+    const provider = registry.get(id);
+    return provider !== void 0 && provider.fetchable !== false && typeof provider.fetch === "function";
+  });
+}
+async function fetchWithFallback(registry, cooldown, fallbackChain, request, signal) {
+  throwIfAborted(signal);
+  const candidates = resolveFetchCandidateIds(registry, fallbackChain);
+  const attempted = [];
+  const attemptedIds = /* @__PURE__ */ new Set();
+  let lastError;
+  while (true) {
+    throwIfAborted(signal);
+    const { ready } = cooldown.filter(candidates, "fetch");
+    const id = ready.find((candidateId) => {
+      if (attemptedIds.has(candidateId)) return false;
+      const provider2 = registry.get(candidateId);
+      return provider2?.available() && provider2.fetchable !== false && typeof provider2.fetch === "function";
+    });
+    if (id === void 0) break;
+    const provider = registry.get(id);
+    attemptedIds.add(id);
+    const attempt = attempted.length === 0 ? void 0 : createAttemptContext(signal, FALLBACK_ATTEMPT_TIMEOUT_MS);
+    try {
+      const attemptSignal = attempt?.signal ?? signal;
+      const result = await raceWithSignal(provider.fetch(request, attemptSignal), attemptSignal);
+      throwIfAborted(signal);
+      if (attempt?.timedOut()) throw attempt.signal.reason;
+      const { cooling: cooling2, disabled: disabled2 } = cooldown.filter(candidates, "fetch");
+      if (attempted.length > 0) {
+        result.warnings = result.warnings ?? [];
+        result.warnings.push(`Fallback used after ${attempted.join(", ")} failed`);
+      }
+      if (cooling2.length > 0) {
+        result.warnings = result.warnings ?? [];
+        result.warnings.push(`Cooling providers skipped: ${cooling2.join(", ")}`);
+      }
+      if (disabled2.length > 0) {
+        result.warnings = result.warnings ?? [];
+        result.warnings.push(`Providers disabled until restart: ${disabled2.join(", ")}`);
+      }
+      return result;
+    } catch (error) {
+      throwIfAborted(signal);
+      const caught = error instanceof Error ? error : new Error(String(error));
+      lastError = caught instanceof ProviderAuthenticationError ? caught : attempt?.timedOut() ? new Error(`fallback attempt timed out after ${FALLBACK_ATTEMPT_TIMEOUT_MS}ms`, { cause: caught }) : caught;
+      attempted.push(id);
+      console.warn(`[search-providers] provider '${id}' fetch failed, trying next: ${lastError.message}`);
+      cooldown.record(id, "fetch", lastError);
+    } finally {
+      attempt?.dispose();
+    }
+  }
+  const { cooling, disabled } = cooldown.filter(candidates, "fetch");
+  const coolingIds = cooling.length > 0 ? ` [cooling: ${cooling.join(", ")}]` : "";
+  const disabledIds = disabled.length > 0 ? ` [disabled until restart: ${disabled.join(", ")}]` : "";
+  throw new Error(
+    `No fetch provider succeeded${attempted.length > 0 ? ` (tried: ${attempted.join(", ")})` : ""}${coolingIds}${disabledIds}. ${lastError?.message ?? "No provider available."}`,
+    { cause: lastError }
+  );
+}
+function renderFetchEvidence(value) {
+  const lines = [String(value.summary ?? "")];
+  const content = String(value.content ?? "").trim();
+  if (content) {
+    lines.push("", "Content:", content.length > RENDER_CONTENT_CAP ? `${content.slice(0, RENDER_CONTENT_CAP)}…` : content);
+  }
+  const links = Array.isArray(value.links) ? value.links.slice(0, RENDER_LINK_CAP) : [];
+  if (links.length > 0) {
+    lines.push("", "Links:");
+    for (const link of links) {
+      const text = typeof link === "object" && link !== null ? String(link.text ?? "") : "";
+      const url = typeof link === "object" && link !== null ? String(link.url ?? "") : "";
+      lines.push(`- ${text} — ${url}`);
+    }
+  }
+  const uncertainty = Array.isArray(value.uncertainty) ? value.uncertainty : [];
+  if (uncertainty.length > 0) {
+    lines.push("", `Uncertain: ${uncertainty.join("; ")}`);
+  }
+  const warnings = Array.isArray(value.warnings) ? value.warnings : [];
+  if (warnings.length > 0) {
+    lines.push("", `Warnings: ${warnings.join("; ")}`);
+  }
+  return lines.filter(Boolean).join("\n");
+}
+function registerWebSearchProvider(ctx, registry, cooldown, fallbackChain) {
+  if (typeof ctx.web?.registerSearchProvider !== "function") {
+    console.error("[search-providers] ctx.web.registerSearchProvider is not available; web_search provider skipped");
+    return;
+  }
+  ctx.web.registerSearchProvider({
+    id: "search-providers",
+    available: () => anyProviderAvailable(registry, cooldown, fallbackChain),
+    async search(request, signal) {
+      const searchRequest = {
+        query: request.query,
+        maxResults: request.maxResults,
+        recencyDays: request.recencyDays,
+        purpose: request.purpose,
+        location: request.location,
+        language: request.language
+      };
+      const { result, attempted, cooling, disabled } = await searchWithFallback(
+        registry,
+        cooldown,
+        fallbackChain,
+        searchRequest,
+        signal
+      );
+      return {
+        content: renderContent(result, attempted, cooling, disabled),
+        sources: result.items.map((item) => ({
+          url: item.url,
+          ...item.title ? { title: item.title } : {},
+          ...item.snippet ? { snippet: item.snippet } : {},
+          ...item.publishedAt ? { publishedAt: item.publishedAt } : {}
+        })),
+        truncated: false
+      };
+    }
+  });
+}
+function resolveSearchCandidateIds(registry, fallbackChain) {
+  return resolveCandidateIds(registry, fallbackChain).filter((id) => {
+    const provider = registry.get(id);
+    return provider !== void 0 && provider.searchable !== false;
+  });
+}
+function anyProviderAvailable(registry, cooldown, fallbackChain) {
+  const candidates = resolveSearchCandidateIds(registry, fallbackChain);
+  const { ready } = cooldown.filter(candidates, "search");
+  return ready.some((id) => {
+    const provider = registry.get(id);
+    return provider?.available() && provider.searchable !== false;
+  });
+}
+async function searchWithFallback(registry, cooldown, fallbackChain, request, signal) {
+  throwIfAborted(signal);
+  const candidates = resolveSearchCandidateIds(registry, fallbackChain);
+  const attempted = [];
+  const attemptedIds = /* @__PURE__ */ new Set();
+  let lastError;
+  while (true) {
+    throwIfAborted(signal);
+    const { ready } = cooldown.filter(candidates, "search");
+    const id = ready.find((candidateId) => {
+      if (attemptedIds.has(candidateId)) return false;
+      const provider2 = registry.get(candidateId);
+      return provider2?.available() && provider2.searchable !== false;
+    });
+    if (id === void 0) break;
+    const provider = registry.get(id);
+    attemptedIds.add(id);
+    const attempt = attempted.length === 0 ? void 0 : createAttemptContext(signal, FALLBACK_ATTEMPT_TIMEOUT_MS);
+    try {
+      const attemptSignal = attempt?.signal ?? signal;
+      const result = await raceWithSignal(provider.search(request, attemptSignal), attemptSignal);
+      throwIfAborted(signal);
+      if (attempt?.timedOut()) throw attempt.signal.reason;
+      const { cooling: cooling2, disabled: disabled2 } = cooldown.filter(candidates, "search");
+      return { result, attempted, cooling: cooling2, disabled: disabled2 };
+    } catch (error) {
+      throwIfAborted(signal);
+      const caught = error instanceof Error ? error : new Error(String(error));
+      lastError = caught instanceof ProviderAuthenticationError ? caught : attempt?.timedOut() ? new Error(`fallback attempt timed out after ${FALLBACK_ATTEMPT_TIMEOUT_MS}ms`, { cause: caught }) : caught;
+      attempted.push(id);
+      console.warn(`[search-providers] provider '${id}' search failed, trying next: ${lastError.message}`);
+      cooldown.record(id, "search", lastError);
+    } finally {
+      attempt?.dispose();
+    }
+  }
+  const { cooling, disabled } = cooldown.filter(candidates, "search");
+  const coolingIds = cooling.length > 0 ? ` [cooling: ${cooling.join(", ")}]` : "";
+  const disabledIds = disabled.length > 0 ? ` [disabled until restart: ${disabled.join(", ")}]` : "";
+  throw new Error(
+    `No search provider succeeded${attempted.length > 0 ? ` (tried: ${attempted.join(", ")})` : ""}${coolingIds}${disabledIds}. ${lastError?.message ?? "No provider available."}`,
+    { cause: lastError }
+  );
+}
+function renderContent(result, attempted, cooling, disabled) {
+  const lines = [`[Search provider: ${result.source}]`, result.summary];
+  if (attempted.length > 0) {
+    lines.push(`[Fallback used after ${attempted.join(", ")} failed]`);
+  }
+  if (cooling.length > 0) {
+    lines.push(`[Cooling: ${cooling.join(", ")}]`);
+  }
+  if (disabled.length > 0) {
+    lines.push(`[Disabled until restart: ${disabled.join(", ")}]`);
+  }
+  if (result.uncertainty.length > 0) {
+    lines.push(`Uncertain: ${result.uncertainty.join("; ")}`);
+  }
+  return lines.filter(Boolean).join("\n");
+}
+const name = "search-providers";
+const inject = ["tools", "web"];
+const DEFAULT_PROVIDER_ORDER = ["codex", "tinyfish", "tavily", "exa", "firecrawl"];
+function apply(ctx, rawConfig = {}) {
+  const registry = new ProviderRegistry();
+  const cooldown = new CooldownController();
+  const demoMode = rawConfig.provider === "demo" || process.env.SEARCH_PROVIDERS_DEMO === "1";
+  registry.register(new CodexProvider(resolveProviderConfig(rawConfig, "codex", "CODEX")));
+  registry.register(new TinyfishProvider(resolveProviderConfig(rawConfig, "tinyfish", "TINYFISH")));
+  registry.register(new TavilyProvider(resolveProviderConfig(rawConfig, "tavily", "TAVILY")));
+  registry.register(new ExaProvider(resolveProviderConfig(rawConfig, "exa", "EXA")));
+  registry.register(new FirecrawlProvider(resolveProviderConfig(rawConfig, "firecrawl", "FIRECRAWL")));
+  if (demoMode) {
+    registry.register(new DemoProvider(resolveProviderConfig(rawConfig, "tinyfish", "TINYFISH")));
+  }
+  const activeProvider = rawConfig.provider ?? (demoMode ? "demo" : void 0);
+  if (activeProvider) {
+    try {
+      registry.setActive(activeProvider);
+    } catch (error) {
+      console.warn(`[search-providers] configured provider '${activeProvider}' is not registered; falling back to '${registry.list()[0]}'`);
+    }
+  }
+  const fallbackChain = rawConfig.fallbackChain ?? DEFAULT_PROVIDER_ORDER;
+  registerWebSearchProvider(ctx, registry, cooldown, fallbackChain);
+  registerReadPageTool(ctx, registry, cooldown, fallbackChain);
+  console.log(`[search-providers] loaded with active provider: ${registry.getActive().id}, fallback after active: [${fallbackChain.join(", ")}]`);
+}
+export {
+  apply,
+  inject,
+  name
+};
+//# sourceMappingURL=index.js.map