kaijibot 2026.8.21 → 2026.8.23

package/dist/video-generation-provider-Z-xZjApd.js

@@ -0,0 +1,240 @@
+import { s as normalizeOptionalString } from "./string-coerce-xZwG7Dq8.js";
+import { r as fetchWithTimeout } from "./fetch-timeout-BCovYv8d.js";
+import { o as resolveProviderHttpRequestConfig, r as postJsonRequest, t as assertOkOrThrowHttpError } from "./shared-BAqqhcWT.js";
+import "./text-runtime-B3UrMt6T.js";
+import "./provider-http-CHFd_hrC.js";
+import { t as isProviderApiKeyConfigured } from "./provider-auth-B0NxCABI.js";
+import { n as resolveApiKeyForProvider } from "./provider-auth-runtime-p93v7b23.js";
+//#region extensions/xai/video-generation-provider.ts
+const DEFAULT_XAI_VIDEO_BASE_URL = "https://api.x.ai/v1";
+const DEFAULT_XAI_VIDEO_MODEL = "grok-imagine-video";
+const DEFAULT_TIMEOUT_MS = 12e4;
+const POLL_INTERVAL_MS = 5e3;
+const MAX_POLL_ATTEMPTS = 120;
+const XAI_VIDEO_ASPECT_RATIOS = new Set([
+	"1:1",
+	"16:9",
+	"9:16",
+	"4:3",
+	"3:4",
+	"3:2",
+	"2:3"
+]);
+function resolveXaiVideoBaseUrl(req) {
+	return normalizeOptionalString(req.cfg?.models?.providers?.xai?.baseUrl) ?? DEFAULT_XAI_VIDEO_BASE_URL;
+}
+function toDataUrl(buffer, mimeType) {
+	return `data:${mimeType};base64,${buffer.toString("base64")}`;
+}
+function resolveImageUrl(input) {
+	if (!input) return;
+	const inputUrl = normalizeOptionalString(input.url);
+	if (inputUrl) return inputUrl;
+	if (!input.buffer) throw new Error("xAI image-to-video input is missing image data.");
+	return toDataUrl(input.buffer, normalizeOptionalString(input.mimeType) ?? "image/png");
+}
+function resolveInputVideoUrl(input) {
+	if (!input) return;
+	const url = normalizeOptionalString(input.url);
+	if (url) return url;
+	if (input.buffer) throw new Error("xAI video editing currently requires a remote mp4 URL input.");
+	throw new Error("xAI video editing input is missing video data.");
+}
+function resolveDurationSeconds(params) {
+	if (typeof params.durationSeconds !== "number" || !Number.isFinite(params.durationSeconds)) return;
+	const rounded = Math.round(params.durationSeconds);
+	return Math.max(params.min ?? 1, Math.min(params.max ?? 15, rounded));
+}
+function resolveAspectRatio(value) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed || !XAI_VIDEO_ASPECT_RATIOS.has(trimmed)) return;
+	return trimmed;
+}
+function resolveResolution(value) {
+	if (value === "480P") return "480p";
+	if (value === "720P" || value === "1080P") return "720p";
+}
+function resolveXaiVideoMode(req) {
+	if (!((req.inputVideos?.length ?? 0) > 0)) return "generate";
+	return typeof resolveDurationSeconds({
+		durationSeconds: req.durationSeconds,
+		min: 2,
+		max: 10
+	}) === "number" ? "extend" : "edit";
+}
+function buildCreateBody(req) {
+	if ((req.inputImages?.length ?? 0) > 1) throw new Error("xAI video generation supports at most one reference image.");
+	if ((req.inputVideos?.length ?? 0) > 1) throw new Error("xAI video generation supports at most one input video.");
+	if ((req.inputImages?.length ?? 0) > 0 && (req.inputVideos?.length ?? 0) > 0) throw new Error("xAI video generation does not support image and video inputs together.");
+	const mode = resolveXaiVideoMode(req);
+	const body = {
+		model: normalizeOptionalString(req.model) ?? DEFAULT_XAI_VIDEO_MODEL,
+		prompt: req.prompt
+	};
+	if (mode === "generate") {
+		const imageUrl = resolveImageUrl(req.inputImages?.[0]);
+		if (imageUrl) body.image = { url: imageUrl };
+		const duration = resolveDurationSeconds({
+			durationSeconds: req.durationSeconds,
+			min: 1,
+			max: 15
+		});
+		if (typeof duration === "number") body.duration = duration;
+		const aspectRatio = resolveAspectRatio(req.aspectRatio);
+		if (aspectRatio) body.aspect_ratio = aspectRatio;
+		const resolution = resolveResolution(req.resolution);
+		if (resolution) body.resolution = resolution;
+		return body;
+	}
+	body.video = { url: resolveInputVideoUrl(req.inputVideos?.[0]) };
+	if (mode === "extend") {
+		const duration = resolveDurationSeconds({
+			durationSeconds: req.durationSeconds,
+			min: 2,
+			max: 10
+		});
+		if (typeof duration === "number") body.duration = duration;
+	}
+	return body;
+}
+function resolveCreateEndpoint(req) {
+	switch (resolveXaiVideoMode(req)) {
+		case "edit": return "/videos/edits";
+		case "extend": return "/videos/extensions";
+		default: return "/videos/generations";
+	}
+}
+async function pollXaiVideo(params) {
+	for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt += 1) {
+		const response = await fetchWithTimeout(`${params.baseUrl}/videos/${params.requestId}`, {
+			method: "GET",
+			headers: params.headers
+		}, params.timeoutMs ?? DEFAULT_TIMEOUT_MS, params.fetchFn);
+		await assertOkOrThrowHttpError(response, "xAI video status request failed");
+		const payload = await response.json();
+		switch (payload.status) {
+			case "done": return payload;
+			case "failed":
+			case "expired": throw new Error(normalizeOptionalString(payload.error?.message) ?? `xAI video generation ${payload.status}`);
+			default:
+				await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+				break;
+		}
+	}
+	throw new Error(`xAI video generation task ${params.requestId} did not finish in time`);
+}
+async function downloadXaiVideo(params) {
+	const response = await fetchWithTimeout(params.url, { method: "GET" }, params.timeoutMs ?? DEFAULT_TIMEOUT_MS, params.fetchFn);
+	await assertOkOrThrowHttpError(response, "xAI generated video download failed");
+	const mimeType = normalizeOptionalString(response.headers.get("content-type")) ?? "video/mp4";
+	const arrayBuffer = await response.arrayBuffer();
+	return {
+		buffer: Buffer.from(arrayBuffer),
+		mimeType,
+		fileName: `video-1.${mimeType.includes("webm") ? "webm" : "mp4"}`
+	};
+}
+function buildXaiVideoGenerationProvider() {
+	return {
+		id: "xai",
+		label: "xAI",
+		defaultModel: DEFAULT_XAI_VIDEO_MODEL,
+		models: [DEFAULT_XAI_VIDEO_MODEL],
+		isConfigured: ({ agentDir }) => isProviderApiKeyConfigured({
+			provider: "xai",
+			agentDir
+		}),
+		capabilities: {
+			generate: {
+				maxVideos: 1,
+				maxDurationSeconds: 15,
+				aspectRatios: [...XAI_VIDEO_ASPECT_RATIOS],
+				resolutions: ["480P", "720P"],
+				supportsAspectRatio: true,
+				supportsResolution: true
+			},
+			imageToVideo: {
+				enabled: true,
+				maxVideos: 1,
+				maxInputImages: 1,
+				maxDurationSeconds: 15,
+				aspectRatios: [...XAI_VIDEO_ASPECT_RATIOS],
+				resolutions: ["480P", "720P"],
+				supportsAspectRatio: true,
+				supportsResolution: true
+			},
+			videoToVideo: {
+				enabled: true,
+				maxVideos: 1,
+				maxInputVideos: 1,
+				maxDurationSeconds: 15,
+				supportsAspectRatio: true,
+				supportsResolution: true
+			}
+		},
+		async generateVideo(req) {
+			const auth = await resolveApiKeyForProvider({
+				provider: "xai",
+				cfg: req.cfg,
+				agentDir: req.agentDir,
+				store: req.authStore
+			});
+			if (!auth.apiKey) throw new Error("xAI API key missing");
+			const fetchFn = fetch;
+			const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+				baseUrl: resolveXaiVideoBaseUrl(req),
+				defaultBaseUrl: DEFAULT_XAI_VIDEO_BASE_URL,
+				allowPrivateNetwork: false,
+				defaultHeaders: {
+					Authorization: `Bearer ${auth.apiKey}`,
+					"Content-Type": "application/json"
+				},
+				provider: "xai",
+				capability: "video",
+				transport: "http"
+			});
+			const { response, release } = await postJsonRequest({
+				url: `${baseUrl}${resolveCreateEndpoint(req)}`,
+				headers,
+				body: buildCreateBody(req),
+				timeoutMs: req.timeoutMs,
+				fetchFn,
+				allowPrivateNetwork,
+				dispatcherPolicy
+			});
+			try {
+				await assertOkOrThrowHttpError(response, "xAI video generation failed");
+				const submitted = await response.json();
+				const requestId = normalizeOptionalString(submitted.request_id);
+				if (!requestId) throw new Error(normalizeOptionalString(submitted.error?.message) ?? "xAI video generation response missing request_id");
+				const completed = await pollXaiVideo({
+					requestId,
+					headers,
+					timeoutMs: req.timeoutMs,
+					baseUrl,
+					fetchFn
+				});
+				const videoUrl = normalizeOptionalString(completed.video?.url);
+				if (!videoUrl) throw new Error("xAI video generation completed without an output URL");
+				return {
+					videos: [await downloadXaiVideo({
+						url: videoUrl,
+						timeoutMs: req.timeoutMs,
+						fetchFn
+					})],
+					model: normalizeOptionalString(req.model) ?? DEFAULT_XAI_VIDEO_MODEL,
+					metadata: {
+						requestId,
+						status: completed.status,
+						videoUrl,
+						mode: resolveXaiVideoMode(req)
+					}
+				};
+			} finally {
+				await release();
+			}
+		}
+	};
+}
+//#endregion
+export { buildXaiVideoGenerationProvider as t };

