@openclaw/moonshot-provider 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/index.js

@@ -1,35 +1,28 @@
+import { t as openclaw_plugin_default } from "./openclaw.plugin-BLi5Z-ZR.js";
 import { MOONSHOT_DEFAULT_MODEL_REF, applyMoonshotNativeStreamingUsageCompat, buildMoonshotProvider } from "./provider-catalog.js";
 import "./api.js";
 import { moonshotMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { isMoonshotAlwaysThinkingModelId, isMoonshotK3NativeVideoRoute, resolveThinkingProfile } from "./provider-policy-api.js";
+import { wrapMoonshotStream } from "./native-video.js";
 import { applyMoonshotConfig, applyMoonshotConfigCn } from "./onboard.js";
-import { isMoonshotAlwaysThinkingModelId, resolveThinkingProfile } from "./provider-policy-api.js";
-import { t as createKimiWebSearchProvider } from "./kimi-web-search-provider-DGFWylD8.js";
+import { t as createKimiWebSearchProvider } from "./kimi-web-search-provider-CofLF1qp.js";
+import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth-api-key";
 import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";
 import { buildOpenAICompatibleReplayPolicy } from "openclaw/plugin-sdk/provider-model-shared";
-import { buildProviderStreamFamilyHooks } from "openclaw/plugin-sdk/provider-stream-family";
 //#region extensions/moonshot/index.ts
 const PROVIDER_ID = "moonshot";
-const moonshotThinkingStreamHooks = buildProviderStreamFamilyHooks("moonshot-thinking");
 var moonshot_default = defineSingleProviderPluginEntry({
 	id: PROVIDER_ID,
 	name: "Moonshot Provider",
 	description: "Bundled Moonshot provider plugin",
+	manifest: openclaw_plugin_default,
 	provider: {
 		label: "Moonshot",
 		docsPath: "/providers/moonshot",
 		aliases: ["moonshotai", "moonshot-ai"],
-		auth: [{
-			methodId: "api-key",
-			label: "Kimi API key (.ai)",
-			hint: "Kimi API models · https://platform.kimi.ai/docs/pricing/chat",
-			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)" }
-		}, {
+		manifestAuth: { applyConfig: applyMoonshotConfig },
+		extraAuth: [createProviderApiKeyAuthMethod({
+			providerId: PROVIDER_ID,
 			methodId: "api-key-cn",
 			label: "Kimi API key (.cn)",
 			hint: "Kimi API models · https://platform.kimi.ai/docs/pricing/chat",
@@ -38,9 +31,9 @@ var moonshot_default = defineSingleProviderPluginEntry({
 			envVar: "MOONSHOT_API_KEY",
 			promptMessage: "Enter Moonshot API key (.cn)",
 			defaultModel: MOONSHOT_DEFAULT_MODEL_REF,
-			applyConfig: (cfg) => applyMoonshotConfigCn(cfg),
+			applyConfig: applyMoonshotConfigCn,
 			wizard: { groupLabel: "Moonshot AI (Kimi)" }
-		}],
+		})],
 		catalog: {
 			buildProvider: buildMoonshotProvider,
 			buildStaticProvider: buildMoonshotProvider,
@@ -48,14 +41,22 @@ var moonshot_default = defineSingleProviderPluginEntry({
 			liveModelDiscovery: true
 		},
 		applyNativeStreamingUsageCompat: ({ providerConfig }) => applyMoonshotNativeStreamingUsageCompat(providerConfig),
+		normalizeResolvedModel: (ctx) => ({
+			...ctx.model,
+			input: ctx.model.input.filter((type) => type !== "video").concat(isMoonshotK3NativeVideoRoute({
+				...ctx.model,
+				provider: ctx.provider,
+				modelId: ctx.modelId
+			}) ? "video" : [])
+		}),
 		buildReplayPolicy: ({ modelApi, modelId }) => buildOpenAICompatibleReplayPolicy(modelApi, {
 			modelId,
 			sanitizeToolCallIds: modelApi === "openai-completions",
 			duplicateToolCallIdStyle: "openai",
 			dropReasoningFromHistory: false
 		}),
-		...moonshotThinkingStreamHooks,
-		wrapSimpleCompletionStreamFn: (ctx) => isMoonshotAlwaysThinkingModelId(ctx.modelId) ? moonshotThinkingStreamHooks.wrapStreamFn?.(ctx) : ctx.streamFn,
+		wrapStreamFn: (ctx) => wrapMoonshotStream(ctx),
+		wrapSimpleCompletionStreamFn: (ctx) => wrapMoonshotStream(ctx, true),
 		resolveThinkingProfile,
 		isModernModelRef: ({ modelId }) => isMoonshotAlwaysThinkingModelId(modelId)
 	},

package/dist/{kimi-web-search-provider-DGFWylD8.js → kimi-web-search-provider-CofLF1qp.js}

@@ -2,7 +2,7 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 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";
-const loadKimiWebSearchProviderRuntime = createLazyRuntimeModule(() => import("./kimi-web-search-provider.runtime-B6y-kz4c.js"));
+const loadKimiWebSearchProviderRuntime = createLazyRuntimeModule(() => import("./kimi-web-search-provider.runtime-_hv6i3xa.js"));
 const KimiSearchSchema = {
 	type: "object",
 	properties: {
@@ -66,9 +66,9 @@ function createKimiWebSearchProvider() {
 		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) => {
+			execute: async (args, context) => {
 				const { executeKimiWebSearchProviderTool } = await loadKimiWebSearchProviderRuntime();
-				return await executeKimiWebSearchProviderTool(ctx, args);
+				return await executeKimiWebSearchProviderTool(ctx, args, { signal: context?.signal });
 			}
 		})
 	};

package/dist/{kimi-web-search-provider.runtime-B6y-kz4c.js → kimi-web-search-provider.runtime-_hv6i3xa.js}

@@ -1,7 +1,7 @@
 import { MOONSHOT_BASE_URL, MOONSHOT_CN_BASE_URL, isNativeMoonshotBaseUrl } from "./provider-catalog.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";
+import { createProviderHttpError, readProviderJsonObjectResponse } from "openclaw/plugin-sdk/provider-http";
+import { MAX_SEARCH_COUNT, buildSearchCacheKey, buildUnsupportedSearchFilterResponse, mergeScopedSearchConfig, readCachedSearchPayload, readConfiguredSecretString, readPositiveIntegerParam, readProviderEnvValue, readStringParam, resolveProviderWebSearchPluginConfig, resolveSearchCacheTtlMs, resolveSearchTimeoutSeconds, setProviderWebSearchPluginConfigValue, withTrustedWebSearchEndpoint, wrapWebContent, writeCachedSearchPayload } from "openclaw/plugin-sdk/provider-web-search";
 //#region extensions/moonshot/src/kimi-web-search-provider.runtime.ts
 const DEFAULT_KIMI_BASE_URL = MOONSHOT_BASE_URL;
 const DEFAULT_KIMI_SEARCH_MODEL = "kimi-k2.6";
@@ -89,6 +89,7 @@ async function runKimiSearch(params) {
 		const next = await withTrustedWebSearchEndpoint({
 			url: endpoint,
 			timeoutSeconds: params.timeoutSeconds,
+			signal: params.signal,
 			init: {
 				method: "POST",
 				headers: {
@@ -160,13 +161,10 @@ async function runKimiSearch(params) {
 			grounded: hasGroundingEvidence
 		};
 	}
-	return {
-		content: "Search completed but no final answer was produced.",
-		citations: [...collectedCitations],
-		grounded: hasGroundingEvidence
-	};
+	throw new Error("Kimi web search exhausted its tool-call rounds without producing a final answer. Retry the query or choose another search provider.");
 }
-async function executeKimiWebSearchProviderTool(ctx, args) {
+async function executeKimiWebSearchProviderTool(ctx, args, opts) {
+	opts?.signal?.throwIfAborted();
 	const searchConfig = mergeScopedSearchConfig(ctx.searchConfig, "kimi", resolveProviderWebSearchPluginConfig(ctx.config, "moonshot"));
 	const unsupportedResponse = buildUnsupportedSearchFilterResponse(args, "kimi");
 	if (unsupportedResponse) return unsupportedResponse;
@@ -178,16 +176,15 @@ async function executeKimiWebSearchProviderTool(ctx, args) {
 		docs: "https://docs.openclaw.ai/tools/web"
 	};
 	const query = readStringParam(args, "query", { required: true });
-	const count = readPositiveIntegerParam(args, "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
 	]);
@@ -199,8 +196,10 @@ async function executeKimiWebSearchProviderTool(ctx, args) {
 		apiKey,
 		baseUrl,
 		model,
-		timeoutSeconds: resolveSearchTimeoutSeconds(searchConfig)
+		timeoutSeconds: resolveSearchTimeoutSeconds(searchConfig),
+		signal: opts?.signal
 	});
+	opts?.signal?.throwIfAborted();
 	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.",
@@ -289,8 +288,7 @@ const testing = {
 	resolveKimiModel,
 	resolveKimiBaseUrl,
 	extractKimiCitations,
-	hasKimiSearchResults,
 	extractKimiToolResultContent
 };
 //#endregion
-export { testing as __testing, testing, executeKimiWebSearchProviderTool, runKimiSearchProviderSetup };
+export { executeKimiWebSearchProviderTool, runKimiSearchProviderSetup, testing };

package/dist/media-understanding-provider.js

@@ -1,56 +1,19 @@
 import { t as openclaw_plugin_default } from "./openclaw.plugin-BLi5Z-ZR.js";
-import { buildOpenAiCompatibleVideoRequestBody, coerceOpenAiCompatibleVideoText, describeImageWithModel, describeImagesWithModel, resolveMediaUnderstandingString } from "openclaw/plugin-sdk/media-understanding";
-import { assertOkOrThrowHttpError, postJsonRequest, readProviderJsonResponse, resolveProviderHttpRequestConfig } from "openclaw/plugin-sdk/provider-http";
+import { MOONSHOT_BASE_URL } from "./provider-catalog.js";
+import { describeImageWithModel, describeImagesWithModel, describeOpenAiCompatibleVideo } from "openclaw/plugin-sdk/media-understanding";
 //#region extensions/moonshot/media-understanding-provider.ts
-const DEFAULT_MOONSHOT_VIDEO_BASE_URL = "https://api.moonshot.ai/v1";
 const DEFAULT_MOONSHOT_IMAGE_MODEL = openclaw_plugin_default.mediaUnderstandingProviderMetadata.moonshot.defaultModels.image;
 const DEFAULT_MOONSHOT_VIDEO_MODEL = openclaw_plugin_default.mediaUnderstandingProviderMetadata.moonshot.defaultModels.video;
 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}`
-		},
+	return describeOpenAiCompatibleVideo({
+		...params,
+		defaultBaseUrl: MOONSHOT_BASE_URL,
+		defaultModel: DEFAULT_MOONSHOT_VIDEO_MODEL,
+		defaultPrompt: DEFAULT_MOONSHOT_VIDEO_PROMPT,
 		provider: "moonshot",
-		api: "openai-completions",
-		capability: "video",
-		transport: "media-understanding"
+		providerLabel: "Moonshot"
 	});
-	const { response: res, release } = await postJsonRequest({
-		url: `${baseUrl}/chat/completions`,
-		headers,
-		body: buildOpenAiCompatibleVideoRequestBody({
-			model,
-			prompt,
-			mime,
-			buffer: params.buffer
-		}),
-		timeoutMs: params.timeoutMs,
-		...params.signal ? { signal: params.signal } : {},
-		fetchFn,
-		allowPrivateNetwork,
-		dispatcherPolicy
-	});
-	try {
-		await assertOkOrThrowHttpError(res, "Moonshot video description failed");
-		const text = coerceOpenAiCompatibleVideoText(await readProviderJsonResponse(res, "Moonshot video description failed"));
-		if (!text) throw new Error("Moonshot video description response missing content");
-		return {
-			text,
-			model
-		};
-	} finally {
-		await release();
-	}
 }
 const moonshotMediaUnderstandingProvider = {
 	id: "moonshot",

package/dist/native-video.js

@@ -0,0 +1,53 @@
+import { isMoonshotAlwaysThinkingModelId, isMoonshotK3NativeVideoRoute } from "./provider-policy-api.js";
+import { resolveProviderContext, streamSimple } from "openclaw/plugin-sdk/llm";
+import { createMoonshotThinkingWrapper, resolveMoonshotThinkingKeep, resolveMoonshotThinkingType } from "openclaw/plugin-sdk/provider-stream-shared";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/moonshot/native-video.ts
+const VIDEO_PREFIX = "data:video/mp4;base64,";
+const VIDEO_OMISSION = "(video omitted: untrusted or unsupported Moonshot video)";
+const MOONSHOT_REQUEST_BYTES_EXCLUSIVE = 1e8;
+function forEachUserContentPart(payload, visit) {
+	const messages = isRecord(payload) && Array.isArray(payload.messages) ? payload.messages : [];
+	for (const message of messages) {
+		if (!isRecord(message) || message.role !== "user" || !Array.isArray(message.content)) continue;
+		for (const part of message.content) if (isRecord(part)) visit(part);
+	}
+}
+function partUrl(part, field) {
+	const url = isRecord(part[field]) ? part[field].url : void 0;
+	return typeof url === "string" ? url : void 0;
+}
+function replacePart(part, text) {
+	Object.keys(part).forEach((key) => Reflect.deleteProperty(part, key));
+	Object.assign(part, {
+		type: "text",
+		text
+	});
+}
+function finalizePayload(result, payload, requestBytesExclusive) {
+	const admitted = [];
+	forEachUserContentPart(payload, (part) => {
+		const videoUrl = partUrl(part, "video_url");
+		const imageUrl = partUrl(part, "image_url");
+		if (part.type === "video_url" && videoUrl?.startsWith(VIDEO_PREFIX)) admitted.push(part);
+		else if (part.type === "video_url" || imageUrl?.startsWith("data:video/")) replacePart(part, VIDEO_OMISSION);
+	});
+	const isOversized = () => Buffer.byteLength(JSON.stringify(payload), "utf8") >= requestBytesExclusive;
+	while (admitted.length > 0 && isOversized()) replacePart(admitted.pop(), "(video omitted: Moonshot request size limit)");
+	if (isOversized()) throw new Error(`Moonshot request body must be smaller than ${requestBytesExclusive} bytes`);
+	return result;
+}
+function wrapMoonshotStream(ctx, simple = false, requestBytesExclusive = MOONSHOT_REQUEST_BYTES_EXCLUSIVE) {
+	const underlying = ctx.streamFn ?? streamSimple;
+	if (simple && !isMoonshotAlwaysThinkingModelId(ctx.modelId)) return underlying;
+	const withVideoContext = (model, context, options) => isMoonshotK3NativeVideoRoute({
+		...model,
+		modelId: model.id
+	}) ? resolveProviderContext(context, options).then((providerContext) => underlying(model, providerContext, options)) : underlying(model, context, options);
+	return createMoonshotThinkingWrapper(withVideoContext, resolveMoonshotThinkingType({
+		configuredThinking: ctx.extraParams?.thinking,
+		thinkingLevel: ctx.thinkingLevel
+	}), resolveMoonshotThinkingKeep({ configuredThinking: ctx.extraParams?.thinking }), (result, payload) => finalizePayload(result, payload, requestBytesExclusive));
+}
+//#endregion
+export { wrapMoonshotStream };

package/dist/onboard.js

@@ -4,9 +4,8 @@ import { createDefaultModelPresetAppliers } from "openclaw/plugin-sdk/provider-o
 const moonshotPresetAppliers = createDefaultModelPresetAppliers({
 	primaryModelRef: MOONSHOT_DEFAULT_MODEL_REF,
 	resolveParams: (_cfg, baseUrl) => {
-		const defaultModel = buildMoonshotProvider().models.find((model) => model.id === MOONSHOT_DEFAULT_MODEL_ID);
-		if (!defaultModel) return null;
-		return {
+		const defaultModel = buildMoonshotProvider().models.find(({ id }) => id === MOONSHOT_DEFAULT_MODEL_ID);
+		return defaultModel ? {
 			providerId: "moonshot",
 			api: "openai-completions",
 			baseUrl,
@@ -16,7 +15,7 @@ const moonshotPresetAppliers = createDefaultModelPresetAppliers({
 				modelRef: MOONSHOT_DEFAULT_MODEL_REF,
 				alias: "Kimi"
 			}]
-		};
+		} : null;
 	}
 });
 function applyMoonshotConfig(cfg) {

package/dist/provider-catalog.js

@@ -1,15 +1,12 @@
 import { t as openclaw_plugin_default } from "./openclaw.plugin-BLi5Z-ZR.js";
-import { applyProviderNativeStreamingUsageCompat, buildManifestModelProviderConfig, readManifestProviderDefaultModelRef, supportsNativeStreamingUsageCompat } from "openclaw/plugin-sdk/provider-catalog-shared";
+import { applyProviderNativeStreamingUsageCompat, buildManifestModelProviderConfig, readManifestProviderDefaultModelRef } from "openclaw/plugin-sdk/provider-catalog-shared";
 //#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_REF = readManifestProviderDefaultModelRef(openclaw_plugin_default, "moonshot");
 const MOONSHOT_DEFAULT_MODEL_ID = MOONSHOT_DEFAULT_MODEL_REF.slice(9);
 function isNativeMoonshotBaseUrl(baseUrl) {
-	return supportsNativeStreamingUsageCompat({
-		providerId: "moonshot",
-		baseUrl
-	});
+	return [MOONSHOT_BASE_URL, MOONSHOT_CN_BASE_URL].some((official) => baseUrl === official || baseUrl === `${official}/`);
 }
 function applyMoonshotNativeStreamingUsageCompat(provider) {
 	return applyProviderNativeStreamingUsageCompat({

package/dist/provider-contract-api.js

@@ -1,3 +1,4 @@
+import { t as openclaw_plugin_default } from "./openclaw.plugin-BLi5Z-ZR.js";
 //#region extensions/moonshot/provider-contract-api.ts
 const noopAuth = async () => ({ profiles: [] });
 function createMoonshotProvider() {
@@ -6,21 +7,14 @@ function createMoonshotProvider() {
 		label: "Moonshot",
 		docsPath: "/providers/moonshot",
 		aliases: ["moonshotai", "moonshot-ai"],
-		auth: [{
-			id: "api-key",
+		auth: openclaw_plugin_default.providerAuthChoices.map((choice) => ({
+			id: choice.method,
 			kind: "api_key",
-			label: "Kimi API key (.ai)",
-			hint: "Kimi API models · https://platform.kimi.ai/docs/pricing/chat",
+			label: choice.choiceLabel,
+			hint: choice.groupHint,
 			run: noopAuth,
-			wizard: { groupLabel: "Moonshot AI (Kimi)" }
-		}, {
-			id: "api-key-cn",
-			kind: "api_key",
-			label: "Kimi API key (.cn)",
-			hint: "Kimi API models · https://platform.kimi.ai/docs/pricing/chat",
-			run: noopAuth,
-			wizard: { groupLabel: "Moonshot AI (Kimi)" }
-		}]
+			wizard: { groupLabel: choice.groupLabel }
+		}))
 	};
 }
 //#endregion

package/dist/provider-policy-api.js

@@ -1,27 +1,34 @@
+import { isNativeMoonshotBaseUrl } from "./provider-catalog.js";
 //#region extensions/moonshot/provider-policy-api.ts
 const KIMI_K2_7_CODE_MODEL_ID = "kimi-k2.7-code";
 const KIMI_K2_7_CODE_HIGHSPEED_MODEL_ID = "kimi-k2.7-code-highspeed";
 const KIMI_K3_MODEL_ID = "kimi-k3";
+const ALWAYS_THINKING_PROFILES = {
+	[KIMI_K3_MODEL_ID]: {
+		id: "max",
+		label: "max"
+	},
+	[KIMI_K2_7_CODE_MODEL_ID]: {
+		id: "low",
+		label: "on"
+	},
+	[KIMI_K2_7_CODE_HIGHSPEED_MODEL_ID]: {
+		id: "low",
+		label: "on"
+	}
+};
+function isMoonshotK3NativeVideoRoute(route) {
+	return route.provider === "moonshot" && route.modelId === "kimi-k3" && route.api === "openai-completions" && isNativeMoonshotBaseUrl(route.baseUrl);
+}
 function isMoonshotAlwaysThinkingModelId(modelId) {
-	const normalized = modelId.trim().toLowerCase();
-	return normalized === "kimi-k2.7-code" || normalized === "kimi-k2.7-code-highspeed" || normalized === "kimi-k3";
+	return modelId.trim().toLowerCase() in ALWAYS_THINKING_PROFILES;
 }
 function resolveThinkingProfile(context) {
 	const modelId = context.modelId.trim().toLowerCase();
-	if (modelId === "kimi-k3") return {
-		levels: [{
-			id: "max",
-			label: "max"
-		}],
-		defaultLevel: "max",
-		preserveWhenCatalogReasoningFalse: true
-	};
-	if (modelId === "kimi-k2.7-code" || modelId === "kimi-k2.7-code-highspeed") return {
-		levels: [{
-			id: "low",
-			label: "on"
-		}],
-		defaultLevel: "low",
+	const profile = ALWAYS_THINKING_PROFILES[modelId];
+	if (profile) return {
+		levels: [profile],
+		defaultLevel: profile.id,
 		preserveWhenCatalogReasoningFalse: true
 	};
 	return {
@@ -36,4 +43,4 @@ function resolveThinkingProfile(context) {
 	};
 }
 //#endregion
-export { KIMI_K2_7_CODE_HIGHSPEED_MODEL_ID, KIMI_K2_7_CODE_MODEL_ID, KIMI_K3_MODEL_ID, isMoonshotAlwaysThinkingModelId, resolveThinkingProfile };
+export { KIMI_K2_7_CODE_HIGHSPEED_MODEL_ID, KIMI_K2_7_CODE_MODEL_ID, KIMI_K3_MODEL_ID, isMoonshotAlwaysThinkingModelId, isMoonshotK3NativeVideoRoute, resolveThinkingProfile };

package/dist/web-search-provider.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/moonshot-provider",
-  "version": "2026.7.2-beta.7",
+  "version": "2026.8.1-beta.3",
   "description": "OpenClaw Moonshot provider plugin",
   "type": "module",
   "openclaw": {
@@ -14,10 +14,10 @@
       "minHostVersion": ">=2026.6.9"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.7"
+      "pluginApi": ">=2026.8.1-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.7",
+      "openclawVersion": "2026.8.1-beta.3",
       "bundledDist": false
     },
     "release": {
@@ -38,7 +38,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.7"
+    "openclaw": ">=2026.8.1-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {