kaijibot 2026.6.21 → 2026.6.23

package/dist/web-search-BtwmRrNq.js

@@ -0,0 +1,221 @@
+import { l as isRecord } from "./utils-CE5zxr9Z.js";
+import { t as formatCliCommand } from "./command-format-BeJUeZeT.js";
+import { d as readNumberParam, h as readStringParam } from "./common-BqLAxNEk.js";
+import { c as wrapWebContent } from "./external-content-86L9qJa0.js";
+import { i as readCache, l as writeCache, o as resolveCacheTtlMs, r as normalizeCacheKey, s as resolveTimeoutSeconds } from "./web-shared-DBF1sNoo.js";
+import { u as postTrustedWebToolsJson } from "./web-search-provider-common-Bg1Lk697.js";
+import { a as setProviderWebSearchPluginConfigValue, i as resolveProviderWebSearchPluginConfig, o as setScopedCredentialValue, r as mergeScopedSearchConfig, t as getScopedCredentialValue } from "./web-search-provider-config-CKklBEQS.js";
+import { n as resolveWebSearchProviderCredential } from "./provider-web-search-DFv7Pi_E.js";
+import { t as normalizeXaiModelId } from "./model-id-D1Wk8S2O.js";
+import "./tool-config-shared-RmlkWteZ.js";
+import { c as setPluginXSearchConfigValue, s as resolveEffectiveXSearchConfig, t as XAI_DEFAULT_X_SEARCH_MODEL } from "./x-search-shared-lXehAzFd.js";
+import { a as resolveXaiResponseTextCitationsAndInline, n as buildXaiResponsesToolBody, r as extractXaiWebSearchContent, t as XAI_RESPONSES_ENDPOINT } from "./responses-tool-shared-DHcb1dPQ.js";
+import { Type } from "typebox";
+//#region extensions/xai/src/web-search-shared.ts
+const XAI_WEB_SEARCH_ENDPOINT = XAI_RESPONSES_ENDPOINT;
+const XAI_DEFAULT_WEB_SEARCH_MODEL = "grok-4-1-fast";
+function buildXaiWebSearchPayload(params) {
+	return {
+		query: params.query,
+		provider: params.provider,
+		model: params.model,
+		tookMs: params.tookMs,
+		externalContent: {
+			untrusted: true,
+			source: "web_search",
+			provider: params.provider,
+			wrapped: true
+		},
+		content: wrapWebContent(params.content, "web_search"),
+		citations: params.citations,
+		...params.inlineCitations ? { inlineCitations: params.inlineCitations } : {}
+	};
+}
+function resolveXaiSearchConfig(searchConfig) {
+	return (isRecord(searchConfig?.grok) ? searchConfig.grok : void 0) ?? {};
+}
+function resolveXaiWebSearchModel(searchConfig) {
+	const config = resolveXaiSearchConfig(searchConfig);
+	return typeof config.model === "string" && config.model.trim() ? normalizeXaiModelId(config.model.trim()) : XAI_DEFAULT_WEB_SEARCH_MODEL;
+}
+function resolveXaiInlineCitations(searchConfig) {
+	return resolveXaiSearchConfig(searchConfig).inlineCitations === true;
+}
+async function requestXaiWebSearch(params) {
+	return await postTrustedWebToolsJson({
+		url: XAI_WEB_SEARCH_ENDPOINT,
+		timeoutSeconds: params.timeoutSeconds,
+		apiKey: params.apiKey,
+		body: buildXaiResponsesToolBody({
+			model: params.model,
+			inputText: params.query,
+			tools: [{ type: "web_search" }]
+		}),
+		errorLabel: "xAI"
+	}, async (response) => {
+		return resolveXaiResponseTextCitationsAndInline(await response.json(), params.inlineCitations);
+	});
+}
+//#endregion
+//#region extensions/xai/web-search.ts
+const XAI_WEB_SEARCH_CACHE = /* @__PURE__ */ new Map();
+const X_SEARCH_MODEL_OPTIONS = [{
+	value: XAI_DEFAULT_X_SEARCH_MODEL,
+	label: XAI_DEFAULT_X_SEARCH_MODEL,
+	hint: "default · fast, no reasoning"
+}, {
+	value: "grok-4-1-fast",
+	label: "grok-4-1-fast",
+	hint: "fast with reasoning"
+}];
+function resolveXSearchConfigRecord(config) {
+	return resolveEffectiveXSearchConfig(config);
+}
+async function runXaiSearchProviderSetup(ctx) {
+	const existingXSearch = resolveXSearchConfigRecord(ctx.config);
+	if (existingXSearch?.enabled === false) return ctx.config;
+	await ctx.prompter.note([
+		"x_search lets your agent search X (formerly Twitter) posts via xAI.",
+		"It reuses the same xAI API key you just configured for Grok web search.",
+		`You can change this later with ${formatCliCommand("kaijibot configure --section web")}.`
+	].join("\n"), "X search");
+	if (await ctx.prompter.select({
+		message: "Enable x_search too?",
+		options: [{
+			value: "yes",
+			label: "Yes, enable x_search",
+			hint: "Search X posts with the same xAI key"
+		}, {
+			value: "skip",
+			label: "Skip for now",
+			hint: "Keep Grok web_search only"
+		}],
+		initialValue: existingXSearch?.enabled === true || ctx.quickstartDefaults ? "yes" : "skip"
+	}) === "skip") return ctx.config;
+	const existingModel = typeof existingXSearch?.model === "string" && existingXSearch.model.trim() ? existingXSearch.model.trim() : "";
+	const knownModel = X_SEARCH_MODEL_OPTIONS.find((entry) => entry.value === existingModel)?.value;
+	const modelPick = await ctx.prompter.select({
+		message: "Grok model for x_search",
+		options: [...X_SEARCH_MODEL_OPTIONS, {
+			value: "__custom__",
+			label: "Enter custom model name",
+			hint: ""
+		}],
+		initialValue: knownModel ?? "grok-4-1-fast-non-reasoning"
+	});
+	let model = modelPick;
+	if (modelPick === "__custom__") model = (await ctx.prompter.text({
+		message: "Custom Grok model name",
+		initialValue: existingModel || "grok-4-1-fast-non-reasoning",
+		placeholder: "grok-4-1-fast-non-reasoning"
+	})).trim() || "grok-4-1-fast-non-reasoning";
+	const next = structuredClone(ctx.config);
+	setPluginXSearchConfigValue(next, "enabled", true);
+	setPluginXSearchConfigValue(next, "model", model || "grok-4-1-fast-non-reasoning");
+	return next;
+}
+function runXaiWebSearch(params) {
+	const cacheKey = normalizeCacheKey(`grok:${params.model}:${String(params.inlineCitations)}:${params.query}`);
+	const cached = readCache(XAI_WEB_SEARCH_CACHE, cacheKey);
+	if (cached) return Promise.resolve({
+		...cached.value,
+		cached: true
+	});
+	return (async () => {
+		const startedAt = Date.now();
+		const result = await requestXaiWebSearch({
+			query: params.query,
+			model: params.model,
+			apiKey: params.apiKey,
+			timeoutSeconds: params.timeoutSeconds,
+			inlineCitations: params.inlineCitations
+		});
+		const payload = buildXaiWebSearchPayload({
+			query: params.query,
+			provider: "grok",
+			model: params.model,
+			tookMs: Date.now() - startedAt,
+			content: result.content,
+			citations: result.citations,
+			inlineCitations: result.inlineCitations
+		});
+		writeCache(XAI_WEB_SEARCH_CACHE, cacheKey, payload, params.cacheTtlMs);
+		return payload;
+	})();
+}
+function resolveXaiToolSearchConfig(ctx) {
+	return mergeScopedSearchConfig(ctx.searchConfig, "grok", resolveProviderWebSearchPluginConfig(ctx.config, "xai"));
+}
+function resolveXaiWebSearchCredential(searchConfig) {
+	return resolveWebSearchProviderCredential({
+		credentialValue: getScopedCredentialValue(searchConfig, "grok"),
+		path: "tools.web.search.grok.apiKey",
+		envVars: ["XAI_API_KEY"]
+	});
+}
+function createXaiWebSearchProvider() {
+	return {
+		id: "grok",
+		label: "Grok (xAI)",
+		hint: "Requires xAI API key · xAI web-grounded responses",
+		onboardingScopes: ["text-inference"],
+		credentialLabel: "xAI API key",
+		envVars: ["XAI_API_KEY"],
+		placeholder: "xai-...",
+		signupUrl: "https://console.x.ai/",
+		docsUrl: "https://gitee.com/kaiji1126/kaijibot/blob/main/docs/tools/web.md",
+		autoDetectOrder: 30,
+		credentialPath: "plugins.entries.xai.config.webSearch.apiKey",
+		inactiveSecretPaths: ["plugins.entries.xai.config.webSearch.apiKey"],
+		getCredentialValue: (searchConfig) => getScopedCredentialValue(searchConfig, "grok"),
+		setCredentialValue: (searchConfigTarget, value) => setScopedCredentialValue(searchConfigTarget, "grok", value),
+		getConfiguredCredentialValue: (config) => resolveProviderWebSearchPluginConfig(config, "xai")?.apiKey,
+		setConfiguredCredentialValue: (configTarget, value) => {
+			setProviderWebSearchPluginConfigValue(configTarget, "xai", "apiKey", value);
+		},
+		runSetup: runXaiSearchProviderSetup,
+		createTool: (ctx) => {
+			const searchConfig = resolveXaiToolSearchConfig(ctx);
+			return {
+				description: "Search the web using xAI Grok. Returns AI-synthesized answers with citations from real-time web search.",
+				parameters: Type.Object({
+					query: Type.String({ description: "Search query string." }),
+					count: Type.Optional(Type.Number({
+						description: "Number of results to return (1-10).",
+						minimum: 1,
+						maximum: 10
+					}))
+				}),
+				execute: async (args) => {
+					const apiKey = resolveXaiWebSearchCredential(searchConfig);
+					if (!apiKey) return {
+						error: "missing_xai_api_key",
+						message: "web_search (grok) needs an xAI API key. Set XAI_API_KEY in the Gateway environment, or configure plugins.entries.xai.config.webSearch.apiKey.",
+						docs: "https://gitee.com/kaiji1126/kaijibot/blob/main/docs/tools/web.md"
+					};
+					const query = readStringParam(args, "query", { required: true });
+					readNumberParam(args, "count", { integer: true });
+					return await runXaiWebSearch({
+						query,
+						model: resolveXaiWebSearchModel(searchConfig),
+						apiKey,
+						timeoutSeconds: resolveTimeoutSeconds(searchConfig?.timeoutSeconds, 30),
+						inlineCitations: resolveXaiInlineCitations(searchConfig),
+						cacheTtlMs: resolveCacheTtlMs(searchConfig?.cacheTtlMinutes, 15)
+					});
+				}
+			};
+		}
+	};
+}
+const __testing = {
+	buildXaiWebSearchPayload,
+	extractXaiWebSearchContent,
+	resolveXaiToolSearchConfig,
+	resolveXaiInlineCitations,
+	resolveXaiWebSearchCredential,
+	resolveXaiWebSearchModel,
+	requestXaiWebSearch
+};
+//#endregion
+export { createXaiWebSearchProvider as n, __testing as t };

