@openclaw/moonshot-provider 0.0.0 → 2026.6.11-beta.2

package/README.md

@@ -1,3 +1,13 @@
-# @openclaw/moonshot-provider
+# Moonshot OpenClaw provider
 
-Bootstrap reservation for the OpenClaw Moonshot provider package.
+Official OpenClaw provider plugin for Moonshot.
+
+## Install
+
+```sh
+openclaw plugins install @openclaw/moonshot-provider
+```
+
+## Docs
+
+See `docs/providers/moonshot.md` in the OpenClaw repository, or the published docs at `https://docs.openclaw.ai/providers/moonshot`.

package/dist/api.js

@@ -0,0 +1,3 @@
+import { a as buildMoonshotProvider, i as applyMoonshotNativeStreamingUsageCompat, n as MOONSHOT_CN_BASE_URL, o as isNativeMoonshotBaseUrl, r as MOONSHOT_DEFAULT_MODEL_ID, t as MOONSHOT_BASE_URL } from "./provider-catalog-BGSHIo8D.js";
+import { MOONSHOT_DEFAULT_MODEL_REF } from "./onboard.js";
+export { MOONSHOT_BASE_URL, MOONSHOT_CN_BASE_URL, MOONSHOT_DEFAULT_MODEL_ID, MOONSHOT_DEFAULT_MODEL_REF, applyMoonshotNativeStreamingUsageCompat, buildMoonshotProvider, isNativeMoonshotBaseUrl };

package/dist/index.js