package/dist/video-generation-provider-kfoZ8epM.js

@@ -0,0 +1,64 @@
+import { o as resolveProviderHttpRequestConfig } from "./shared-BAqqhcWT.js";
+import "./provider-http-CHFd_hrC.js";
+import { a as DEFAULT_VIDEO_GENERATION_TIMEOUT_MS, n as DASHSCOPE_WAN_VIDEO_MODELS, p as runDashscopeVideoGenerationTask, r as DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL, t as DASHSCOPE_WAN_VIDEO_CAPABILITIES } from "./video-generation-CksImGdK.js";
+import { t as isProviderApiKeyConfigured } from "./provider-auth-B0NxCABI.js";
+import { n as resolveApiKeyForProvider } from "./provider-auth-runtime-p93v7b23.js";
+//#region extensions/alibaba/video-generation-provider.ts
+const DEFAULT_ALIBABA_VIDEO_BASE_URL = "https://dashscope-intl.aliyuncs.com";
+const DEFAULT_ALIBABA_VIDEO_MODEL = DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL;
+function resolveAlibabaVideoBaseUrl(req) {
+	return req.cfg?.models?.providers?.alibaba?.baseUrl?.trim() || DEFAULT_ALIBABA_VIDEO_BASE_URL;
+}
+function resolveDashscopeAigcApiBaseUrl(baseUrl) {
+	return baseUrl.replace(/\/+$/u, "");
+}
+function buildAlibabaVideoGenerationProvider() {
+	return {
+		id: "alibaba",
+		label: "Alibaba Model Studio",
+		defaultModel: DEFAULT_ALIBABA_VIDEO_MODEL,
+		models: [...DASHSCOPE_WAN_VIDEO_MODELS],
+		isConfigured: ({ agentDir }) => isProviderApiKeyConfigured({
+			provider: "alibaba",
+			agentDir
+		}),
+		capabilities: DASHSCOPE_WAN_VIDEO_CAPABILITIES,
+		async generateVideo(req) {
+			const fetchFn = fetch;
+			const auth = await resolveApiKeyForProvider({
+				provider: "alibaba",
+				cfg: req.cfg,
+				agentDir: req.agentDir,
+				store: req.authStore
+			});
+			if (!auth.apiKey) throw new Error("Alibaba Model Studio API key missing");
+			const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+				baseUrl: resolveAlibabaVideoBaseUrl(req),
+				defaultBaseUrl: DEFAULT_ALIBABA_VIDEO_BASE_URL,
+				defaultHeaders: {
+					Authorization: `Bearer ${auth.apiKey}`,
+					"Content-Type": "application/json",
+					"X-DashScope-Async": "enable"
+				},
+				provider: "alibaba",
+				capability: "video",
+				transport: "http"
+			});
+			return await runDashscopeVideoGenerationTask({
+				providerLabel: "Alibaba Wan",
+				model: req.model?.trim() || DEFAULT_ALIBABA_VIDEO_MODEL,
+				req,
+				url: `${resolveDashscopeAigcApiBaseUrl(baseUrl)}/api/v1/services/aigc/video-generation/video-synthesis`,
+				headers,
+				baseUrl: resolveDashscopeAigcApiBaseUrl(baseUrl),
+				timeoutMs: req.timeoutMs,
+				fetchFn,
+				allowPrivateNetwork,
+				dispatcherPolicy,
+				defaultTimeoutMs: DEFAULT_VIDEO_GENERATION_TIMEOUT_MS
+			});
+		}
+	};
+}
+//#endregion
+export { buildAlibabaVideoGenerationProvider as t };

