@qzhike/agent-search 1.0.1

package/dist/adapters/jina.js

@@ -0,0 +1,90 @@
+import { configString, fetchJson } from "../http.js";
+import { formatResultsAsContent, resolveTimeoutSeconds } from "../result.js";
+import { buildJinaSearchRequestHeaders, resolveJinaAuthMode, resolveJinaSearchBaseUrl, resolveJinaSearchUrl, } from "./jina-config.js";
+export async function searchJina(config, query, count, signal) {
+    const provider = "jina";
+    const cfg = config.providers?.jina;
+    const auth = resolveJinaAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.jina.auth. Use "direct" (s.jina.ai) or "deeproute" (Console /api/mirror/jina).',
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (auth === "deeproute" && !apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: "deeproute: set providers.jina.apiKey to your DeepRoute user sk (Bearer).",
+        };
+    }
+    const baseUrl = resolveJinaSearchBaseUrl(cfg, auth);
+    if (!baseUrl) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: "deeproute: set providers.jina.baseUrl to Console origin (e.g. http://host:20316).",
+        };
+    }
+    const url = resolveJinaSearchUrl(baseUrl, auth);
+    const startedAt = Date.now();
+    try {
+        const { data } = await fetchJson(url, {
+            method: "POST",
+            headers: buildJinaSearchRequestHeaders(auth, apiKey),
+            body: { q: query, num: count },
+            timeoutSeconds: resolveTimeoutSeconds(config),
+            signal,
+        });
+        const raw = Array.isArray(data.data)
+            ? data.data
+            : Array.isArray(data.results)
+                ? data.results
+                : [];
+        const results = raw.slice(0, count).map((entry) => ({
+            title: entry.title ?? "",
+            url: entry.url ?? "",
+            snippet: entry.description ?? entry.content ?? "",
+            siteName: entry.url ? safeHostname(entry.url) : 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) {
+        const raw = err instanceof Error ? err.message : String(err);
+        const needsKeyHint = raw.includes("401") || raw.includes("AuthenticationRequired");
+        const hint = needsKeyHint
+            ? auth === "deeproute"
+                ? " Jina Search requires a valid Jina API Key in DeepRoute Console → 扩展服务 (secret jina)."
+                : " Jina Search requires a valid Jina API Key in providers.jina.apiKey."
+            : "";
+        return {
+            ok: false,
+            provider,
+            error: "jina_request_failed",
+            message: raw + hint,
+        };
+    }
+}
+function safeHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=jina.js.map

package/dist/adapters/kimi.js

@@ -0,0 +1,196 @@
+import { configString, fetchJson, trimTrailingSlashes } from "../http.js";
+import { pluginConfigPath } from "../plugin-meta.js";
+import { resolveTimeoutSeconds } from "../result.js";
+const DEFAULT_MODEL = "kimi-k2.6";
+const KIMI_THINKING_MODELS = new Set(["kimi-k2.6", "kimi-k2.5"]);
+const WEB_SEARCH_TOOL = {
+    type: "builtin_function",
+    function: { name: "$web_search" },
+};
+function normalizeOptionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function extractMessageText(message) {
+    const content = message?.content?.trim();
+    if (content) {
+        return content;
+    }
+    return message?.reasoning_content?.trim() || undefined;
+}
+function extractCitations(data) {
+    const citations = (data.search_results ?? [])
+        .map((entry) => entry.url?.trim())
+        .filter((url) => Boolean(url));
+    for (const toolCall of data.choices?.[0]?.message?.tool_calls ?? []) {
+        const raw = toolCall.function?.arguments;
+        if (!raw) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            const parsedUrl = normalizeOptionalString(parsed.url);
+            if (parsedUrl) {
+                citations.push(parsedUrl);
+            }
+            for (const result of parsed.search_results ?? []) {
+                const resultUrl = normalizeOptionalString(result.url);
+                if (resultUrl) {
+                    citations.push(resultUrl);
+                }
+            }
+        }
+        catch {
+            // ignore malformed tool arguments
+        }
+    }
+    return [...new Set(citations)];
+}
+function hasGroundingEvidence(data) {
+    if ((data.search_results ?? []).some((e) => e.url || e.title || e.content)) {
+        return true;
+    }
+    return extractCitations(data).length > 0;
+}
+export async function searchKimi(config, query, _count, signal) {
+    const provider = "kimi";
+    const cfg = config.providers?.kimi;
+    const baseUrl = trimTrailingSlashes(configString(cfg?.baseUrl) ?? "");
+    if (!baseUrl) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: `OpenAI-compatible baseUrl missing. Set ${pluginConfigPath("providers.kimi.baseUrl")}.`,
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (!apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: `Bearer apiKey missing. Set ${pluginConfigPath("providers.kimi.apiKey")}.`,
+        };
+    }
+    const model = cfg?.model?.trim() || DEFAULT_MODEL;
+    const endpoint = `${baseUrl}/chat/completions`;
+    const timeoutSeconds = resolveTimeoutSeconds(config);
+    const startedAt = Date.now();
+    const messages = [
+        { role: "user", content: query },
+    ];
+    const collectedCitations = new Set();
+    let grounded = false;
+    try {
+        for (let round = 0; round < 3; round += 1) {
+            const body = {
+                model,
+                messages,
+                tools: [WEB_SEARCH_TOOL],
+            };
+            if (KIMI_THINKING_MODELS.has(model)) {
+                body.thinking = { type: "disabled" };
+            }
+            const { data } = await fetchJson(endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body,
+                timeoutSeconds,
+                signal,
+            });
+            if (hasGroundingEvidence(data)) {
+                grounded = true;
+            }
+            for (const citation of extractCitations(data)) {
+                collectedCitations.add(citation);
+            }
+            const choice = data.choices?.[0];
+            const message = choice?.message;
+            const text = extractMessageText(message);
+            const toolCalls = message?.tool_calls ?? [];
+            if (choice?.finish_reason !== "tool_calls" || toolCalls.length === 0) {
+                const content = text ?? "No response from Kimi.";
+                const citations = [...collectedCitations];
+                const results = citations.map((url, index) => ({
+                    title: `Source ${index + 1}`,
+                    url,
+                    snippet: "",
+                }));
+                if (!grounded) {
+                    return {
+                        ok: false,
+                        provider,
+                        error: "kimi_ungrounded",
+                        message: "Kimi returned a completion without web-search grounding. Try another provider in fallback.",
+                    };
+                }
+                return {
+                    ok: true,
+                    provider,
+                    query,
+                    tookMs: Date.now() - startedAt,
+                    results,
+                    citations,
+                    content,
+                };
+            }
+            messages.push({
+                role: "assistant",
+                content: message?.content ?? "",
+                ...(message?.reasoning_content
+                    ? { reasoning_content: message.reasoning_content }
+                    : {}),
+                tool_calls: toolCalls,
+            });
+            let pushed = false;
+            for (const toolCall of toolCalls) {
+                const toolCallId = toolCall.id?.trim();
+                const toolCallName = toolCall.function?.name?.trim();
+                const toolContent = toolCall.function?.arguments?.trim();
+                if (!toolCallId || !toolCallName || !toolContent) {
+                    continue;
+                }
+                if (toolCallName === WEB_SEARCH_TOOL.function.name) {
+                    grounded = true;
+                }
+                pushed = true;
+                messages.push({
+                    role: "tool",
+                    tool_call_id: toolCallId,
+                    name: toolCallName,
+                    content: toolContent,
+                });
+            }
+            if (!pushed) {
+                const content = text ?? "No response from Kimi.";
+                return {
+                    ok: true,
+                    provider,
+                    query,
+                    tookMs: Date.now() - startedAt,
+                    results: [],
+                    citations: [...collectedCitations],
+                    content,
+                };
+            }
+        }
+        return {
+            ok: false,
+            provider,
+            error: "kimi_incomplete",
+            message: "Kimi search exceeded maximum tool rounds without a final answer.",
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            provider,
+            error: "kimi_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=kimi.js.map

package/dist/adapters/metaso-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_METASO_DIRECT_BASE = "https://metaso.cn";
+export const METASO_SEARCH_PATH = "/api/v1/search";
+export function resolveMetasoAuthMode(auth) {
+    return resolveProviderAuthMode(auth);
+}
+export function resolveMetasoSearchUrl(cfg, auth) {
+    const configured = configString(cfg?.baseUrl);
+    if (auth === "deeproute") {
+        if (!configured)
+            return undefined;
+        const root = resolveDeeprouteMirrorRoot(configured, "metaso");
+        return joinMirrorPath(root, METASO_SEARCH_PATH);
+    }
+    const base = configured
+        ? trimTrailingSlashes(configured)
+        : DEFAULT_METASO_DIRECT_BASE;
+    return joinMirrorPath(base, METASO_SEARCH_PATH);
+}
+export function buildMetasoRequestHeaders(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;
+}
+//# sourceMappingURL=metaso-config.js.map

package/dist/adapters/metaso.js

@@ -0,0 +1,102 @@
+import { configString, fetchJson } from "../http.js";
+import { formatResultsAsContent, resolveTimeoutSeconds } from "../result.js";
+import { buildMetasoRequestHeaders, resolveMetasoAuthMode, resolveMetasoSearchUrl, } from "./metaso-config.js";
+export async function searchMetaso(config, query, count, signal) {
+    const provider = "metaso";
+    const cfg = config.providers?.metaso;
+    const auth = resolveMetasoAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.metaso.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.metaso.apiKey to your DeepRoute user sk."
+                : "direct: set providers.metaso.apiKey to your Metaso API key.",
+        };
+    }
+    const url = resolveMetasoSearchUrl(cfg, auth);
+    if (!url) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: "deeproute: set providers.metaso.baseUrl to Console origin (e.g. http://host:20316).",
+        };
+    }
+    const startedAt = Date.now();
+    try {
+        const { data } = await fetchJson(url, {
+            method: "POST",
+            headers: buildMetasoRequestHeaders(auth, apiKey),
+            body: {
+                q: query,
+                scope: "webpage",
+                page: 1,
+                includeSummary: true,
+                includeRawContent: false,
+                conciseSnippet: true,
+            },
+            timeoutSeconds: resolveTimeoutSeconds(config),
+            signal,
+        });
+        if (data.errCode !== undefined && data.errCode !== 0) {
+            return {
+                ok: false,
+                provider,
+                error: "metaso_api_error",
+                message: data.errMsg ?? `Metaso errCode ${data.errCode}`,
+            };
+        }
+        const nested = data.data ?? data;
+        const raw = Array.isArray(nested.webpages)
+            ? nested.webpages
+            : Array.isArray(nested.results)
+                ? nested.results
+                : Array.isArray(nested.items)
+                    ? nested.items
+                    : [];
+        const results = raw.slice(0, count).map((entry) => ({
+            title: entry.title ?? "",
+            url: entry.link ?? "",
+            snippet: entry.snippet ?? entry.summary ?? "",
+            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: "metaso_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function safeHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=metaso.js.map

package/dist/adapters/minimax-config.js

@@ -0,0 +1,54 @@
+import { configString, trimTrailingSlashes } from "../http.js";
+import { joinMirrorPath, resolveDeeprouteMirrorRoot, } from "./deeproute-mirror.js";
+import { buildDeeprouteBearerHeaders, resolveProviderAuthMode, } from "./provider-auth.js";
+export const DEFAULT_MINIMAX_GLOBAL_BASE = "https://api.minimax.io";
+export const DEFAULT_MINIMAX_CN_BASE = "https://api.minimaxi.com";
+export const MINIMAX_SEARCH_PATH = "/v1/coding_plan/search";
+export function resolveMinimaxAuthMode(auth) {
+    return resolveProviderAuthMode(auth);
+}
+export function resolveMinimaxBaseUrl(cfg, auth) {
+    const configured = configString(cfg?.baseUrl);
+    if (configured) {
+        if (auth === "deeproute") {
+            return resolveDeeprouteMirrorRoot(configured, "minimax");
+        }
+        return trimTrailingSlashes(configured);
+    }
+    if (auth === "direct") {
+        const region = (cfg?.region ?? "global").trim().toLowerCase();
+        if (region === "cn" || region === "china") {
+            return DEFAULT_MINIMAX_CN_BASE;
+        }
+        return DEFAULT_MINIMAX_GLOBAL_BASE;
+    }
+    return undefined;
+}
+export function resolveMinimaxSearchUrl(baseUrl, auth) {
+    if (auth === "deeproute") {
+        return joinMirrorPath(baseUrl, MINIMAX_SEARCH_PATH);
+    }
+    const trimmed = trimTrailingSlashes(baseUrl || DEFAULT_MINIMAX_GLOBAL_BASE);
+    try {
+        const url = new URL(trimmed);
+        url.pathname = `${url.pathname.replace(/\/$/, "")}${MINIMAX_SEARCH_PATH}`;
+        return url.toString();
+    }
+    catch {
+        return `${DEFAULT_MINIMAX_GLOBAL_BASE}${MINIMAX_SEARCH_PATH}`;
+    }
+}
+export function buildMinimaxRequestHeaders(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;
+}
+//# sourceMappingURL=minimax-config.js.map

package/dist/adapters/minimax.js

@@ -0,0 +1,85 @@
+import { configString, fetchJson } from "../http.js";
+import { formatResultsAsContent, resolveTimeoutSeconds } from "../result.js";
+import { buildMinimaxRequestHeaders, resolveMinimaxAuthMode, resolveMinimaxBaseUrl, resolveMinimaxSearchUrl, } from "./minimax-config.js";
+export async function searchMinimax(config, query, count, signal) {
+    const provider = "minimax";
+    const cfg = config.providers?.minimax;
+    const auth = resolveMinimaxAuthMode(cfg?.auth);
+    if (!auth) {
+        return {
+            ok: false,
+            provider,
+            error: "invalid_auth",
+            message: 'Invalid providers.minimax.auth. Use "direct" (Token Plan key) or "deeproute" (Console mirror + user sk).',
+        };
+    }
+    const apiKey = configString(cfg?.apiKey);
+    if (!apiKey) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_api_key",
+            message: auth === "deeproute"
+                ? "deeproute: set providers.minimax.apiKey to your DeepRoute user sk (Bearer)."
+                : "direct: set providers.minimax.apiKey to your MiniMax Token Plan key.",
+        };
+    }
+    const baseUrl = resolveMinimaxBaseUrl(cfg, auth);
+    if (!baseUrl) {
+        return {
+            ok: false,
+            provider,
+            error: "missing_base_url",
+            message: "deeproute: set providers.minimax.baseUrl (e.g. http://host:20316/api/mirror/minimax).",
+        };
+    }
+    const url = resolveMinimaxSearchUrl(baseUrl, auth);
+    const startedAt = Date.now();
+    try {
+        const { data } = await fetchJson(url, {
+            method: "POST",
+            headers: buildMinimaxRequestHeaders(auth, apiKey),
+            body: { query, max_results: count },
+            timeoutSeconds: resolveTimeoutSeconds(config),
+            signal,
+        });
+        const raw = Array.isArray(data.results)
+            ? data.results
+            : Array.isArray(data.data?.results)
+                ? data.data.results
+                : [];
+        const results = raw.slice(0, count).map((entry) => ({
+            title: entry.title ?? "",
+            url: entry.url ?? "",
+            snippet: entry.snippet ?? entry.description ?? entry.content ?? "",
+            siteName: entry.url ? safeHostname(entry.url) : 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: "minimax_request_failed",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function safeHostname(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=minimax.js.map

package/dist/adapters/provider-auth.js

@@ -0,0 +1,18 @@
+import { configString } from "../http.js";
+export function resolveProviderAuthMode(auth) {
+    const value = configString(auth)?.toLowerCase();
+    if (!value || value === "direct") {
+        return "direct";
+    }
+    if (value === "deeproute") {
+        return "deeproute";
+    }
+    return undefined;
+}
+export function buildDeeprouteBearerHeaders(apiKey) {
+    return {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+    };
+}
+//# sourceMappingURL=provider-auth.js.map

package/dist/adapters/ragflow-config.js

@@ -0,0 +1,63 @@
+import { configString, trimTrailingSlashes } from "../http.js";
+import { joinMirrorPath, resolveDeeprouteMirrorRoot, } from "./deeproute-mirror.js";
+import { buildDeeprouteBearerHeaders, resolveProviderAuthMode, } from "./provider-auth.js";
+export const RAGFLOW_RETRIEVAL_PATH = "/api/v1/retrieval";
+export const DEFAULT_RAGFLOW_TIMEOUT_SECONDS = 120;
+export function resolveRagflowAuthMode(auth) {
+    return resolveProviderAuthMode(auth);
+}
+export function parseRagflowDatasetIds(raw) {
+    const trimmed = configString(raw);
+    if (!trimmed) {
+        return [];
+    }
+    return trimmed
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+export function resolveRagflowBaseUrl(cfg, auth) {
+    const configured = configString(cfg?.baseUrl);
+    if (!configured) {
+        return undefined;
+    }
+    if (auth === "deeproute") {
+        return resolveDeeprouteMirrorRoot(configured, "ragflow");
+    }
+    return trimTrailingSlashes(configured);
+}
+export function resolveRagflowRetrievalUrl(baseUrl, auth) {
+    if (auth === "deeproute") {
+        return joinMirrorPath(baseUrl, RAGFLOW_RETRIEVAL_PATH);
+    }
+    const trimmed = trimTrailingSlashes(baseUrl);
+    try {
+        const url = new URL(trimmed);
+        url.pathname = `${url.pathname.replace(/\/$/, "")}${RAGFLOW_RETRIEVAL_PATH}`;
+        return url.toString();
+    }
+    catch {
+        return `${trimmed}${RAGFLOW_RETRIEVAL_PATH}`;
+    }
+}
+export function buildRagflowRequestHeaders(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 resolveRagflowTimeoutSeconds(cfg) {
+    const value = cfg?.timeoutSeconds;
+    if (typeof value === "number" && value > 0) {
+        return Math.min(120, Math.floor(value));
+    }
+    return DEFAULT_RAGFLOW_TIMEOUT_SECONDS;
+}
+//# sourceMappingURL=ragflow-config.js.map