@@ -0,0 +1,67 @@
+import { a as buildMoonshotProvider, i as applyMoonshotNativeStreamingUsageCompat } from "./provider-catalog-BGSHIo8D.js";
+import { MOONSHOT_DEFAULT_MODEL_REF, applyMoonshotConfig, applyMoonshotConfigCn } from "./onboard.js";
+import "./api.js";
+import { moonshotMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { KIMI_K2_7_CODE_MODEL_ID, resolveThinkingProfile } from "./provider-policy-api.js";
+import { t as createKimiWebSearchProvider } from "./kimi-web-search-provider-pERL62H1.js";
+import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";
+import { buildOpenAICompatibleReplayPolicy } from "openclaw/plugin-sdk/provider-model-shared";
+import { MOONSHOT_THINKING_STREAM_HOOKS } from "openclaw/plugin-sdk/provider-stream-family";
+//#region extensions/moonshot/index.ts
+const PROVIDER_ID = "moonshot";
+const moonshotThinkingStreamHooks = MOONSHOT_THINKING_STREAM_HOOKS;
+var moonshot_default = defineSingleProviderPluginEntry({
+	id: PROVIDER_ID,
+	name: "Moonshot Provider",
+	description: "Bundled Moonshot provider plugin",
+	provider: {
+		label: "Moonshot",
+		docsPath: "/providers/moonshot",
+		aliases: ["moonshotai", "moonshot-ai"],
+		auth: [{
+			methodId: "api-key",
+			label: "Kimi API key (.ai)",
+			hint: "Kimi K2.6 + Kimi",
+			optionKey: "moonshotApiKey",
+			flagName: "--moonshot-api-key",
+			envVar: "MOONSHOT_API_KEY",
+			promptMessage: "Enter Moonshot API key",
+			defaultModel: MOONSHOT_DEFAULT_MODEL_REF,
+			applyConfig: (cfg) => applyMoonshotConfig(cfg),
+			wizard: { groupLabel: "Moonshot AI (Kimi K2.6)" }
+		}, {
+			methodId: "api-key-cn",
+			label: "Kimi API key (.cn)",
+			hint: "Kimi K2.6 + Kimi",
+			optionKey: "moonshotApiKey",
+			flagName: "--moonshot-api-key",
+			envVar: "MOONSHOT_API_KEY",
+			promptMessage: "Enter Moonshot API key (.cn)",
+			defaultModel: MOONSHOT_DEFAULT_MODEL_REF,
+			applyConfig: (cfg) => applyMoonshotConfigCn(cfg),
+			wizard: { groupLabel: "Moonshot AI (Kimi K2.6)" }
+		}],
+		catalog: {
+			buildProvider: buildMoonshotProvider,
+			buildStaticProvider: buildMoonshotProvider,
+			allowExplicitBaseUrl: true
+		},
+		applyNativeStreamingUsageCompat: ({ providerConfig }) => applyMoonshotNativeStreamingUsageCompat(providerConfig),
+		buildReplayPolicy: ({ modelApi, modelId }) => buildOpenAICompatibleReplayPolicy(modelApi, {
+			modelId,
+			sanitizeToolCallIds: modelApi === "openai-completions",
+			duplicateToolCallIdStyle: "openai",
+			dropReasoningFromHistory: false
+		}),
+		...moonshotThinkingStreamHooks,
+		wrapSimpleCompletionStreamFn: (ctx) => ctx.modelId.trim().toLowerCase() === "kimi-k2.7-code" ? moonshotThinkingStreamHooks.wrapStreamFn?.(ctx) : ctx.streamFn,
+		resolveThinkingProfile,
+		isModernModelRef: ({ modelId }) => modelId.trim().toLowerCase() === KIMI_K2_7_CODE_MODEL_ID
+	},
+	register(api) {
+		api.registerMediaUnderstandingProvider(moonshotMediaUnderstandingProvider);
+		api.registerWebSearchProvider(createKimiWebSearchProvider());
+	}
+});
+//#endregion
+export { moonshot_default as default };

package/dist/kimi-web-search-provider-pERL62H1.js

@@ -0,0 +1,80 @@
+import { createWebSearchProviderContractFields } from "openclaw/plugin-sdk/provider-web-search-config-contract";
+//#region extensions/moonshot/src/kimi-web-search-provider.ts
+const KIMI_CREDENTIAL_PATH = "plugins.entries.moonshot.config.webSearch.apiKey";
+let kimiWebSearchProviderRuntimePromise;
+function loadKimiWebSearchProviderRuntime() {
+	kimiWebSearchProviderRuntimePromise ??= import("./kimi-web-search-provider.runtime-DvaZLHkr.js");
+	return kimiWebSearchProviderRuntimePromise;
+}
+const KimiSearchSchema = {
+	type: "object",
+	properties: {
+		query: {
+			type: "string",
+			description: "Search query string."
+		},
+		count: {
+			type: "integer",
+			description: "Number of results to return (1-10).",
+			minimum: 1,
+			maximum: 10
+		},
+		country: {
+			type: "string",
+			description: "Not supported by Kimi."
+		},
+		language: {
+			type: "string",
+			description: "Not supported by Kimi."
+		},
+		freshness: {
+			type: "string",
+			description: "Not supported by Kimi."
+		},
+		date_after: {
+			type: "string",
+			description: "Not supported by Kimi."
+		},
+		date_before: {
+			type: "string",
+			description: "Not supported by Kimi."
+		}
+	}
+};
+async function runKimiSearchProviderSetup(ctx) {
+	return await (await loadKimiWebSearchProviderRuntime()).runKimiSearchProviderSetup(ctx);
+}
+function createKimiWebSearchProvider() {
+	return {
+		id: "kimi",
+		label: "Kimi (Moonshot)",
+		hint: "Requires Moonshot / Kimi API key · Moonshot web search",
+		onboardingScopes: ["text-inference"],
+		credentialLabel: "Moonshot / Kimi API key",
+		envVars: ["KIMI_API_KEY", "MOONSHOT_API_KEY"],
+		placeholder: "sk-...",
+		signupUrl: "https://platform.moonshot.cn/",
+		docsUrl: "https://docs.openclaw.ai/tools/web",
+		autoDetectOrder: 40,
+		credentialPath: KIMI_CREDENTIAL_PATH,
+		...createWebSearchProviderContractFields({
+			credentialPath: KIMI_CREDENTIAL_PATH,
+			searchCredential: {
+				type: "scoped",
+				scopeId: "kimi"
+			},
+			configuredCredential: { pluginId: "moonshot" }
+		}),
+		runSetup: runKimiSearchProviderSetup,
+		createTool: (ctx) => ({
+			description: "Search the web using Kimi by Moonshot. Returns AI-synthesized answers with citations from native $web_search.",
+			parameters: KimiSearchSchema,
+			execute: async (args) => {
+				const { executeKimiWebSearchProviderTool } = await loadKimiWebSearchProviderRuntime();
+				return await executeKimiWebSearchProviderTool(ctx, args);
+			}
+		})
+	};
+}
+//#endregion
+export { createKimiWebSearchProvider as t };

package/dist/kimi-web-search-provider.runtime-DvaZLHkr.js

@@ -0,0 +1,299 @@
+import { n as MOONSHOT_CN_BASE_URL, o as isNativeMoonshotBaseUrl, r as MOONSHOT_DEFAULT_MODEL_ID, t as MOONSHOT_BASE_URL } from "./provider-catalog-BGSHIo8D.js";
+import { createProviderHttpError, readProviderJsonObjectResponse } from "openclaw/plugin-sdk/provider-http";
+import { DEFAULT_SEARCH_COUNT, MAX_SEARCH_COUNT, buildSearchCacheKey, buildUnsupportedSearchFilterResponse, mergeScopedSearchConfig, readCachedSearchPayload, readConfiguredSecretString, readPositiveIntegerParam, readProviderEnvValue, readStringParam, resolveProviderWebSearchPluginConfig, resolveSearchCacheTtlMs, resolveSearchCount, resolveSearchTimeoutSeconds, setProviderWebSearchPluginConfigValue, withTrustedWebSearchEndpoint, wrapWebContent, writeCachedSearchPayload } from "openclaw/plugin-sdk/provider-web-search";
+import { isRecord, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/moonshot/src/kimi-web-search-provider.runtime.ts
+const DEFAULT_KIMI_BASE_URL = MOONSHOT_BASE_URL;
+const DEFAULT_KIMI_SEARCH_MODEL = MOONSHOT_DEFAULT_MODEL_ID;
+/** Models that require explicit thinking disablement for web search.
+* Reasoning variants (kimi-k2-thinking, kimi-k2-thinking-turbo) are excluded
+* because they default to thinking-enabled and disabling it would defeat their
+* purpose; they are also unlikely to be used for web search. */
+const KIMI_THINKING_MODELS = new Set(["kimi-k2.6", "kimi-k2.5"]);
+const KIMI_WEB_SEARCH_TOOL = {
+	type: "builtin_function",
+	function: { name: "$web_search" }
+};
+function throwMalformedKimiResponse() {
+	throw new Error("Kimi API error: malformed JSON response");
+}
+function resolveKimiConfig(searchConfig) {
+	const kimi = searchConfig?.kimi;
+	return kimi && typeof kimi === "object" && !Array.isArray(kimi) ? kimi : {};
+}
+function resolveKimiApiKey(kimi) {
+	return readConfiguredSecretString(kimi?.apiKey, "tools.web.search.kimi.apiKey") ?? readProviderEnvValue(["KIMI_API_KEY", "MOONSHOT_API_KEY"]);
+}
+function resolveKimiModel(kimi) {
+	return (normalizeOptionalString(kimi?.model) ?? "") || DEFAULT_KIMI_SEARCH_MODEL;
+}
+function trimTrailingSlashes(url) {
+	return url.replace(/\/+$/, "");
+}
+function resolveKimiBaseUrl(kimi, openClawConfig) {
+	const explicitBaseUrl = normalizeOptionalString(kimi?.baseUrl) ?? "";
+	if (explicitBaseUrl) return trimTrailingSlashes(explicitBaseUrl) || DEFAULT_KIMI_BASE_URL;
+	const moonshotBaseUrl = openClawConfig?.models?.providers?.moonshot?.baseUrl;
+	if (typeof moonshotBaseUrl === "string") {
+		const normalizedMoonshotBaseUrl = trimTrailingSlashes(moonshotBaseUrl.trim());
+		if (normalizedMoonshotBaseUrl && isNativeMoonshotBaseUrl(normalizedMoonshotBaseUrl)) return normalizedMoonshotBaseUrl;
+	}
+	return DEFAULT_KIMI_BASE_URL;
+}
+function extractKimiMessageText(message) {
+	const content = message?.content?.trim();
+	if (content) return content;
+	return message?.reasoning_content?.trim() || void 0;
+}
+function extractKimiCitations(data) {
+	const searchResults = data.search_results ?? [];
+	if (!Array.isArray(searchResults)) throwMalformedKimiResponse();
+	const citations = searchResults.map((entry) => isRecord(entry) && typeof entry.url === "string" ? entry.url.trim() : "").filter((url) => Boolean(url));
+	const choices = data.choices ?? [];
+	if (!Array.isArray(choices)) throwMalformedKimiResponse();
+	const firstChoice = choices[0];
+	const toolCalls = (firstChoice && isRecord(firstChoice.message) ? firstChoice.message : void 0)?.tool_calls ?? [];
+	if (!Array.isArray(toolCalls)) throwMalformedKimiResponse();
+	for (const toolCall of toolCalls) {
+		if (!isRecord(toolCall) || !isRecord(toolCall.function)) continue;
+		const rawArguments = toolCall.function.arguments;
+		if (typeof rawArguments !== "string" || !rawArguments) continue;
+		try {
+			const parsed = JSON.parse(rawArguments);
+			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 {}
+	}
+	return uniqueStrings(citations);
+}
+function hasKimiSearchResults(data) {
+	const searchResults = data.search_results ?? [];
+	if (!Array.isArray(searchResults)) throwMalformedKimiResponse();
+	return searchResults.some((entry) => isRecord(entry) && (Boolean(normalizeOptionalString(entry.url)) || Boolean(normalizeOptionalString(entry.title)) || Boolean(normalizeOptionalString(entry.content))));
+}
+function extractKimiToolResultContent(toolCall) {
+	const rawArguments = toolCall.function?.arguments;
+	if (typeof rawArguments !== "string" || rawArguments.trim().length === 0) return;
+	return rawArguments;
+}
+async function runKimiSearch(params) {
+	const endpoint = `${params.baseUrl.trim().replace(/\/$/, "")}/chat/completions`;
+	const messages = [{
+		role: "user",
+		content: params.query
+	}];
+	const collectedCitations = /* @__PURE__ */ new Set();
+	let hasGroundingEvidence = false;
+	for (let round = 0; round < 3; round += 1) {
+		const next = await withTrustedWebSearchEndpoint({
+			url: endpoint,
+			timeoutSeconds: params.timeoutSeconds,
+			init: {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${params.apiKey}`
+				},
+				body: JSON.stringify({
+					model: params.model,
+					...KIMI_THINKING_MODELS.has(params.model) ? { thinking: { type: "disabled" } } : {},
+					messages,
+					tools: [KIMI_WEB_SEARCH_TOOL]
+				})
+			}
+		}, async (res) => {
+			if (!res.ok) throw await createProviderHttpError(res, "Kimi API error");
+			const data = await readProviderJsonObjectResponse(res, "Kimi API error");
+			if (!Array.isArray(data.choices)) throwMalformedKimiResponse();
+			if (hasKimiSearchResults(data)) hasGroundingEvidence = true;
+			for (const citation of extractKimiCitations(data)) collectedCitations.add(citation);
+			if (collectedCitations.size > 0) hasGroundingEvidence = true;
+			const choice = data.choices?.[0];
+			if (!isRecord(choice) || !isRecord(choice.message)) throwMalformedKimiResponse();
+			const message = choice?.message;
+			const text = extractKimiMessageText(message);
+			const toolCalls = message?.tool_calls ?? [];
+			if (!Array.isArray(toolCalls)) throwMalformedKimiResponse();
+			if (choice?.finish_reason !== "tool_calls" || toolCalls.length === 0) {
+				if (!text) throwMalformedKimiResponse();
+				return {
+					done: true,
+					content: text,
+					citations: [...collectedCitations]
+				};
+			}
+			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 = extractKimiToolResultContent(toolCall);
+				if (!toolCallId || !toolCallName || !toolContent) continue;
+				if (toolCallName === KIMI_WEB_SEARCH_TOOL.function.name) hasGroundingEvidence = true;
+				pushed = true;
+				messages.push({
+					role: "tool",
+					tool_call_id: toolCallId,
+					name: toolCallName,
+					content: toolContent
+				});
+			}
+			if (!pushed) {
+				if (!text) throwMalformedKimiResponse();
+				return {
+					done: true,
+					content: text,
+					citations: [...collectedCitations]
+				};
+			}
+			return { done: false };
+		});
+		if (next.done) return {
+			content: next.content,
+			citations: next.citations,
+			grounded: hasGroundingEvidence
+		};
+	}
+	return {
+		content: "Search completed but no final answer was produced.",
+		citations: [...collectedCitations],
+		grounded: hasGroundingEvidence
+	};
+}
+async function executeKimiWebSearchProviderTool(ctx, args) {
+	const searchConfig = mergeScopedSearchConfig(ctx.searchConfig, "kimi", resolveProviderWebSearchPluginConfig(ctx.config, "moonshot"));
+	const unsupportedResponse = buildUnsupportedSearchFilterResponse(args, "kimi");
+	if (unsupportedResponse) return unsupportedResponse;
+	const kimiConfig = resolveKimiConfig(searchConfig);
+	const apiKey = resolveKimiApiKey(kimiConfig);
+	if (!apiKey) return {
+		error: "missing_kimi_api_key",
+		message: "web_search (kimi) needs a Moonshot API key. Set KIMI_API_KEY or MOONSHOT_API_KEY in the Gateway environment, or configure tools.web.search.kimi.apiKey. If you do not want to configure a search API key, use web_fetch for a specific URL or the browser tool for interactive pages.",
+		docs: "https://docs.openclaw.ai/tools/web"
+	};
+	const query = readStringParam(args, "query", { required: true });
+	const count = readPositiveIntegerParam(args, "count", {
+		max: MAX_SEARCH_COUNT,
+		message: `count must be an integer from 1 to ${MAX_SEARCH_COUNT}.`
+	}) ?? searchConfig?.maxResults ?? void 0;
+	const model = resolveKimiModel(kimiConfig);
+	const baseUrl = resolveKimiBaseUrl(kimiConfig, ctx.config);
+	const cacheKey = buildSearchCacheKey([
+		"kimi",
+		query,
+		resolveSearchCount(count, DEFAULT_SEARCH_COUNT),
+		baseUrl,
+		model
+	]);
+	const cached = readCachedSearchPayload(cacheKey);
+	if (cached) return cached;
+	const start = Date.now();
+	const result = await runKimiSearch({
+		query,
+		apiKey,
+		baseUrl,
+		model,
+		timeoutSeconds: resolveSearchTimeoutSeconds(searchConfig)
+	});
+	if (!result.grounded) return {
+		error: "kimi_web_search_ungrounded",
+		message: "Kimi returned a chat completion without native web-search grounding. Retry the query, switch to a structured provider such as Brave, or use web_fetch/browser for a specific URL.",
+		query,
+		provider: "kimi",
+		model,
+		docs: "https://docs.openclaw.ai/tools/kimi-search",
+		tookMs: Date.now() - start
+	};
+	const payload = {
+		query,
+		provider: "kimi",
+		model,
+		tookMs: Date.now() - start,
+		externalContent: {
+			untrusted: true,
+			source: "web_search",
+			provider: "kimi",
+			wrapped: true
+		},
+		content: wrapWebContent(result.content),
+		citations: result.citations
+	};
+	writeCachedSearchPayload(cacheKey, payload, resolveSearchCacheTtlMs(searchConfig));
+	return payload;
+}
+async function runKimiSearchProviderSetup(ctx) {
+	const existingPluginConfig = resolveProviderWebSearchPluginConfig(ctx.config, "moonshot");
+	const normalizedBaseUrl = (normalizeOptionalString(existingPluginConfig?.baseUrl) ?? "").replace(/\/+$/, "");
+	const existingModel = normalizeOptionalString(existingPluginConfig?.model) ?? "";
+	const isCustomBaseUrl = normalizedBaseUrl && !isNativeMoonshotBaseUrl(normalizedBaseUrl);
+	const regionOptions = [];
+	if (isCustomBaseUrl) regionOptions.push({
+		value: normalizedBaseUrl,
+		label: `Keep current (${normalizedBaseUrl})`,
+		hint: "custom endpoint"
+	});
+	regionOptions.push({
+		value: MOONSHOT_BASE_URL,
+		label: "Moonshot API key (.ai)",
+		hint: "api.moonshot.ai"
+	}, {
+		value: MOONSHOT_CN_BASE_URL,
+		label: "Moonshot API key (.cn)",
+		hint: "api.moonshot.cn"
+	});
+	const baseUrl = await ctx.prompter.select({
+		message: "Kimi API region",
+		options: regionOptions,
+		initialValue: normalizedBaseUrl || "https://api.moonshot.ai/v1"
+	});
+	const currentModelLabel = existingModel ? `Keep current (moonshot/${existingModel})` : `Use default (moonshot/${DEFAULT_KIMI_SEARCH_MODEL})`;
+	const modelChoice = await ctx.prompter.select({
+		message: "Kimi web search model",
+		options: [
+			{
+				value: "__keep__",
+				label: currentModelLabel
+			},
+			{
+				value: "__custom__",
+				label: "Enter model manually"
+			},
+			{
+				value: DEFAULT_KIMI_SEARCH_MODEL,
+				label: `moonshot/${DEFAULT_KIMI_SEARCH_MODEL}`
+			}
+		],
+		initialValue: "__keep__"
+	});
+	let model;
+	if (modelChoice === "__keep__") model = existingModel || DEFAULT_KIMI_SEARCH_MODEL;
+	else if (modelChoice === "__custom__") model = (await ctx.prompter.text({
+		message: "Kimi model name",
+		initialValue: existingModel || DEFAULT_KIMI_SEARCH_MODEL,
+		placeholder: DEFAULT_KIMI_SEARCH_MODEL
+	}))?.trim() || DEFAULT_KIMI_SEARCH_MODEL;
+	else model = modelChoice;
+	const next = { ...ctx.config };
+	setProviderWebSearchPluginConfigValue(next, "moonshot", "baseUrl", baseUrl);
+	setProviderWebSearchPluginConfigValue(next, "moonshot", "model", model);
+	return next;
+}
+const testing = {
+	resolveKimiApiKey,
+	resolveKimiModel,
+	resolveKimiBaseUrl,
+	extractKimiCitations,
+	hasKimiSearchResults,
+	extractKimiToolResultContent
+};
+//#endregion
+export { testing as __testing, testing, executeKimiWebSearchProviderTool, runKimiSearchProviderSetup };

package/dist/media-understanding-provider.js

@@ -0,0 +1,66 @@
+import { r as MOONSHOT_DEFAULT_MODEL_ID } from "./provider-catalog-BGSHIo8D.js";
+import { buildOpenAiCompatibleVideoRequestBody, coerceOpenAiCompatibleVideoText, describeImageWithModel, describeImagesWithModel, resolveMediaUnderstandingString } from "openclaw/plugin-sdk/media-understanding";
+import { assertOkOrThrowHttpError, postJsonRequest, resolveProviderHttpRequestConfig } from "openclaw/plugin-sdk/provider-http";
+//#region extensions/moonshot/media-understanding-provider.ts
+const DEFAULT_MOONSHOT_VIDEO_BASE_URL = "https://api.moonshot.ai/v1";
+const DEFAULT_MOONSHOT_VIDEO_MODEL = MOONSHOT_DEFAULT_MODEL_ID;
+const DEFAULT_MOONSHOT_VIDEO_PROMPT = "Describe the video.";
+async function describeMoonshotVideo(params) {
+	const fetchFn = params.fetchFn ?? fetch;
+	const model = resolveMediaUnderstandingString(params.model, DEFAULT_MOONSHOT_VIDEO_MODEL);
+	const mime = resolveMediaUnderstandingString(params.mime, "video/mp4");
+	const prompt = resolveMediaUnderstandingString(params.prompt, DEFAULT_MOONSHOT_VIDEO_PROMPT);
+	const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+		baseUrl: params.baseUrl,
+		defaultBaseUrl: DEFAULT_MOONSHOT_VIDEO_BASE_URL,
+		headers: params.headers,
+		request: params.request,
+		defaultHeaders: {
+			"content-type": "application/json",
+			authorization: `Bearer ${params.apiKey}`
+		},
+		provider: "moonshot",
+		api: "openai-completions",
+		capability: "video",
+		transport: "media-understanding"
+	});
+	const { response: res, release } = await postJsonRequest({
+		url: `${baseUrl}/chat/completions`,
+		headers,
+		body: buildOpenAiCompatibleVideoRequestBody({
+			model,
+			prompt,
+			mime,
+			buffer: params.buffer
+		}),
+		timeoutMs: params.timeoutMs,
+		fetchFn,
+		allowPrivateNetwork,
+		dispatcherPolicy
+	});
+	try {
+		await assertOkOrThrowHttpError(res, "Moonshot video description failed");
+		const text = coerceOpenAiCompatibleVideoText(await res.json());
+		if (!text) throw new Error("Moonshot video description response missing content");
+		return {
+			text,
+			model
+		};
+	} finally {
+		await release();
+	}
+}
+const moonshotMediaUnderstandingProvider = {
+	id: "moonshot",
+	capabilities: ["image", "video"],
+	defaultModels: {
+		image: MOONSHOT_DEFAULT_MODEL_ID,
+		video: DEFAULT_MOONSHOT_VIDEO_MODEL
+	},
+	autoPriority: { video: 20 },
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel,
+	describeVideo: describeMoonshotVideo
+};
+//#endregion
+export { describeMoonshotVideo, moonshotMediaUnderstandingProvider };

package/dist/onboard.js

@@ -0,0 +1,30 @@
+import { a as buildMoonshotProvider, n as MOONSHOT_CN_BASE_URL, r as MOONSHOT_DEFAULT_MODEL_ID, t as MOONSHOT_BASE_URL } from "./provider-catalog-BGSHIo8D.js";
+import { createDefaultModelPresetAppliers } from "openclaw/plugin-sdk/provider-onboard";
+//#region extensions/moonshot/onboard.ts
+const MOONSHOT_DEFAULT_MODEL_REF = `moonshot/${MOONSHOT_DEFAULT_MODEL_ID}`;
+const moonshotPresetAppliers = createDefaultModelPresetAppliers({
+	primaryModelRef: MOONSHOT_DEFAULT_MODEL_REF,
+	resolveParams: (_cfg, baseUrl) => {
+		const defaultModel = buildMoonshotProvider().models[0];
+		if (!defaultModel) return null;
+		return {
+			providerId: "moonshot",
+			api: "openai-completions",
+			baseUrl,
+			defaultModel,
+			defaultModelId: MOONSHOT_DEFAULT_MODEL_ID,
+			aliases: [{
+				modelRef: MOONSHOT_DEFAULT_MODEL_REF,
+				alias: "Kimi"
+			}]
+		};
+	}
+});
+function applyMoonshotConfig(cfg) {
+	return moonshotPresetAppliers.applyConfig(cfg, MOONSHOT_BASE_URL);
+}
+function applyMoonshotConfigCn(cfg) {
+	return moonshotPresetAppliers.applyConfig(cfg, MOONSHOT_CN_BASE_URL);
+}
+//#endregion
+export { MOONSHOT_DEFAULT_MODEL_REF, applyMoonshotConfig, applyMoonshotConfigCn };

package/dist/provider-catalog-BGSHIo8D.js

@@ -0,0 +1,121 @@
+import { applyProviderNativeStreamingUsageCompat, buildManifestModelProviderConfig, supportsNativeStreamingUsageCompat } from "openclaw/plugin-sdk/provider-catalog-shared";
+//#region extensions/moonshot/openclaw.plugin.json
+var modelCatalog = {
+	"aliases": {
+		"moonshotai": { "provider": "moonshot" },
+		"moonshot-ai": { "provider": "moonshot" }
+	},
+	"providers": { "moonshot": {
+		"baseUrl": "https://api.moonshot.ai/v1",
+		"api": "openai-completions",
+		"models": [
+			{
+				"id": "kimi-k2.6",
+				"name": "Kimi K2.6",
+				"input": ["text", "image"],
+				"contextWindow": 262144,
+				"maxTokens": 262144,
+				"cost": {
+					"input": .95,
+					"output": 4,
+					"cacheRead": .16,
+					"cacheWrite": 0
+				}
+			},
+			{
+				"id": "kimi-k2.7-code",
+				"name": "Kimi K2.7 Code",
+				"reasoning": true,
+				"input": ["text", "image"],
+				"contextWindow": 262144,
+				"maxTokens": 262144,
+				"cost": {
+					"input": .95,
+					"output": 4,
+					"cacheRead": .19,
+					"cacheWrite": 0
+				}
+			},
+			{
+				"id": "kimi-k2.5",
+				"name": "Kimi K2.5",
+				"input": ["text", "image"],
+				"contextWindow": 262144,
+				"maxTokens": 262144,
+				"cost": {
+					"input": .6,
+					"output": 3,
+					"cacheRead": .1,
+					"cacheWrite": 0
+				}
+			},
+			{
+				"id": "kimi-k2-thinking",
+				"name": "Kimi K2 Thinking",
+				"reasoning": true,
+				"input": ["text"],
+				"contextWindow": 262144,
+				"maxTokens": 262144,
+				"cost": {
+					"input": 0,
+					"output": 0,
+					"cacheRead": 0,
+					"cacheWrite": 0
+				}
+			},
+			{
+				"id": "kimi-k2-thinking-turbo",
+				"name": "Kimi K2 Thinking Turbo",
+				"reasoning": true,
+				"input": ["text"],
+				"contextWindow": 262144,
+				"maxTokens": 262144,
+				"cost": {
+					"input": 0,
+					"output": 0,
+					"cacheRead": 0,
+					"cacheWrite": 0
+				}
+			},
+			{
+				"id": "kimi-k2-turbo",
+				"name": "Kimi K2 Turbo",
+				"input": ["text"],
+				"contextWindow": 256e3,
+				"maxTokens": 16384,
+				"cost": {
+					"input": 0,
+					"output": 0,
+					"cacheRead": 0,
+					"cacheWrite": 0
+				}
+			}
+		]
+	} },
+	"discovery": { "moonshot": "static" }
+};
+//#endregion
+//#region extensions/moonshot/provider-catalog.ts
+const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
+const MOONSHOT_CN_BASE_URL = "https://api.moonshot.cn/v1";
+const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2.6";
+function isNativeMoonshotBaseUrl(baseUrl) {
+	return supportsNativeStreamingUsageCompat({
+		providerId: "moonshot",
+		baseUrl
+	});
+}
+function applyMoonshotNativeStreamingUsageCompat(provider) {
+	return applyProviderNativeStreamingUsageCompat({
+		providerId: "moonshot",
+		providerConfig: provider
+	});
+}
+function buildMoonshotProvider() {
+	return buildManifestModelProviderConfig({
+		providerId: "moonshot",
+		catalog: modelCatalog.providers.moonshot
+	});
+}
+//#endregion
+export { buildMoonshotProvider as a, applyMoonshotNativeStreamingUsageCompat as i, MOONSHOT_CN_BASE_URL as n, isNativeMoonshotBaseUrl as o, MOONSHOT_DEFAULT_MODEL_ID as r, MOONSHOT_BASE_URL as t };

package/dist/provider-catalog.js

@@ -0,0 +1,2 @@
+import { a as buildMoonshotProvider, i as applyMoonshotNativeStreamingUsageCompat, n as MOONSHOT_CN_BASE_URL, o as isNativeMoonshotBaseUrl, r as MOONSHOT_DEFAULT_MODEL_ID, t as MOONSHOT_BASE_URL } from "./provider-catalog-BGSHIo8D.js";
+export { MOONSHOT_BASE_URL, MOONSHOT_CN_BASE_URL, MOONSHOT_DEFAULT_MODEL_ID, applyMoonshotNativeStreamingUsageCompat, buildMoonshotProvider, isNativeMoonshotBaseUrl };

package/dist/provider-contract-api.js

@@ -0,0 +1,27 @@
+//#region extensions/moonshot/provider-contract-api.ts
+const noopAuth = async () => ({ profiles: [] });
+function createMoonshotProvider() {
+	return {
+		id: "moonshot",
+		label: "Moonshot",
+		docsPath: "/providers/moonshot",
+		aliases: ["moonshotai", "moonshot-ai"],
+		auth: [{
+			id: "api-key",
+			kind: "api_key",
+			label: "Kimi API key (.ai)",
+			hint: "Kimi K2.6 + Kimi",
+			run: noopAuth,
+			wizard: { groupLabel: "Moonshot AI (Kimi K2.6)" }
+		}, {
+			id: "api-key-cn",
+			kind: "api_key",
+			label: "Kimi API key (.cn)",
+			hint: "Kimi K2.6 + Kimi",
+			run: noopAuth,
+			wizard: { groupLabel: "Moonshot AI (Kimi K2.6)" }
+		}]
+	};
+}
+//#endregion
+export { createMoonshotProvider };

package/dist/provider-discovery.js

@@ -0,0 +1,15 @@
+import { a as buildMoonshotProvider } from "./provider-catalog-BGSHIo8D.js";
+//#region extensions/moonshot/provider-discovery.ts
+const moonshotProviderDiscovery = {
+	id: "moonshot",
+	label: "Moonshot",
+	docsPath: "/providers/moonshot",
+	aliases: ["moonshotai", "moonshot-ai"],
+	auth: [],
+	staticCatalog: {
+		order: "simple",
+		run: async () => ({ provider: buildMoonshotProvider() })
+	}
+};
+//#endregion
+export { moonshotProviderDiscovery as default };

package/dist/provider-policy-api.js

@@ -0,0 +1,24 @@
+//#region extensions/moonshot/provider-policy-api.ts
+const KIMI_K2_7_CODE_MODEL_ID = "kimi-k2.7-code";
+function resolveThinkingProfile(context) {
+	if (context.modelId.trim().toLowerCase() === "kimi-k2.7-code") return {
+		levels: [{
+			id: "low",
+			label: "on"
+		}],
+		defaultLevel: "low",
+		preserveWhenCatalogReasoningFalse: true
+	};
+	return {
+		levels: [{
+			id: "off",
+			label: "off"
+		}, {
+			id: "low",
+			label: "on"
+		}],
+		defaultLevel: "off"
+	};
+}
+//#endregion
+export { KIMI_K2_7_CODE_MODEL_ID, resolveThinkingProfile };

package/dist/web-search-contract-api.js

@@ -0,0 +1,29 @@
+import { createWebSearchProviderContractFields } from "openclaw/plugin-sdk/provider-web-search-config-contract";
+//#region extensions/moonshot/web-search-contract-api.ts
+function createKimiWebSearchProvider() {
+	const credentialPath = "plugins.entries.moonshot.config.webSearch.apiKey";
+	return {
+		id: "kimi",
+		label: "Kimi (Moonshot)",
+		hint: "Requires Moonshot / Kimi API key · Moonshot web search",
+		onboardingScopes: ["text-inference"],
+		credentialLabel: "Moonshot / Kimi API key",
+		envVars: ["KIMI_API_KEY", "MOONSHOT_API_KEY"],
+		placeholder: "sk-...",
+		signupUrl: "https://platform.moonshot.cn/",
+		docsUrl: "https://docs.openclaw.ai/tools/web",
+		autoDetectOrder: 40,
+		credentialPath,
+		...createWebSearchProviderContractFields({
+			credentialPath,
+			searchCredential: {
+				type: "scoped",
+				scopeId: "kimi"
+			},
+			configuredCredential: { pluginId: "moonshot" }
+		}),
+		createTool: () => null
+	};
+}
+//#endregion
+export { createKimiWebSearchProvider };

package/dist/web-search-provider.js

@@ -0,0 +1,2 @@
+import { t as createKimiWebSearchProvider } from "./kimi-web-search-provider-pERL62H1.js";
+export { createKimiWebSearchProvider };

package/npm-shrinkwrap.json

@@ -0,0 +1,12 @@
+{
+  "name": "@openclaw/moonshot-provider",
+  "version": "2026.6.11-beta.2",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@openclaw/moonshot-provider",
+      "version": "2026.6.11-beta.2"
+    }
+  }
+}

package/openclaw.plugin.json

@@ -0,0 +1,232 @@
+{
+  "id": "moonshot",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providerCatalogEntry": "./provider-discovery.ts",
+  "providers": ["moonshot"],
+  "providerAuthAliases": {
+    "moonshotai": "moonshot",
+    "moonshot-ai": "moonshot"
+  },
+  "providerEndpoints": [
+    {
+      "endpointClass": "moonshot-native",
+      "baseUrls": ["https://api.moonshot.ai/v1", "https://api.moonshot.cn/v1"]
+    }
+  ],
+  "providerRequest": {
+    "providers": {
+      "moonshot": {
+        "family": "moonshot",
+        "compatibilityFamily": "moonshot"
+      }
+    }
+  },
+  "modelPricing": {
+    "providers": {
+      "moonshot": {
+        "openRouter": {
+          "provider": "moonshotai"
+        },
+        "liteLLM": {
+          "provider": "moonshot"
+        }
+      }
+    }
+  },
+  "modelCatalog": {
+    "aliases": {
+      "moonshotai": {
+        "provider": "moonshot"
+      },
+      "moonshot-ai": {
+        "provider": "moonshot"
+      }
+    },
+    "providers": {
+      "moonshot": {
+        "baseUrl": "https://api.moonshot.ai/v1",
+        "api": "openai-completions",
+        "models": [
+          {
+            "id": "kimi-k2.6",
+            "name": "Kimi K2.6",
+            "input": ["text", "image"],
+            "contextWindow": 262144,
+            "maxTokens": 262144,
+            "cost": {
+              "input": 0.95,
+              "output": 4,
+              "cacheRead": 0.16,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2.7-code",
+            "name": "Kimi K2.7 Code",
+            "reasoning": true,
+            "input": ["text", "image"],
+            "contextWindow": 262144,
+            "maxTokens": 262144,
+            "cost": {
+              "input": 0.95,
+              "output": 4,
+              "cacheRead": 0.19,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2.5",
+            "name": "Kimi K2.5",
+            "input": ["text", "image"],
+            "contextWindow": 262144,
+            "maxTokens": 262144,
+            "cost": {
+              "input": 0.6,
+              "output": 3,
+              "cacheRead": 0.1,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2-thinking",
+            "name": "Kimi K2 Thinking",
+            "reasoning": true,
+            "input": ["text"],
+            "contextWindow": 262144,
+            "maxTokens": 262144,
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2-thinking-turbo",
+            "name": "Kimi K2 Thinking Turbo",
+            "reasoning": true,
+            "input": ["text"],
+            "contextWindow": 262144,
+            "maxTokens": 262144,
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2-turbo",
+            "name": "Kimi K2 Turbo",
+            "input": ["text"],
+            "contextWindow": 256000,
+            "maxTokens": 16384,
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          }
+        ]
+      }
+    },
+    "discovery": {
+      "moonshot": "static"
+    }
+  },
+  "setup": {
+    "providers": [
+      {
+        "id": "moonshot",
+        "envVars": ["MOONSHOT_API_KEY", "KIMI_API_KEY"]
+      }
+    ]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "moonshot",
+      "method": "api-key",
+      "choiceId": "moonshot-api-key",
+      "choiceLabel": "Moonshot API key (.ai)",
+      "groupId": "moonshot",
+      "groupLabel": "Moonshot AI (Kimi K2.6)",
+      "groupHint": "Kimi K2.6",
+      "optionKey": "moonshotApiKey",
+      "cliFlag": "--moonshot-api-key",
+      "cliOption": "--moonshot-api-key <key>",
+      "cliDescription": "Moonshot API key"
+    },
+    {
+      "provider": "moonshot",
+      "method": "api-key-cn",
+      "choiceId": "moonshot-api-key-cn",
+      "choiceLabel": "Moonshot API key (.cn)",
+      "groupId": "moonshot",
+      "groupLabel": "Moonshot AI (Kimi K2.6)",
+      "groupHint": "Kimi K2.6",
+      "optionKey": "moonshotApiKey",
+      "cliFlag": "--moonshot-api-key",
+      "cliOption": "--moonshot-api-key <key>",
+      "cliDescription": "Moonshot API key"
+    }
+  ],
+  "uiHints": {
+    "webSearch.apiKey": {
+      "label": "Kimi Search API Key",
+      "help": "Moonshot/Kimi API key (fallback: KIMI_API_KEY or MOONSHOT_API_KEY env var).",
+      "sensitive": true
+    },
+    "webSearch.baseUrl": {
+      "label": "Kimi Search Base URL",
+      "help": "Kimi base URL override."
+    },
+    "webSearch.model": {
+      "label": "Kimi Search Model",
+      "help": "Kimi model override."
+    }
+  },
+  "contracts": {
+    "mediaUnderstandingProviders": ["moonshot"],
+    "webSearchProviders": ["kimi"]
+  },
+  "mediaUnderstandingProviderMetadata": {
+    "moonshot": {
+      "capabilities": ["image", "video"],
+      "defaultModels": {
+        "image": "kimi-k2.6",
+        "video": "kimi-k2.6"
+      },
+      "autoPriority": {
+        "video": 20
+      }
+    }
+  },
+  "configContracts": {
+    "compatibilityRuntimePaths": ["tools.web.search.apiKey"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "webSearch": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "apiKey": {
+            "type": ["string", "object"]
+          },
+          "baseUrl": {
+            "type": "string"
+          },
+          "model": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -1,13 +1,50 @@
 {
   "name": "@openclaw/moonshot-provider",
-  "version": "0.0.0",
-  "description": "Bootstrap reservation for the OpenClaw Moonshot provider package.",
+  "version": "2026.6.11-beta.2",
+  "description": "OpenClaw Moonshot provider plugin",
+  "type": "module",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "clawhubSpec": "clawhub:@openclaw/moonshot-provider",
+      "npmSpec": "@openclaw/moonshot-provider",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.6.9"
+    },
+    "compat": {
+      "pluginApi": ">=2026.6.11-beta.2"
+    },
+    "build": {
+      "openclawVersion": "2026.6.11-beta.2",
+      "bundledDist": false
+    },
+    "release": {
+      "publishToClawHub": true,
+      "publishToNpm": true
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ]
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/openclaw/openclaw.git"
+    "url": "https://github.com/openclaw/openclaw"
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json",
+    "npm-shrinkwrap.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.6.11-beta.2"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
   },
-  "license": "Apache-2.0",
-  "publishConfig": {
-    "access": "public"
-  }
+  "bundledDependencies": []
 }