@qzhike/agent-search 1.0.1

package/dist/result.js

@@ -0,0 +1,326 @@
+import { resolveProviderAuthMode } from "./adapters/provider-auth.js";
+import { parseRagflowDatasetIds } from "./adapters/ragflow-config.js";
+import { EXTERNAL_CONTENT_SOURCE, pluginConfigPath, TOOL_SEARCH, } from "./plugin-meta.js";
+const DEFAULT_MAX_RESULTS = 5;
+const MAX_RESULTS = 10;
+export function clampCount(value, fallback = DEFAULT_MAX_RESULTS) {
+    const parsed = typeof value === "number" && Number.isFinite(value)
+        ? Math.floor(value)
+        : fallback;
+    return Math.max(1, Math.min(MAX_RESULTS, parsed));
+}
+export function resolveTimeoutSeconds(config) {
+    const value = config.timeoutSeconds;
+    return typeof value === "number" && value > 0 ? value : 30;
+}
+const DEFAULT_CONCURRENT_MAX = 3;
+const MAX_CONCURRENT_PROVIDERS = 10;
+export function resolveSearchMode(config, override) {
+    if (override === "fallback" || override === "concurrent") {
+        return override;
+    }
+    const mode = config.searchMode;
+    if (mode === "fallback" || mode === "concurrent") {
+        return mode;
+    }
+    return "fallback";
+}
+export function resolveConcurrentMaxProviders(config) {
+    const value = config.concurrentMaxProviders;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 1) {
+        return Math.min(MAX_CONCURRENT_PROVIDERS, Math.floor(value));
+    }
+    return DEFAULT_CONCURRENT_MAX;
+}
+export function resolveFallbackOrder(config) {
+    const requested = config.fallback ?? [];
+    const ordered = [];
+    for (const id of requested) {
+        if (isProviderConfigured(config, id) && !ordered.includes(id)) {
+            ordered.push(id);
+        }
+    }
+    return ordered;
+}
+export function resolveConcurrentList(config) {
+    const requested = config.concurrent ?? [];
+    const max = resolveConcurrentMaxProviders(config);
+    const ordered = [];
+    for (const id of requested) {
+        if (!ordered.includes(id)) {
+            ordered.push(id);
+        }
+        if (ordered.length >= max) {
+            break;
+        }
+    }
+    return ordered;
+}
+export function isSuccessWithResults(outcome) {
+    if (!outcome.ok) {
+        return false;
+    }
+    if (outcome.provider === "kimi") {
+        return outcome.content.trim().length > 0;
+    }
+    return outcome.results.length > 0 || Boolean(outcome.answer?.trim());
+}
+function isProviderExplicitlyDisabled(enabled) {
+    return enabled === false;
+}
+function isMirrorProviderConfigured(cfg, directRequiresApiKey = true) {
+    if (!cfg || isProviderExplicitlyDisabled(cfg.enabled)) {
+        return false;
+    }
+    const auth = resolveProviderAuthMode(cfg.auth) ?? "direct";
+    if (auth === "deeproute") {
+        return Boolean(cfg.baseUrl?.trim() && cfg.apiKey?.trim());
+    }
+    return directRequiresApiKey ? Boolean(cfg.apiKey?.trim()) : true;
+}
+/** Provider blocks omitted from config are disabled by default. */
+export function isProviderConfigured(config, id) {
+    const providers = config.providers;
+    if (!providers) {
+        return false;
+    }
+    switch (id) {
+        case "ragflow": {
+            const cfg = providers.ragflow;
+            if (!cfg || isProviderExplicitlyDisabled(cfg.enabled)) {
+                return false;
+            }
+            const auth = resolveProviderAuthMode(cfg.auth) ?? "direct";
+            if (auth === "deeproute") {
+                return Boolean(cfg.baseUrl?.trim() && cfg.apiKey?.trim());
+            }
+            return Boolean(cfg.baseUrl?.trim() &&
+                cfg.apiKey?.trim() &&
+                parseRagflowDatasetIds(cfg.datasetIds).length > 0);
+        }
+        case "serper":
+        case "metaso":
+        case "zai":
+        case "exa":
+        case "tavily":
+        case "minimax":
+            return isMirrorProviderConfigured(providers[id]);
+        case "searxng": {
+            const cfg = providers.searxng;
+            if (!cfg || isProviderExplicitlyDisabled(cfg.enabled)) {
+                return false;
+            }
+            const auth = resolveProviderAuthMode(cfg.auth) ?? "direct";
+            if (auth === "deeproute") {
+                return Boolean(cfg.baseUrl?.trim() && cfg.apiKey?.trim());
+            }
+            return Boolean(cfg.baseUrl?.trim());
+        }
+        case "jina":
+            return isMirrorProviderConfigured(providers.jina, true);
+        case "brave":
+            return isMirrorProviderConfigured(providers.brave);
+        case "kimi": {
+            const cfg = providers.kimi;
+            if (!cfg || isProviderExplicitlyDisabled(cfg.enabled)) {
+                return false;
+            }
+            return Boolean(cfg.baseUrl?.trim() && cfg.apiKey?.trim());
+        }
+        default: {
+            const _exhaustive = id;
+            return _exhaustive;
+        }
+    }
+}
+export function providerConfigurationHint(id) {
+    const path = pluginConfigPath(`providers.${id}`);
+    switch (id) {
+        case "jina":
+            return (`Provider "jina" is not configured for search. Set ${path} with auth and credentials. ` +
+                `Search (${TOOL_SEARCH}) needs apiKey (direct) or baseUrl+apiKey (deeproute) plus a valid Jina key in DeepRoute 扩展服务 for Search.`);
+        case "brave":
+            return (`Provider "brave" is not configured. Set ${path} with apiKey (direct Brave token) ` +
+                "or auth deeproute + baseUrl (Console origin) + apiKey (user sk).");
+        default:
+            return `Provider "${id}" is not configured. Set ${path} with the required fields (see README).`;
+    }
+}
+/** Jina Reader: direct works without apiKey; deeproute needs Console origin + user sk. */
+export function isJinaReaderConfigured(config) {
+    const cfg = config.providers?.jina;
+    if (!cfg || isProviderExplicitlyDisabled(cfg.enabled)) {
+        return false;
+    }
+    const auth = resolveProviderAuthMode(cfg.auth) ?? "direct";
+    if (auth === "deeproute") {
+        return Boolean(cfg.baseUrl?.trim() && cfg.apiKey?.trim());
+    }
+    return true;
+}
+export function resolveEnabledProviders(config) {
+    const ids = [];
+    for (const id of [
+        "ragflow",
+        "serper",
+        "metaso",
+        "zai",
+        "exa",
+        "searxng",
+        "kimi",
+        "brave",
+        "tavily",
+        "jina",
+        "minimax",
+    ]) {
+        if (isProviderConfigured(config, id)) {
+            ids.push(id);
+        }
+    }
+    return ids;
+}
+export function formatResultsAsContent(results, answer) {
+    if (answer?.trim()) {
+        return answer.trim();
+    }
+    if (results.length === 0) {
+        return "No search results.";
+    }
+    return results
+        .map((item, index) => {
+        const lines = [
+            `${index + 1}. ${item.title || "(no title)"}`,
+            `   ${item.url}`,
+        ];
+        if (item.snippet) {
+            lines.push(`   ${item.snippet}`);
+        }
+        return lines.join("\n");
+    })
+        .join("\n\n");
+}
+export function mergeConcurrentResults(successes, maxResults) {
+    const seen = new Set();
+    const merged = [];
+    const citations = [];
+    for (const success of successes) {
+        for (const url of success.citations) {
+            if (!citations.includes(url)) {
+                citations.push(url);
+            }
+        }
+        for (const item of success.results) {
+            const key = item.url.trim().toLowerCase();
+            if (key && !seen.has(key)) {
+                seen.add(key);
+                merged.push(item);
+                if (merged.length >= maxResults) {
+                    break;
+                }
+            }
+        }
+        if (merged.length >= maxResults) {
+            break;
+        }
+    }
+    let content = "";
+    for (const success of successes) {
+        if (success.answer?.trim()) {
+            content = success.answer.trim();
+            break;
+        }
+    }
+    if (!content) {
+        content = formatResultsAsContent(merged);
+    }
+    return { results: merged, content, citations };
+}
+function mapAttempts(attempts) {
+    return attempts.map((attempt) => attempt.ok
+        ? { provider: attempt.provider, ok: true, tookMs: attempt.tookMs }
+        : {
+            provider: attempt.provider,
+            ok: false,
+            error: attempt.error,
+            message: attempt.message,
+        });
+}
+export function toToolPayload(success, attempts) {
+    return {
+        query: success.query,
+        searchMode: "fallback",
+        provider: success.provider,
+        tookMs: success.tookMs,
+        citations: success.citations,
+        results: success.results,
+        ...(success.answer ? { answer: success.answer } : {}),
+        content: success.content,
+        externalContent: {
+            untrusted: true,
+            source: EXTERNAL_CONTENT_SOURCE,
+            provider: success.provider,
+        },
+        attempts: mapAttempts(attempts),
+    };
+}
+export function toConcurrentToolPayload(query, successes, attempts, tookMs, maxResults) {
+    const { results, content, citations } = mergeConcurrentResults(successes, maxResults);
+    const resultsByProvider = {};
+    for (const attempt of attempts) {
+        if (attempt.ok) {
+            resultsByProvider[attempt.provider] = {
+                ok: true,
+                tookMs: attempt.tookMs,
+                results: attempt.results,
+                ...(attempt.answer ? { answer: attempt.answer } : {}),
+                content: attempt.content,
+            };
+        }
+        else {
+            resultsByProvider[attempt.provider] = {
+                ok: false,
+                error: attempt.error,
+                message: attempt.message,
+            };
+        }
+    }
+    const succeeded = attempts.filter((attempt) => isSuccessWithResults(attempt)).length;
+    return {
+        query,
+        searchMode: "concurrent",
+        tookMs,
+        content,
+        results,
+        citations,
+        resultsByProvider,
+        attempts: mapAttempts(attempts),
+        summary: {
+            total: attempts.length,
+            succeeded,
+            failed: attempts.length - succeeded,
+        },
+        externalContent: {
+            untrusted: true,
+            source: EXTERNAL_CONTENT_SOURCE,
+            providers: successes.map((success) => success.provider),
+        },
+    };
+}
+export function failurePayload(query, attempts, options) {
+    return {
+        error: "all_providers_failed",
+        query,
+        ...(options?.searchMode ? { searchMode: options.searchMode } : {}),
+        message: "All configured search providers failed. See attempts for details.",
+        attempts: mapAttempts(attempts),
+    };
+}
+export function noProvidersConfiguredPayload(searchMode) {
+    const listKey = searchMode === "concurrent" ? "concurrent" : "fallback";
+    return {
+        error: "no_providers_configured",
+        searchMode,
+        message: `No providers configured for ${searchMode} mode. Set ${pluginConfigPath(listKey)} with enabled providers.`,
+    };
+}
+//# sourceMappingURL=result.js.map

