@qzhike/agent-search 1.0.1

package/dist/config-schema.js

@@ -0,0 +1,221 @@
+import { Type } from "typebox";
+const DEEPROUTE_ORIGIN = "deeproute: Console API origin only (e.g. http://host:20316); plugin appends /api/mirror/{provider}. Legacy full mirror paths still work.";
+const providerEnabled = Type.Optional(Type.Boolean({
+    description: "Set false to disable a configured provider. Omitted providers are disabled.",
+}));
+export const searxngProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: SearXNG instance baseUrl. deeproute: Bearer sk to Console /api/mirror/searxng.",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: SearXNG root, e.g. http://127.0.0.1:8888. ${DEEPROUTE_ORIGIN}`,
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "deeproute only: New API user sk (Bearer).",
+    })),
+    categories: Type.Optional(Type.String({ description: "SearXNG categories, e.g. general" })),
+    language: Type.Optional(Type.String({ description: "SearXNG language code" })),
+});
+export const kimiProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    baseUrl: Type.Optional(Type.String({
+        description: "OpenAI-compatible base URL, e.g. https://new-api.example.com/v1 (New API).",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "Bearer token for Authorization header (required to enable).",
+    })),
+    model: Type.Optional(Type.String({
+        description: "Model id for chat/completions, default kimi-k2.6",
+    })),
+});
+export const braveProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: Brave X-Subscription-Token (default). deeproute: Bearer user sk to Console /api/mirror/brave.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: Brave subscription token. deeproute: New API user sk (Console injects Brave key).",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: default https://api.search.brave.com. ${DEEPROUTE_ORIGIN}`,
+    })),
+    country: Type.Optional(Type.String({
+        description: "Brave country filter (ISO 3166-1 alpha-2), e.g. US.",
+    })),
+    freshness: Type.Optional(Type.String({
+        description: 'Brave result freshness: "pd" (day), "pw", "pm", or "py".',
+    })),
+});
+export const jinaProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: POST https://s.jina.ai/ with Jina API key. deeproute: POST {baseUrl}/mirror/jina/s with user sk; Console must store valid Jina API key.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: Jina API key (required). deeproute: New API user sk; vendor Jina key must be in Console 扩展服务.",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `deeproute: ${DEEPROUTE_ORIGIN} direct: default https://s.jina.ai.`,
+    })),
+});
+export const minimaxProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: Bearer Token Plan key. deeproute: Bearer user sk; Console injects minimax key and region.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: MiniMax Token Plan key. deeproute: New API user sk (Console injects minimax credentials).",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `deeproute: ${DEEPROUTE_ORIGIN} direct: api.minimax.io or api.minimaxi.com.`,
+    })),
+    region: Type.Optional(Type.String({
+        description: 'direct only: "global" (default) or "cn" for upstream host.',
+    })),
+});
+export const ragflowProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: Bearer RAGFlow API key + datasetIds in config. deeproute: Bearer user sk; Console injects RAGFlow key and dataset_ids.",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: RAGFlow service root. ${DEEPROUTE_ORIGIN}`,
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: RAGFlow API key. deeproute: New API user sk (Console injects RAGFlow key).",
+    })),
+    datasetIds: Type.Optional(Type.String({
+        description: "direct only: comma-separated RAGFlow dataset IDs (deeproute: configured in Console 扩展服务).",
+    })),
+    similarityThreshold: Type.Optional(Type.Number({ description: "RAGFlow similarity_threshold, default 0.2." })),
+    pageSize: Type.Optional(Type.Number({ description: "RAGFlow page_size, default 30." })),
+    topK: Type.Optional(Type.Number({ description: "RAGFlow top_k." })),
+    timeoutSeconds: Type.Optional(Type.Number({
+        description: "RAGFlow HTTP timeout (seconds), default 120, max 120.",
+        minimum: 1,
+        maximum: 120,
+    })),
+});
+export const serperProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: X-API-KEY to google.serper.dev. deeproute: Bearer user sk; Console injects Serper key.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: Serper API key. deeproute: New API user sk (Console injects Serper key).",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: default https://google.serper.dev. ${DEEPROUTE_ORIGIN}`,
+    })),
+});
+export const metasoProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: Bearer Metaso key. deeproute: Bearer user sk; Console injects Metaso key.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: Metaso API key. deeproute: New API user sk (Console injects Metaso key).",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: default https://metaso.cn. ${DEEPROUTE_ORIGIN}`,
+    })),
+});
+export const zaiProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: Bearer Zhipu key. deeproute: Bearer user sk; Console injects Zhipu key.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: Zhipu API key. deeproute: New API user sk (Console injects Zhipu key).",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: default https://open.bigmodel.cn. ${DEEPROUTE_ORIGIN}`,
+    })),
+    searchEngine: Type.Optional(Type.String({
+        description: 'Zhipu search_engine parameter, default "search_pro".',
+    })),
+});
+export const exaProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: x-api-key to api.exa.ai. deeproute: Bearer user sk; Console injects Exa key.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: Exa API key. deeproute: New API user sk (Console injects Exa key).",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: default https://api.exa.ai. ${DEEPROUTE_ORIGIN}`,
+    })),
+});
+export const tavilyProviderSchema = Type.Object({
+    enabled: providerEnabled,
+    auth: Type.Optional(Type.Union([Type.Literal("direct"), Type.Literal("deeproute")], {
+        description: "direct: Tavily api_key in POST body. deeproute: Bearer sk; Console injects Tavily key.",
+    })),
+    apiKey: Type.Optional(Type.String({
+        description: "direct: Tavily API key. deeproute: New API user sk (Console injects Tavily key).",
+    })),
+    baseUrl: Type.Optional(Type.String({
+        description: `direct: default https://api.tavily.com. ${DEEPROUTE_ORIGIN}`,
+    })),
+    searchDepth: Type.Optional(Type.Union([Type.Literal("basic"), Type.Literal("advanced")], {
+        description: "Tavily search depth.",
+    })),
+    includeAnswer: Type.Optional(Type.Boolean({
+        description: "Include Tavily synthesized answer when available.",
+    })),
+});
+const searchProviderIdSchema = Type.Union([
+    Type.Literal("ragflow"),
+    Type.Literal("serper"),
+    Type.Literal("metaso"),
+    Type.Literal("zai"),
+    Type.Literal("exa"),
+    Type.Literal("searxng"),
+    Type.Literal("kimi"),
+    Type.Literal("brave"),
+    Type.Literal("tavily"),
+    Type.Literal("jina"),
+    Type.Literal("minimax"),
+]);
+export const pluginConfigSchema = Type.Object({
+    searchMode: Type.Optional(Type.Union([Type.Literal("fallback"), Type.Literal("concurrent")], {
+        description: 'Search strategy: "fallback" = linear try order; "concurrent" = parallel calls. Default fallback.',
+    })),
+    fallback: Type.Optional(Type.Array(searchProviderIdSchema, {
+        description: "Fallback mode: strict try order. Only listed configured providers run.",
+    })),
+    concurrent: Type.Optional(Type.Array(searchProviderIdSchema, {
+        description: "Concurrent mode: providers to call in parallel (capped by concurrentMaxProviders).",
+    })),
+    concurrentMaxProviders: Type.Optional(Type.Number({
+        description: "Max parallel providers in concurrent mode (1-10). Default 3.",
+        minimum: 1,
+        maximum: 10,
+    })),
+    timeoutSeconds: Type.Optional(Type.Number({
+        description: "HTTP timeout per request (seconds).",
+        minimum: 1,
+        maximum: 120,
+    })),
+    maxResults: Type.Optional(Type.Number({
+        description: "Default max structured results (1-10).",
+        minimum: 1,
+        maximum: 10,
+    })),
+    providers: Type.Optional(Type.Object({
+        ragflow: Type.Optional(ragflowProviderSchema),
+        serper: Type.Optional(serperProviderSchema),
+        metaso: Type.Optional(metasoProviderSchema),
+        zai: Type.Optional(zaiProviderSchema),
+        exa: Type.Optional(exaProviderSchema),
+        searxng: Type.Optional(searxngProviderSchema),
+        kimi: Type.Optional(kimiProviderSchema),
+        brave: Type.Optional(braveProviderSchema),
+        tavily: Type.Optional(tavilyProviderSchema),
+        jina: Type.Optional(jinaProviderSchema),
+        minimax: Type.Optional(minimaxProviderSchema),
+    })),
+});
+//# sourceMappingURL=config-schema.js.map