package/dist/video-generation-provider-wgwFq2Wr.js

@@ -0,0 +1,77 @@
+import { o as resolveProviderHttpRequestConfig } from "./shared-BAqqhcWT.js";
+import "./provider-http-CHFd_hrC.js";
+import { a as DEFAULT_VIDEO_GENERATION_TIMEOUT_MS, n as DASHSCOPE_WAN_VIDEO_MODELS, p as runDashscopeVideoGenerationTask, r as DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL, t as DASHSCOPE_WAN_VIDEO_CAPABILITIES } from "./video-generation-CksImGdK.js";
+import { t as isProviderApiKeyConfigured } from "./provider-auth-B0NxCABI.js";
+import { n as resolveApiKeyForProvider } from "./provider-auth-runtime-p93v7b23.js";
+import "./models-D_V6hTy-.js";
+//#region extensions/qwen/video-generation-provider.ts
+const DEFAULT_QWEN_VIDEO_BASE_URL = "https://dashscope-intl.aliyuncs.com";
+const DEFAULT_QWEN_VIDEO_MODEL = DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL;
+function resolveQwenVideoBaseUrl(req) {
+	const direct = req.cfg?.models?.providers?.qwen?.baseUrl?.trim();
+	if (!direct) return DEFAULT_QWEN_VIDEO_BASE_URL;
+	try {
+		return new URL(direct).toString();
+	} catch {
+		return DEFAULT_QWEN_VIDEO_BASE_URL;
+	}
+}
+function resolveDashscopeAigcApiBaseUrl(baseUrl) {
+	try {
+		const url = new URL(baseUrl);
+		if (url.hostname === "coding-intl.dashscope.aliyuncs.com" || url.hostname === "coding.dashscope.aliyuncs.com" || url.hostname === "dashscope-intl.aliyuncs.com" || url.hostname === "dashscope.aliyuncs.com") return url.origin;
+	} catch {}
+	if (baseUrl.startsWith("https://dashscope.aliyuncs.com/compatible-mode/v1")) return "https://dashscope.aliyuncs.com";
+	if (baseUrl.startsWith("https://dashscope-intl.aliyuncs.com/compatible-mode/v1")) return DEFAULT_QWEN_VIDEO_BASE_URL;
+	return baseUrl.replace(/\/+$/u, "");
+}
+function buildQwenVideoGenerationProvider() {
+	return {
+		id: "qwen",
+		label: "Qwen Cloud",
+		defaultModel: DEFAULT_QWEN_VIDEO_MODEL,
+		models: [...DASHSCOPE_WAN_VIDEO_MODELS],
+		isConfigured: ({ agentDir }) => isProviderApiKeyConfigured({
+			provider: "qwen",
+			agentDir
+		}),
+		capabilities: DASHSCOPE_WAN_VIDEO_CAPABILITIES,
+		async generateVideo(req) {
+			const fetchFn = fetch;
+			const auth = await resolveApiKeyForProvider({
+				provider: "qwen",
+				cfg: req.cfg,
+				agentDir: req.agentDir,
+				store: req.authStore
+			});
+			if (!auth.apiKey) throw new Error("Qwen API key missing");
+			const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+				baseUrl: resolveQwenVideoBaseUrl(req),
+				defaultBaseUrl: DEFAULT_QWEN_VIDEO_BASE_URL,
+				defaultHeaders: {
+					Authorization: `Bearer ${auth.apiKey}`,
+					"Content-Type": "application/json",
+					"X-DashScope-Async": "enable"
+				},
+				provider: "qwen",
+				capability: "video",
+				transport: "http"
+			});
+			return await runDashscopeVideoGenerationTask({
+				providerLabel: "Qwen",
+				model: req.model?.trim() || DEFAULT_QWEN_VIDEO_MODEL,
+				req,
+				url: `${resolveDashscopeAigcApiBaseUrl(baseUrl)}/api/v1/services/aigc/video-generation/video-synthesis`,
+				headers,
+				baseUrl: resolveDashscopeAigcApiBaseUrl(baseUrl),
+				timeoutMs: req.timeoutMs,
+				fetchFn,
+				allowPrivateNetwork,
+				dispatcherPolicy,
+				defaultTimeoutMs: DEFAULT_VIDEO_GENERATION_TIMEOUT_MS
+			});
+		}
+	};
+}
+//#endregion
+export { buildQwenVideoGenerationProvider as t };