package/dist/run-provider.js

@@ -0,0 +1,42 @@
+import { searchBrave } from "./adapters/brave.js";
+import { searchExa } from "./adapters/exa.js";
+import { searchJina } from "./adapters/jina.js";
+import { searchKimi } from "./adapters/kimi.js";
+import { searchMetaso } from "./adapters/metaso.js";
+import { searchMinimax } from "./adapters/minimax.js";
+import { searchRagflow } from "./adapters/ragflow.js";
+import { searchSearxng } from "./adapters/searxng.js";
+import { searchSerper } from "./adapters/serper.js";
+import { searchTavily } from "./adapters/tavily.js";
+import { searchZai } from "./adapters/zai.js";
+export async function runProvider(config, provider, query, count, signal, runOptions) {
+    switch (provider) {
+        case "ragflow":
+            return searchRagflow(config, query, count, signal);
+        case "serper":
+            return searchSerper(config, query, count, signal);
+        case "metaso":
+            return searchMetaso(config, query, count, signal);
+        case "zai":
+            return searchZai(config, query, count, signal);
+        case "exa":
+            return searchExa(config, query, count, signal);
+        case "searxng":
+            return searchSearxng(config, query, count, signal);
+        case "kimi":
+            return searchKimi(config, query, count, signal);
+        case "brave":
+            return searchBrave(config, query, count, signal, runOptions);
+        case "tavily":
+            return searchTavily(config, query, count, signal, runOptions);
+        case "jina":
+            return searchJina(config, query, count, signal);
+        case "minimax":
+            return searchMinimax(config, query, count, signal);
+        default: {
+            const _exhaustive = provider;
+            return _exhaustive;
+        }
+    }
+}
+//# sourceMappingURL=run-provider.js.map