package/dist/http.js

@@ -0,0 +1,49 @@
+export async function fetchJson(url, options) {
+    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 init = {
+            method: options.method ?? (options.body !== undefined ? "POST" : "GET"),
+            headers: options.headers,
+            signal: signals.length > 1 ? AbortSignal.any(signals) : controller.signal,
+        };
+        if (options.body !== undefined) {
+            init.body =
+                typeof options.body === "string"
+                    ? options.body
+                    : JSON.stringify(options.body);
+            init.headers = {
+                "Content-Type": "application/json",
+                ...options.headers,
+            };
+        }
+        const response = await fetch(url, init);
+        const text = await response.text();
+        let data;
+        try {
+            data = text ? JSON.parse(text) : {};
+        }
+        catch {
+            throw new Error(`Invalid JSON response (${response.status}): ${text.slice(0, 500)}`);
+        }
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${text.slice(0, 500) || response.statusText}`);
+        }
+        return { status: response.status, data, text };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function trimTrailingSlashes(url) {
+    return url.replace(/\/+$/, "");
+}
+export function configString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+//# sourceMappingURL=http.js.map

package/dist/index.js

@@ -0,0 +1,84 @@
+import { defineToolPlugin } from "openclaw/plugin-sdk/tool-plugin";
+import { Type } from "typebox";
+import { pluginConfigSchema } from "./config-schema.js";
+import { PLUGIN_DISPLAY_NAME, PLUGIN_ID, TOOL_READ_URL, TOOL_SEARCH, } from "./plugin-meta.js";
+import { executeReadUrl } from "./read-url.js";
+import { executeDeepSearch } from "./search.js";
+const providerIdSchema = Type.Optional(Type.Union([
+    Type.Literal("ragflow"),
+    Type.Literal("serper"),
+    Type.Literal("metaso"),
+    Type.Literal("zai"),
+    Type.Literal("exa"),
+    Type.Literal("searxng"),
+    Type.Literal("kimi"),
+    Type.Literal("brave"),
+    Type.Literal("tavily"),
+    Type.Literal("jina"),
+    Type.Literal("minimax"),
+], {
+    description: "Force a single backend instead of configured fallback chain.",
+}));
+export default defineToolPlugin({
+    id: PLUGIN_ID,
+    name: PLUGIN_DISPLAY_NAME,
+    description: "Multi-backend search (RAGFlow KB, Serper, Metaso, Zhipu, Exa, SearXNG, Kimi, Brave, Tavily, Jina, MiniMax) with fallback/concurrent modes, plus Jina Reader URL fetch. DeepRoute mirror support.",
+    configSchema: pluginConfigSchema,
+    tools: (tool) => [
+        tool({
+            name: TOOL_SEARCH,
+            label: "Qzhike Search",
+            description: "Search knowledge bases (RAGFlow) and the web using configured backends with fallback or concurrent mode. Prefer this over web_search when this plugin is installed.",
+            parameters: Type.Object({
+                query: Type.String({ description: "Search query." }),
+                count: Type.Optional(Type.Number({
+                    description: "Max results for structured providers (1-10).",
+                    minimum: 1,
+                    maximum: 10,
+                })),
+                searchMode: Type.Optional(Type.Union([Type.Literal("fallback"), Type.Literal("concurrent")], {
+                    description: "Override config searchMode for this call (fallback = linear try order, concurrent = parallel).",
+                })),
+                provider: providerIdSchema,
+                country: Type.Optional(Type.String({
+                    description: "Brave only: ISO 3166-1 alpha-2 country filter (overrides config).",
+                })),
+                freshness: Type.Optional(Type.String({
+                    description: "Brave only: freshness pd|pw|pm|py (overrides config).",
+                })),
+                searchDepth: Type.Optional(Type.Union([Type.Literal("basic"), Type.Literal("advanced")], {
+                    description: "Tavily only: search depth (overrides config).",
+                })),
+                includeAnswer: Type.Optional(Type.Boolean({
+                    description: "Tavily only: include synthesized answer (overrides config).",
+                })),
+            }),
+            async execute(params, config, context) {
+                context.signal?.throwIfAborted();
+                return executeDeepSearch(config, {
+                    query: params.query,
+                    count: params.count,
+                    searchMode: params.searchMode,
+                    provider: params.provider,
+                    country: params.country,
+                    freshness: params.freshness,
+                    searchDepth: params.searchDepth,
+                    includeAnswer: params.includeAnswer,
+                }, context.signal);
+            },
+        }),
+        tool({
+            name: TOOL_READ_URL,
+            label: "Qzhike Read URL",
+            description: "Fetch readable page content via Jina Reader (GET r.jina.ai or DeepRoute /api/mirror/jina/r/…). Use when you have a URL and need full page text.",
+            parameters: Type.Object({
+                url: Type.String({ description: "Absolute HTTP(S) URL to read." }),
+            }),
+            async execute(params, config, context) {
+                context.signal?.throwIfAborted();
+                return executeReadUrl(config, { url: params.url }, context.signal);
+            },
+        }),
+    ],
+});
+//# sourceMappingURL=index.js.map

package/dist/plugin-meta.js

@@ -0,0 +1,11 @@
+/** OpenClaw plugin id (also used as plugins.entries key). */
+export const PLUGIN_ID = "qzhike-agent-search";
+export const PLUGIN_DISPLAY_NAME = "Qzhike Agent Search";
+export const TOOL_SEARCH = "qzhike_search";
+export const TOOL_READ_URL = "qzhike_read_url";
+export const EXTERNAL_CONTENT_SOURCE = "qzhike_agent_search";
+export function pluginConfigPath(suffix = "") {
+    const base = `plugins.entries.${PLUGIN_ID}.config`;
+    return suffix ? `${base}.${suffix}` : base;
+}
+//# sourceMappingURL=plugin-meta.js.map

package/dist/read-url.js

@@ -0,0 +1,38 @@
+/** Internal Jina Reader fetch for qzhike_read_url. */
+import { readUrlWithJina } from "./adapters/jina-reader.js";
+import { pluginConfigPath, TOOL_READ_URL } from "./plugin-meta.js";
+import { isJinaReaderConfigured } from "./result.js";
+export async function executeReadUrl(config, params, signal) {
+    const url = params.url.trim();
+    if (!url) {
+        return { error: "missing_url", message: "url is required." };
+    }
+    if (!isJinaReaderConfigured(config)) {
+        return {
+            error: "reader_not_configured",
+            message: `Jina Reader is not configured. Set ${pluginConfigPath("providers.jina")} ` +
+                "(direct: optional apiKey; deeproute: baseUrl + user apiKey sk).",
+        };
+    }
+    const outcome = await readUrlWithJina(config, url, signal);
+    if (!outcome.ok) {
+        return {
+            error: outcome.error,
+            message: outcome.message,
+            provider: outcome.provider,
+        };
+    }
+    return {
+        url: outcome.url,
+        provider: outcome.provider,
+        tookMs: outcome.tookMs,
+        title: outcome.title,
+        content: outcome.content,
+        externalContent: {
+            untrusted: true,
+            source: TOOL_READ_URL,
+            provider: outcome.provider,
+        },
+    };
+}
+//# sourceMappingURL=read-url.js.map