@qzhike/agent-search 1.0.1

package/dist/adapters/ragflow.js

@@ -0,0 +1,170 @@
+import { configString } from "../http.js";
+import { formatResultsAsContent } from "../result.js";
+import { buildRagflowRequestHeaders, parseRagflowDatasetIds, resolveRagflowAuthMode, resolveRagflowBaseUrl, resolveRagflowRetrievalUrl, resolveRagflowTimeoutSeconds, } from "./ragflow-config.js";
+const TRANSIENT_HTTP = new Set([429, 500, 502, 503, 504]);
+const MAX_ATTEMPTS = 3;
+export async function searchRagflow(config, query, count, signal) {
+    const provider = "ragflow";
+    const cfg = config.providers?.ragflow;
+    const auth = resolveRagflowAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.ragflow.auth. Use "direct" (RAGFlow API) or "deeproute" (Console mirror).',
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (!apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: auth === "deeproute"
+                ? "deeproute: set providers.ragflow.apiKey to your New API user sk (Bearer)."
+                : "direct: set providers.ragflow.apiKey to your RAGFlow API key.",
+        };
+    }
+    const baseUrl = resolveRagflowBaseUrl(cfg, auth);
+    if (!baseUrl) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: auth === "deeproute"
+                ? "deeproute: set providers.ragflow.baseUrl to Console origin."
+                : "direct: set providers.ragflow.baseUrl to RAGFlow service root URL.",
+        };
+    }
+    const datasetIds = auth === "direct" ? parseRagflowDatasetIds(cfg?.datasetIds) : [];
+    if (auth === "direct" && datasetIds.length === 0) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_dataset_ids",
+            message: "direct: set providers.ragflow.datasetIds to comma-separated RAGFlow dataset IDs.",
+        };
+    }
+    const body = {
+        question: query,
+        page: 1,
+        page_size: cfg?.pageSize ?? 30,
+        similarity_threshold: cfg?.similarityThreshold ?? 0.2,
+    };
+    if (auth === "direct") {
+        body.dataset_ids = datasetIds;
+    }
+    if (typeof cfg?.topK === "number" && Number.isFinite(cfg.topK)) {
+        body.top_k = Math.floor(cfg.topK);
+    }
+    const url = resolveRagflowRetrievalUrl(baseUrl, auth);
+    const timeoutSeconds = resolveRagflowTimeoutSeconds(cfg);
+    const startedAt = Date.now();
+    try {
+        const data = await fetchRagflowWithRetry(url, {
+            method: "POST",
+            headers: buildRagflowRequestHeaders(auth, apiKey),
+            body: JSON.stringify(body),
+            timeoutSeconds,
+            signal,
+        });
+        const bizCode = data.code;
+        if (bizCode !== 0) {
+            const msg = typeof data.message === "string"
+                ? data.message
+                : `RAGFlow code ${String(bizCode)}`;
+            return {
+                ok: false,
+                provider,
+                error: "ragflow_business_error",
+                message: msg,
+            };
+        }
+        const chunks = Array.isArray(data.data?.chunks) ? data.data.chunks : [];
+        const results = chunks.slice(0, count).map((chunk, index) => ({
+            title: chunk.document_keyword?.trim() || `Chunk ${index + 1}`,
+            url: "",
+            snippet: chunk.content?.trim() ?? "",
+            siteName: chunk.document_id?.trim() || undefined,
+        }));
+        const content = formatResultsAsContent(results);
+        return {
+            ok: true,
+            provider,
+            query,
+            tookMs: Date.now() - startedAt,
+            results,
+            citations: [],
+            content,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            provider,
+            error: "ragflow_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function fetchRagflowWithRetry(url, options) {
+    let lastErr = "unknown error";
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), options.timeoutSeconds * 1000);
+        const signals = [controller.signal];
+        if (options.signal) {
+            signals.push(options.signal);
+        }
+        try {
+            const response = await fetch(url, {
+                method: options.method,
+                headers: options.headers,
+                body: options.body,
+                signal: signals.length > 1 ? AbortSignal.any(signals) : controller.signal,
+            });
+            const text = await response.text();
+            let data;
+            try {
+                data = text ? JSON.parse(text) : {};
+            }
+            catch {
+                lastErr = `Invalid JSON (${response.status})`;
+                if (TRANSIENT_HTTP.has(response.status) && attempt + 1 < MAX_ATTEMPTS) {
+                    await sleep(2 ** attempt * 1000);
+                    continue;
+                }
+                throw new Error(lastErr);
+            }
+            if (!response.ok) {
+                lastErr =
+                    typeof data.message === "string"
+                        ? data.message
+                        : `HTTP ${response.status}: ${text.slice(0, 500)}`;
+                if (TRANSIENT_HTTP.has(response.status) && attempt + 1 < MAX_ATTEMPTS) {
+                    await sleep(2 ** attempt * 1000);
+                    continue;
+                }
+                throw new Error(lastErr);
+            }
+            return data;
+        }
+        catch (err) {
+            lastErr = err instanceof Error ? err.message : String(err);
+            if (attempt + 1 < MAX_ATTEMPTS && !options.signal?.aborted) {
+                await sleep(2 ** attempt * 1000);
+                continue;
+            }
+            throw new Error(lastErr);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    throw new Error(lastErr);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=ragflow.js.map

package/dist/adapters/searxng-config.js

@@ -0,0 +1,40 @@
+import { configString, trimTrailingSlashes } from "../http.js";
+import { joinMirrorPath, resolveDeeprouteMirrorRoot, } from "./deeproute-mirror.js";
+import { buildDeeprouteBearerHeaders, resolveProviderAuthMode, } from "./provider-auth.js";
+export const SEARXNG_SEARCH_PATH = "/search";
+export function resolveSearxngAuthMode(auth) {
+    return resolveProviderAuthMode(auth);
+}
+export function resolveSearxngBaseUrl(cfg, auth) {
+    const configured = configString(cfg?.baseUrl);
+    if (!configured) {
+        return undefined;
+    }
+    if (auth === "deeproute") {
+        return resolveDeeprouteMirrorRoot(configured, "searxng");
+    }
+    return trimTrailingSlashes(configured);
+}
+export function buildSearxngSearchUrl(baseUrl, query, categories, language) {
+    const path = baseUrl.endsWith(SEARXNG_SEARCH_PATH)
+        ? baseUrl
+        : joinMirrorPath(baseUrl, SEARXNG_SEARCH_PATH);
+    const url = new URL(path);
+    url.searchParams.set("q", query);
+    url.searchParams.set("format", "json");
+    if (categories?.trim()) {
+        url.searchParams.set("categories", categories.trim());
+    }
+    if (language?.trim()) {
+        url.searchParams.set("language", language.trim());
+    }
+    return url.toString();
+}
+export function buildSearxngRequestHeaders(auth, apiKey) {
+    const headers = { Accept: "application/json" };
+    if (auth === "deeproute" && apiKey) {
+        Object.assign(headers, buildDeeprouteBearerHeaders(apiKey));
+    }
+    return headers;
+}
+//# sourceMappingURL=searxng-config.js.map

package/dist/adapters/searxng.js

@@ -0,0 +1,86 @@
+import { configString, fetchJson } from "../http.js";
+import { formatResultsAsContent, resolveTimeoutSeconds } from "../result.js";
+import { buildSearxngRequestHeaders, buildSearxngSearchUrl, resolveSearxngAuthMode, resolveSearxngBaseUrl, } from "./searxng-config.js";
+export async function searchSearxng(config, query, count, signal) {
+    const provider = "searxng";
+    const cfg = config.providers?.searxng;
+    const auth = resolveSearxngAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.searxng.auth. Use "direct" (SearXNG instance) or "deeproute" (Console mirror).',
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (auth === "deeproute" && !apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: "deeproute: set providers.searxng.apiKey to your New API user sk (Bearer).",
+        };
+    }
+    const baseUrl = resolveSearxngBaseUrl(cfg, auth);
+    if (!baseUrl) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: auth === "deeproute"
+                ? "deeproute: set providers.searxng.baseUrl (e.g. http://host:20316/api/mirror/searxng)."
+                : "direct: set providers.searxng.baseUrl to your SearXNG instance root.",
+        };
+    }
+    const url = buildSearxngSearchUrl(baseUrl, query, cfg?.categories, cfg?.language);
+    const startedAt = Date.now();
+    try {
+        const { data } = await fetchJson(url, {
+            method: "GET",
+            headers: buildSearxngRequestHeaders(auth, apiKey),
+            timeoutSeconds: resolveTimeoutSeconds(config),
+            signal,
+        });
+        const raw = Array.isArray(data.results) ? data.results : [];
+        const results = raw
+            .filter((entry) => entry.url && entry.title)
+            .slice(0, count)
+            .map((entry) => ({
+            title: entry.title ?? "",
+            url: entry.url ?? "",
+            snippet: entry.content ?? "",
+            siteName: safeHostname(entry.url),
+        }));
+        const citations = [...new Set(results.map((r) => r.url).filter(Boolean))];
+        return {
+            ok: true,
+            provider,
+            query,
+            tookMs: Date.now() - startedAt,
+            results,
+            citations,
+            content: formatResultsAsContent(results),
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            provider,
+            error: "searxng_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function safeHostname(url) {
+    if (!url) {
+        return undefined;
+    }
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=searxng.js.map

package/dist/adapters/serper-config.js

@@ -0,0 +1,35 @@
+import { configString, trimTrailingSlashes } from "../http.js";
+import { joinMirrorPath, resolveDeeprouteMirrorRoot, } from "./deeproute-mirror.js";
+import { buildDeeprouteBearerHeaders, resolveProviderAuthMode, } from "./provider-auth.js";
+export const DEFAULT_SERPER_DIRECT_BASE = "https://google.serper.dev";
+export const SERPER_SEARCH_PATH = "/search";
+export function resolveSerperAuthMode(auth) {
+    return resolveProviderAuthMode(auth);
+}
+export function resolveSerperSearchUrl(cfg, auth) {
+    const configured = configString(cfg?.baseUrl);
+    if (auth === "deeproute") {
+        if (!configured)
+            return undefined;
+        const root = resolveDeeprouteMirrorRoot(configured, "serper");
+        return joinMirrorPath(root, SERPER_SEARCH_PATH);
+    }
+    const base = configured
+        ? trimTrailingSlashes(configured)
+        : DEFAULT_SERPER_DIRECT_BASE;
+    return joinMirrorPath(base, SERPER_SEARCH_PATH);
+}
+export function buildSerperRequestHeaders(auth, apiKey) {
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+    };
+    if (auth === "deeproute") {
+        Object.assign(headers, buildDeeprouteBearerHeaders(apiKey));
+    }
+    else {
+        headers["X-API-KEY"] = apiKey;
+    }
+    return headers;
+}
+//# sourceMappingURL=serper-config.js.map

package/dist/adapters/serper.js

@@ -0,0 +1,80 @@
+import { configString, fetchJson } from "../http.js";
+import { formatResultsAsContent, resolveTimeoutSeconds } from "../result.js";
+import { buildSerperRequestHeaders, resolveSerperAuthMode, resolveSerperSearchUrl, } from "./serper-config.js";
+export async function searchSerper(config, query, count, signal) {
+    const provider = "serper";
+    const cfg = config.providers?.serper;
+    const auth = resolveSerperAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.serper.auth. Use "direct" (Serper API) or "deeproute" (Console mirror).',
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (!apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: auth === "deeproute"
+                ? "deeproute: set providers.serper.apiKey to your DeepRoute user sk (Bearer)."
+                : "direct: set providers.serper.apiKey to your Serper API key.",
+        };
+    }
+    const url = resolveSerperSearchUrl(cfg, auth);
+    if (!url) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: "deeproute: set providers.serper.baseUrl to Console origin (e.g. http://host:20316).",
+        };
+    }
+    const startedAt = Date.now();
+    try {
+        const { data } = await fetchJson(url, {
+            method: "POST",
+            headers: buildSerperRequestHeaders(auth, apiKey),
+            body: { q: query, num: count, page: 1 },
+            timeoutSeconds: resolveTimeoutSeconds(config),
+            signal,
+        });
+        const raw = Array.isArray(data.organic) ? data.organic : [];
+        const results = raw.slice(0, count).map((entry) => ({
+            title: entry.title ?? "",
+            url: entry.link ?? "",
+            snippet: entry.snippet ?? "",
+            siteName: entry.link ? safeHostname(entry.link) : undefined,
+        }));
+        const citations = [...new Set(results.map((r) => r.url).filter(Boolean))];
+        return {
+            ok: true,
+            provider,
+            query,
+            tookMs: Date.now() - startedAt,
+            results,
+            citations,
+            content: formatResultsAsContent(results),
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            provider,
+            error: "serper_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function safeHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=serper.js.map

package/dist/adapters/tavily-config.js

@@ -0,0 +1,46 @@
+import { configString, trimTrailingSlashes } from "../http.js";
+import { joinMirrorPath, resolveDeeprouteMirrorRoot, } from "./deeproute-mirror.js";
+import { buildDeeprouteBearerHeaders, resolveProviderAuthMode, } from "./provider-auth.js";
+export const DEFAULT_TAVILY_DIRECT_BASE = "https://api.tavily.com";
+export const TAVILY_SEARCH_PATH = "/search";
+export function resolveTavilyAuthMode(auth) {
+    return resolveProviderAuthMode(auth);
+}
+export function resolveTavilyBaseUrl(cfg, auth) {
+    const configured = configString(cfg?.baseUrl);
+    if (configured) {
+        if (auth === "deeproute") {
+            return resolveDeeprouteMirrorRoot(configured, "tavily");
+        }
+        return trimTrailingSlashes(configured);
+    }
+    if (auth === "direct") {
+        return DEFAULT_TAVILY_DIRECT_BASE;
+    }
+    return undefined;
+}
+export function resolveTavilySearchUrl(baseUrl, auth) {
+    if (auth === "deeproute") {
+        return joinMirrorPath(baseUrl, TAVILY_SEARCH_PATH);
+    }
+    const trimmed = trimTrailingSlashes(baseUrl || DEFAULT_TAVILY_DIRECT_BASE);
+    try {
+        const url = new URL(trimmed);
+        url.pathname = `${url.pathname.replace(/\/$/, "")}${TAVILY_SEARCH_PATH}`;
+        return url.toString();
+    }
+    catch {
+        return `${DEFAULT_TAVILY_DIRECT_BASE}${TAVILY_SEARCH_PATH}`;
+    }
+}
+export function buildTavilyRequestHeaders(auth, apiKey) {
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+    };
+    if (auth === "deeproute") {
+        Object.assign(headers, buildDeeprouteBearerHeaders(apiKey));
+    }
+    return headers;
+}
+//# sourceMappingURL=tavily-config.js.map

package/dist/adapters/tavily.js

@@ -0,0 +1,98 @@
+import { configString, fetchJson } from "../http.js";
+import { formatResultsAsContent, resolveTimeoutSeconds } from "../result.js";
+import { buildTavilyRequestHeaders, resolveTavilyAuthMode, resolveTavilyBaseUrl, resolveTavilySearchUrl, } from "./tavily-config.js";
+export async function searchTavily(config, query, count, signal, runOptions) {
+    const provider = "tavily";
+    const cfg = config.providers?.tavily;
+    const auth = resolveTavilyAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.tavily.auth. Use "direct" (Tavily API) or "deeproute" (Console mirror).',
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (!apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: auth === "deeproute"
+                ? "deeproute: set providers.tavily.apiKey to your New API user sk (Bearer)."
+                : "direct: set providers.tavily.apiKey to your Tavily API key.",
+        };
+    }
+    const baseUrl = resolveTavilyBaseUrl(cfg, auth);
+    if (!baseUrl) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: "deeproute: set providers.tavily.baseUrl (e.g. http://host:20316/api/mirror/tavily).",
+        };
+    }
+    const body = {
+        query,
+        max_results: count,
+    };
+    if (auth === "direct") {
+        body.api_key = apiKey;
+    }
+    const searchDepth = runOptions?.tavily?.searchDepth ?? cfg?.searchDepth;
+    if (searchDepth) {
+        body.search_depth = searchDepth;
+    }
+    const includeAnswer = runOptions?.tavily?.includeAnswer ?? cfg?.includeAnswer;
+    if (includeAnswer) {
+        body.include_answer = true;
+    }
+    const url = resolveTavilySearchUrl(baseUrl, auth);
+    const startedAt = Date.now();
+    try {
+        const { data } = await fetchJson(url, {
+            method: "POST",
+            headers: buildTavilyRequestHeaders(auth, apiKey),
+            body,
+            timeoutSeconds: resolveTimeoutSeconds(config),
+            signal,
+        });
+        const raw = Array.isArray(data.results) ? data.results : [];
+        const results = raw.slice(0, count).map((entry) => ({
+            title: entry.title ?? "",
+            url: entry.url ?? "",
+            snippet: entry.content ?? "",
+            siteName: entry.url ? safeHostname(entry.url) : undefined,
+        }));
+        const citations = [...new Set(results.map((r) => r.url).filter(Boolean))];
+        const answer = typeof data.answer === "string" ? data.answer : undefined;
+        return {
+            ok: true,
+            provider,
+            query,
+            tookMs: Date.now() - startedAt,
+            results,
+            citations,
+            answer,
+            content: formatResultsAsContent(results, answer),
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            provider,
+            error: "tavily_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function safeHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=tavily.js.map

package/dist/adapters/zai-config.js

@@ -0,0 +1,39 @@
+import { configString, trimTrailingSlashes } from "../http.js";
+import { joinMirrorPath, resolveDeeprouteMirrorRoot, } from "./deeproute-mirror.js";
+import { buildDeeprouteBearerHeaders, resolveProviderAuthMode, } from "./provider-auth.js";
+export const DEFAULT_ZAI_DIRECT_BASE = "https://open.bigmodel.cn";
+export const ZAI_SEARCH_PATH = "/api/paas/v4/web_search";
+export function resolveZaiAuthMode(auth) {
+    return resolveProviderAuthMode(auth);
+}
+export function resolveZaiSearchUrl(cfg, auth) {
+    const configured = configString(cfg?.baseUrl);
+    if (auth === "deeproute") {
+        if (!configured)
+            return undefined;
+        const root = resolveDeeprouteMirrorRoot(configured, "zai");
+        return joinMirrorPath(root, ZAI_SEARCH_PATH);
+    }
+    const base = configured
+        ? trimTrailingSlashes(configured)
+        : DEFAULT_ZAI_DIRECT_BASE;
+    return joinMirrorPath(base, ZAI_SEARCH_PATH);
+}
+export function buildZaiRequestHeaders(auth, apiKey) {
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+    };
+    if (auth === "deeproute") {
+        Object.assign(headers, buildDeeprouteBearerHeaders(apiKey));
+    }
+    else {
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    return headers;
+}
+export function resolveZaiSearchEngine(cfg) {
+    const engine = configString(cfg?.searchEngine);
+    return engine || "search_pro";
+}
+//# sourceMappingURL=zai-config.js.map

package/dist/adapters/zai.js

@@ -0,0 +1,91 @@
+import { configString, fetchJson } from "../http.js";
+import { formatResultsAsContent, resolveTimeoutSeconds } from "../result.js";
+import { buildZaiRequestHeaders, resolveZaiAuthMode, resolveZaiSearchEngine, resolveZaiSearchUrl, } from "./zai-config.js";
+export async function searchZai(config, query, count, signal) {
+    const provider = "zai";
+    const cfg = config.providers?.zai;
+    const auth = resolveZaiAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.zai.auth. Use "direct" or "deeproute".',
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (!apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: auth === "deeproute"
+                ? "deeproute: set providers.zai.apiKey to your DeepRoute user sk."
+                : "direct: set providers.zai.apiKey to your Zhipu API key.",
+        };
+    }
+    const url = resolveZaiSearchUrl(cfg, auth);
+    if (!url) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: "deeproute: set providers.zai.baseUrl to Console origin (e.g. http://host:20316).",
+        };
+    }
+    const searchEngine = resolveZaiSearchEngine(cfg);
+    const body = {
+        search_query: query,
+        search_engine: searchEngine,
+        search_intent: true,
+        content_size: "high",
+        search_recency_filter: "noLimit",
+    };
+    if (searchEngine !== "search_pro_quark") {
+        body.count = Math.min(Math.max(count, 1), 50);
+    }
+    const startedAt = Date.now();
+    try {
+        const { data } = await fetchJson(url, {
+            method: "POST",
+            headers: buildZaiRequestHeaders(auth, apiKey),
+            body,
+            timeoutSeconds: resolveTimeoutSeconds(config),
+            signal,
+        });
+        const raw = Array.isArray(data.search_result) ? data.search_result : [];
+        const results = raw.slice(0, count).map((entry) => ({
+            title: entry.title ?? "",
+            url: entry.link ?? "",
+            snippet: entry.content ?? "",
+            siteName: entry.link ? safeHostname(entry.link) : undefined,
+        }));
+        const citations = [...new Set(results.map((r) => r.url).filter(Boolean))];
+        return {
+            ok: true,
+            provider,
+            query,
+            tookMs: Date.now() - startedAt,
+            results,
+            citations,
+            content: formatResultsAsContent(results),
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            provider,
+            error: "zai_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function safeHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=zai.js.map