package/dist/search-concurrent.js

@@ -0,0 +1,23 @@
+import { failurePayload, isProviderConfigured, isSuccessWithResults, providerConfigurationHint, toConcurrentToolPayload, } from "./result.js";
+import { runProvider } from "./run-provider.js";
+async function resolveProviderAttempt(config, providerId, query, count, signal, runOptions) {
+    if (!isProviderConfigured(config, providerId)) {
+        return {
+            ok: false,
+            provider: providerId,
+            error: "provider_not_configured",
+            message: providerConfigurationHint(providerId),
+        };
+    }
+    return runProvider(config, providerId, query, count, signal, runOptions);
+}
+export async function executeConcurrentSearch(config, query, count, order, signal, runOptions) {
+    const started = Date.now();
+    const attempts = await Promise.all(order.map((providerId) => resolveProviderAttempt(config, providerId, query, count, signal, runOptions)));
+    const successes = attempts.filter((attempt) => attempt.ok && isSuccessWithResults(attempt));
+    if (successes.length === 0) {
+        return failurePayload(query, attempts, { searchMode: "concurrent" });
+    }
+    return toConcurrentToolPayload(query, successes, attempts, Date.now() - started, count);
+}
+//# sourceMappingURL=search-concurrent.js.map

package/dist/search-fallback.js