package/dist/web-fetch-providers.runtime-YHUYJGZL.js

@@ -0,0 +1,33 @@
+import { a as mapRegistryProviders, s as resolveManifestDeclaredWebProviderCandidatePluginIds } from "./web-search-providers.shared-Xt40bzDW.js";
+import { n as sortWebFetchProviders, t as resolveBundledWebFetchResolutionConfig } from "./web-fetch-providers.shared-BsJEWJjG.js";
+import { i as resolvePluginWebProviders, r as createWebProviderSnapshotCache } from "./web-search-providers.runtime-BxK0HVx5.js";
+//#region src/plugins/web-fetch-providers.runtime.ts
+let webFetchProviderSnapshotCache = createWebProviderSnapshotCache();
+function resolveWebFetchCandidatePluginIds(params) {
+	return resolveManifestDeclaredWebProviderCandidatePluginIds({
+		contract: "webFetchProviders",
+		configKey: "webFetch",
+		config: params.config,
+		workspaceDir: params.workspaceDir,
+		env: params.env,
+		onlyPluginIds: params.onlyPluginIds,
+		origin: params.origin
+	});
+}
+function mapRegistryWebFetchProviders(params) {
+	return mapRegistryProviders({
+		entries: params.registry.webFetchProviders,
+		onlyPluginIds: params.onlyPluginIds,
+		sortProviders: sortWebFetchProviders
+	});
+}
+function resolvePluginWebFetchProviders(params) {
+	return resolvePluginWebProviders(params, {
+		snapshotCache: webFetchProviderSnapshotCache,
+		resolveBundledResolutionConfig: resolveBundledWebFetchResolutionConfig,
+		resolveCandidatePluginIds: resolveWebFetchCandidatePluginIds,
+		mapRegistryProviders: mapRegistryWebFetchProviders
+	});
+}
+//#endregion
+export { resolvePluginWebFetchProviders as t };