package/dist/web-search-provider-BpVY1JYn.js

@@ -0,0 +1,155 @@
+import { s as normalizeOptionalString } from "./string-coerce-CIT1-v_a.js";
+import { t as normalizeOptionalSecretInput } from "./normalize-secret-input-Cwg-vdk5.js";
+import { u as isNonSecretApiKeyMarker } from "./model-auth-markers-CvwYPdtC.js";
+import { t as resolveEnvApiKey } from "./model-auth-env-D8uPsDyE.js";
+import { d as readNumberParam, h as readStringParam } from "./common-BqLAxNEk.js";
+import { n as fetchWithSsrFGuard } from "./fetch-guard-C-WK6ARz.js";
+import { c as wrapWebContent } from "./external-content-86L9qJa0.js";
+import { _ as truncateText, a as readResponseText } from "./web-shared-DBF1sNoo.js";
+import { _ as resolveSiteName, h as resolveSearchCount } from "./web-search-provider-common-Bg1Lk697.js";
+import "./ssrf-runtime-BX8d4bG0.js";
+import "./text-runtime-CNganbWZ.js";
+import "./provider-auth-6QHap3yT.js";
+import "./provider-auth-runtime-B0BCXRMS.js";
+import { t as enablePluginInConfig } from "./enable-BS5KUlHI.js";
+import "./provider-web-search-DFv7Pi_E.js";
+import { c as resolveOllamaApiBase, i as fetchOllamaModels, l as OLLAMA_DEFAULT_BASE_URL, t as buildOllamaBaseUrlSsrFPolicy } from "./provider-models-BrE46jCo2.js";
+import { n as checkOllamaCloudAuth } from "./setup-DAJzkyY_.js";
+import { Type } from "typebox";
+//#region extensions/ollama/src/web-search-provider.ts
+const OLLAMA_WEB_SEARCH_SCHEMA = Type.Object({
+	query: Type.String({ description: "Search query string." }),
+	count: Type.Optional(Type.Number({
+		description: "Number of results to return (1-10).",
+		minimum: 1,
+		maximum: 10
+	}))
+}, { additionalProperties: false });
+const OLLAMA_WEB_SEARCH_PATH = "/api/experimental/web_search";
+const DEFAULT_OLLAMA_WEB_SEARCH_COUNT = 5;
+const DEFAULT_OLLAMA_WEB_SEARCH_TIMEOUT_MS = 15e3;
+const OLLAMA_WEB_SEARCH_SNIPPET_MAX_CHARS = 300;
+function resolveOllamaWebSearchApiKey(config) {
+	const providerApiKey = normalizeOptionalSecretInput(config?.models?.providers?.ollama?.apiKey);
+	if (providerApiKey && !isNonSecretApiKeyMarker(providerApiKey)) return providerApiKey;
+	return resolveEnvApiKey("ollama")?.apiKey;
+}
+function resolveOllamaWebSearchBaseUrl(config) {
+	const configuredBaseUrl = config?.models?.providers?.ollama?.baseUrl;
+	if (normalizeOptionalString(configuredBaseUrl)) return resolveOllamaApiBase(configuredBaseUrl);
+	return OLLAMA_DEFAULT_BASE_URL;
+}
+function normalizeOllamaWebSearchResult(result) {
+	const url = normalizeOptionalString(result.url) ?? "";
+	if (!url) return null;
+	return {
+		title: normalizeOptionalString(result.title) ?? "",
+		url,
+		content: normalizeOptionalString(result.content) ?? ""
+	};
+}
+async function runOllamaWebSearch(params) {
+	const query = params.query.trim();
+	if (!query) throw new Error("query parameter is required");
+	const baseUrl = resolveOllamaWebSearchBaseUrl(params.config);
+	const apiKey = resolveOllamaWebSearchApiKey(params.config);
+	const count = resolveSearchCount(params.count, DEFAULT_OLLAMA_WEB_SEARCH_COUNT);
+	const startedAt = Date.now();
+	const headers = { "Content-Type": "application/json" };
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	const { response, release } = await fetchWithSsrFGuard({
+		url: `${baseUrl}${OLLAMA_WEB_SEARCH_PATH}`,
+		init: {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				query,
+				max_results: count
+			}),
+			signal: AbortSignal.timeout(DEFAULT_OLLAMA_WEB_SEARCH_TIMEOUT_MS)
+		},
+		policy: buildOllamaBaseUrlSsrFPolicy(baseUrl),
+		auditContext: "ollama-web-search.search"
+	});
+	try {
+		if (response.status === 401) throw new Error("Ollama web search authentication failed. Run `ollama signin`.");
+		if (response.status === 403) throw new Error("Ollama web search is unavailable. Ensure cloud-backed web search is enabled on the Ollama host.");
+		if (!response.ok) {
+			const detail = await readResponseText(response, { maxBytes: 64e3 });
+			throw new Error(`Ollama web search failed (${response.status}): ${detail.text || ""}`.trim());
+		}
+		const payload = await response.json();
+		const results = Array.isArray(payload.results) ? payload.results.map(normalizeOllamaWebSearchResult).filter((result) => result !== null).slice(0, count) : [];
+		return {
+			query,
+			provider: "ollama",
+			count: results.length,
+			tookMs: Date.now() - startedAt,
+			externalContent: {
+				untrusted: true,
+				source: "web_search",
+				provider: "ollama",
+				wrapped: true
+			},
+			results: results.map((result) => {
+				const snippet = truncateText(result.content, OLLAMA_WEB_SEARCH_SNIPPET_MAX_CHARS).text;
+				return {
+					title: result.title ? wrapWebContent(result.title, "web_search") : "",
+					url: result.url,
+					snippet: snippet ? wrapWebContent(snippet, "web_search") : "",
+					siteName: resolveSiteName(result.url) || void 0
+				};
+			})
+		};
+	} finally {
+		await release();
+	}
+}
+async function warnOllamaWebSearchPrereqs(params) {
+	const baseUrl = resolveOllamaWebSearchBaseUrl(params.config);
+	const { reachable } = await fetchOllamaModels(baseUrl);
+	if (!reachable) {
+		await params.prompter.note([
+			"Ollama Web Search requires Ollama to be running.",
+			`Expected host: ${baseUrl}`,
+			"Start Ollama before using this provider."
+		].join("\n"), "Ollama Web Search");
+		return params.config;
+	}
+	const auth = await checkOllamaCloudAuth(baseUrl);
+	if (!auth.signedIn) await params.prompter.note(["Ollama Web Search requires `ollama signin`.", ...auth.signinUrl ? [auth.signinUrl] : ["Run `ollama signin`."]].join("\n"), "Ollama Web Search");
+	return params.config;
+}
+function createOllamaWebSearchProvider() {
+	return {
+		id: "ollama",
+		label: "Ollama Web Search",
+		hint: "Local Ollama host · requires ollama signin",
+		onboardingScopes: ["text-inference"],
+		requiresCredential: false,
+		envVars: [],
+		placeholder: "(run ollama signin)",
+		signupUrl: "https://ollama.com/",
+		docsUrl: "https://gitee.com/kaiji1126/kaijibot/blob/main/docs/tools/web.md",
+		autoDetectOrder: 110,
+		credentialPath: "",
+		getCredentialValue: () => void 0,
+		setCredentialValue: () => {},
+		applySelectionConfig: (config) => enablePluginInConfig(config, "ollama").config,
+		runSetup: async (ctx) => await warnOllamaWebSearchPrereqs({
+			config: ctx.config,
+			prompter: ctx.prompter
+		}),
+		createTool: (ctx) => ({
+			description: "Search the web using Ollama's experimental web search API. Returns titles, URLs, and snippets from the configured Ollama host.",
+			parameters: OLLAMA_WEB_SEARCH_SCHEMA,
+			execute: async (args) => await runOllamaWebSearch({
+				config: ctx.config,
+				query: readStringParam(args, "query", { required: true }),
+				count: readNumberParam(args, "count", { integer: true })
+			})
+		})
+	};
+}
+//#endregion
+export { createOllamaWebSearchProvider as t };