@@ -0,0 +1,14 @@
+import { failurePayload, isSuccessWithResults, toToolPayload, } from "./result.js";
+import { runProvider } from "./run-provider.js";
+export async function executeFallbackSearch(config, query, count, order, signal, runOptions) {
+    const attempts = [];
+    for (const providerId of order) {
+        const outcome = await runProvider(config, providerId, query, count, signal, runOptions);
+        attempts.push(outcome);
+        if (outcome.ok && isSuccessWithResults(outcome)) {
+            return toToolPayload(outcome, attempts);
+        }
+    }
+    return failurePayload(query, attempts, { searchMode: "fallback" });
+}
+//# sourceMappingURL=search-fallback.js.map

package/dist/search.js

@@ -0,0 +1,43 @@
+import { clampCount, isProviderConfigured, noProvidersConfiguredPayload, providerConfigurationHint, resolveConcurrentList, resolveFallbackOrder, resolveSearchMode, } from "./result.js";
+import { executeConcurrentSearch } from "./search-concurrent.js";
+import { executeFallbackSearch } from "./search-fallback.js";
+export async function executeDeepSearch(config, params, signal) {
+    const query = params.query.trim();
+    if (!query) {
+        return { error: "missing_query", message: "query is required." };
+    }
+    const count = clampCount(params.count ?? config.maxResults);
+    const runOptions = {
+        brave: {
+            country: params.country,
+            freshness: params.freshness,
+        },
+        tavily: {
+            searchDepth: params.searchDepth,
+            includeAnswer: params.includeAnswer,
+        },
+    };
+    if (params.provider) {
+        if (!isProviderConfigured(config, params.provider)) {
+            return {
+                error: "provider_not_configured",
+                message: providerConfigurationHint(params.provider),
+            };
+        }
+        return executeFallbackSearch(config, query, count, [params.provider], signal, runOptions);
+    }
+    const searchMode = resolveSearchMode(config, params.searchMode);
+    if (searchMode === "concurrent") {
+        const order = resolveConcurrentList(config);
+        if (order.length === 0) {
+            return noProvidersConfiguredPayload("concurrent");
+        }
+        return executeConcurrentSearch(config, query, count, order, signal, runOptions);
+    }
+    const order = resolveFallbackOrder(config);
+    if (order.length === 0) {
+        return noProvidersConfiguredPayload("fallback");
+    }
+    return executeFallbackSearch(config, query, count, order, signal, runOptions);
+}
+//# sourceMappingURL=search.js.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map