package/dist/web-fetch-providers.runtime.js

@@ -1 +1 @@
-export * from "./web-fetch-providers.runtime-m66rypbB.js";
+export * from "./web-fetch-providers.runtime-YHUYJGZL.js";

package/dist/web-search-C0DUuJkz.js

@@ -0,0 +1,221 @@
+import { l as isRecord } from "./utils-C8dt4mi-.js";
+import { t as formatCliCommand } from "./command-format-BZyfOXIE.js";
+import { d as readNumberParam, h as readStringParam } from "./common-Dw8lgI2P.js";
+import { c as wrapWebContent } from "./external-content-lXsoko3R.js";
+import { i as readCache, l as writeCache, o as resolveCacheTtlMs, r as normalizeCacheKey, s as resolveTimeoutSeconds } from "./web-shared--44LWgiH.js";
+import { u as postTrustedWebToolsJson } from "./web-search-provider-common-B9jozd8T.js";
+import { a as setProviderWebSearchPluginConfigValue, i as resolveProviderWebSearchPluginConfig, o as setScopedCredentialValue, r as mergeScopedSearchConfig, t as getScopedCredentialValue } from "./web-search-provider-config-DCqeS6ct.js";
+import { n as resolveWebSearchProviderCredential } from "./provider-web-search-CyGNmODH.js";
+import { t as normalizeXaiModelId } from "./model-id-josvS7_f.js";
+import "./tool-config-shared-CThVi2Zv.js";
+import { c as setPluginXSearchConfigValue, s as resolveEffectiveXSearchConfig, t as XAI_DEFAULT_X_SEARCH_MODEL } from "./x-search-shared-uvKOvvdl.js";
+import { a as resolveXaiResponseTextCitationsAndInline, n as buildXaiResponsesToolBody, r as extractXaiWebSearchContent, t as XAI_RESPONSES_ENDPOINT } from "./responses-tool-shared-Bp63wGvZ.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 };