@openclaw/kimi-provider 2026.7.2-beta.5 → 2026.7.33

package/dist/index.js

@@ -1,65 +1,11 @@
-import { isKimiK3ModelId, resolveThinkingProfile } from "./provider-policy-api.js";
 import { buildKimiCodingProvider, normalizeKimiCodingModelId } from "./provider-catalog.js";
 import { KIMI_CODING_MODEL_REF, applyKimiCodeConfig } from "./onboard.js";
 import { KIMI_REPLAY_POLICY } from "./replay-policy.js";
 import { wrapKimiProviderStream } from "./stream.js";
-import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth-api-key";
 import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/kimi-coding/openclaw.plugin.json
-var openclaw_plugin_default = {
-	id: "kimi",
-	activation: { "onStartup": false },
-	enabledByDefault: true,
-	providers: ["kimi", "kimi-coding"],
-	providerRequest: { "providers": {
-		"kimi": {
-			"family": "moonshot",
-			"compatibilityFamily": "moonshot"
-		},
-		"kimi-coding": {
-			"family": "moonshot",
-			"compatibilityFamily": "moonshot"
-		}
-	} },
-	modelPricing: { "providers": {
-		"kimi": {
-			"openRouter": { "provider": "moonshotai" },
-			"liteLLM": { "provider": "moonshot" }
-		},
-		"kimi-coding": {
-			"openRouter": { "provider": "moonshotai" },
-			"liteLLM": { "provider": "moonshot" }
-		}
-	} },
-	setup: { "providers": [{
-		"id": "kimi",
-		"envVars": ["KIMI_API_KEY", "KIMICODE_API_KEY"]
-	}, {
-		"id": "kimi-coding",
-		"envVars": ["KIMI_API_KEY", "KIMICODE_API_KEY"]
-	}] },
-	providerAuthChoices: [{
-		"provider": "kimi",
-		"method": "api-key",
-		"choiceId": "kimi-code-api-key",
-		"appGuidedSecret": true,
-		"choiceLabel": "Kimi Code API key (subscription)",
-		"groupId": "moonshot",
-		"groupLabel": "Moonshot AI (Kimi)",
-		"groupHint": "Kimi Code membership · https://www.kimi.com/membership/pricing",
-		"optionKey": "kimiCodeApiKey",
-		"cliFlag": "--kimi-code-api-key",
-		"cliOption": "--kimi-code-api-key <key>",
-		"cliDescription": "Kimi Code API key (subscription)"
-	}],
-	configSchema: {
-		"type": "object",
-		"additionalProperties": false,
-		"properties": {}
-	}
-};
-//#endregion
 //#region extensions/kimi-coding/index.ts
 const PLUGIN_ID = "kimi";
 const PROVIDER_ID = "kimi";
@@ -69,61 +15,83 @@ function findExplicitProviderConfig(providers, providerId) {
 	const match = Object.entries(providers).find(([configuredProviderId]) => normalizeProviderId(configuredProviderId) === normalizedProviderId);
 	return isRecord(match?.[1]) ? match[1] : void 0;
 }
-var kimi_coding_default = defineSingleProviderPluginEntry({
+var kimi_coding_default = definePluginEntry({
 	id: PLUGIN_ID,
 	name: "Kimi Provider",
 	description: "Bundled Kimi provider plugin",
-	manifest: openclaw_plugin_default,
-	provider: {
-		id: PROVIDER_ID,
-		label: "Kimi",
-		aliases: ["kimi-code", "kimi-coding"],
-		docsPath: "/providers/moonshot",
-		envVars: ["KIMI_API_KEY", "KIMICODE_API_KEY"],
-		manifestAuth: {
-			promptMessage: "Enter Kimi API key",
-			defaultModel: KIMI_CODING_MODEL_REF,
-			expectedProviders: [
-				"kimi",
-				"kimi-code",
-				"kimi-coding"
-			],
-			applyConfig: applyKimiCodeConfig,
-			noteMessage: ["Kimi uses a dedicated coding endpoint and API key.", "Get your API key at: https://www.kimi.com/code/console"].join("\n"),
-			noteTitle: "Kimi"
-		},
-		catalog: {
-			order: "simple",
-			run: async (ctx) => {
-				const apiKey = ctx.resolveProviderApiKey(PROVIDER_ID).apiKey;
-				if (!apiKey) return null;
-				const explicitProvider = findExplicitProviderConfig(ctx.config.models?.providers, PROVIDER_ID);
-				const builtInProvider = buildKimiCodingProvider();
-				const explicitBaseUrl = normalizeOptionalString(explicitProvider?.baseUrl) ?? "";
-				const explicitHeaders = isRecord(explicitProvider?.headers) ? explicitProvider.headers : void 0;
-				return { provider: {
-					...builtInProvider,
-					...explicitBaseUrl ? { baseUrl: explicitBaseUrl } : {},
-					...explicitHeaders ? { headers: {
-						...builtInProvider.headers,
-						...explicitHeaders
-					} } : {},
-					apiKey
-				} };
-			}
-		},
-		buildReplayPolicy: () => KIMI_REPLAY_POLICY,
-		normalizeResolvedModel: ({ model }) => {
-			const normalizedId = normalizeKimiCodingModelId(model.id);
-			return normalizedId === model.id ? void 0 : {
-				...model,
-				id: normalizedId
-			};
-		},
-		normalizeModelId: ({ modelId }) => normalizeKimiCodingModelId(modelId),
-		resolveThinkingProfile,
-		wrapSimpleCompletionStreamFn: (ctx) => isKimiK3ModelId(ctx.modelId) ? wrapKimiProviderStream(ctx) : ctx.streamFn,
-		wrapStreamFn: wrapKimiProviderStream
+	register(api) {
+		api.registerProvider({
+			id: PROVIDER_ID,
+			label: "Kimi",
+			aliases: ["kimi-code", "kimi-coding"],
+			docsPath: "/providers/moonshot",
+			envVars: ["KIMI_API_KEY", "KIMICODE_API_KEY"],
+			auth: [createProviderApiKeyAuthMethod({
+				providerId: PROVIDER_ID,
+				methodId: "api-key",
+				label: "Kimi Code API key (subscription)",
+				hint: "Kimi K2.6 + Kimi",
+				optionKey: "kimiCodeApiKey",
+				flagName: "--kimi-code-api-key",
+				envVar: "KIMI_API_KEY",
+				promptMessage: "Enter Kimi API key",
+				defaultModel: KIMI_CODING_MODEL_REF,
+				expectedProviders: [
+					"kimi",
+					"kimi-code",
+					"kimi-coding"
+				],
+				applyConfig: (cfg) => applyKimiCodeConfig(cfg),
+				noteMessage: ["Kimi uses a dedicated coding endpoint and API key.", "Get your API key at: https://www.kimi.com/code/en"].join("\n"),
+				noteTitle: "Kimi",
+				wizard: {
+					choiceId: "kimi-code-api-key",
+					choiceLabel: "Kimi Code API key (subscription)",
+					groupId: "moonshot",
+					groupLabel: "Moonshot AI (Kimi K2.6)",
+					groupHint: "Kimi K2.6"
+				}
+			})],
+			catalog: {
+				order: "simple",
+				run: async (ctx) => {
+					const apiKey = ctx.resolveProviderApiKey(PROVIDER_ID).apiKey;
+					if (!apiKey) return null;
+					const explicitProvider = findExplicitProviderConfig(ctx.config.models?.providers, PROVIDER_ID);
+					const builtInProvider = buildKimiCodingProvider();
+					const explicitBaseUrl = normalizeOptionalString(explicitProvider?.baseUrl) ?? "";
+					const explicitHeaders = isRecord(explicitProvider?.headers) ? explicitProvider.headers : void 0;
+					return { provider: {
+						...builtInProvider,
+						...explicitBaseUrl ? { baseUrl: explicitBaseUrl } : {},
+						...explicitHeaders ? { headers: {
+							...builtInProvider.headers,
+							...explicitHeaders
+						} } : {},
+						apiKey
+					} };
+				}
+			},
+			buildReplayPolicy: () => KIMI_REPLAY_POLICY,
+			normalizeResolvedModel: ({ model }) => {
+				const normalizedId = normalizeKimiCodingModelId(model.id);
+				return normalizedId === model.id ? void 0 : {
+					...model,
+					id: normalizedId
+				};
+			},
+			resolveThinkingProfile: () => ({
+				levels: [{
+					id: "off",
+					label: "off"
+				}, {
+					id: "low",
+					label: "on"
+				}],
+				defaultLevel: "off"
+			}),
+			wrapStreamFn: wrapKimiProviderStream
+		});
 	}
 });
 //#endregion

package/dist/provider-catalog.js

@@ -1,9 +1,7 @@
-import { KIMI_K3_MODEL_IDS } from "./provider-policy-api.js";
 //#region extensions/kimi-coding/provider-catalog.ts
 const KIMI_BASE_URL = "https://api.kimi.com/coding/";
 const KIMI_CODING_USER_AGENT = "claude-code/0.1.0";
 const KIMI_DEFAULT_MODEL_ID = "kimi-for-coding";
-const KIMI_HIGHSPEED_MODEL_ID = "kimi-for-coding-highspeed";
 const KIMI_LEGACY_MODEL_IDS = ["kimi-code", "k2p5"];
 const KIMI_CODING_DEFAULT_CONTEXT_WINDOW = 262144;
 const KIMI_CODING_DEFAULT_MAX_TOKENS = 32768;
@@ -13,63 +11,32 @@ const KIMI_CODING_DEFAULT_COST = {
 	cacheRead: 0,
 	cacheWrite: 0
 };
-const KIMI_K3_COST = {
-	input: 3,
-	output: 15,
-	cacheRead: .3,
-	cacheWrite: 0
-};
-const KIMI_K3_CONTEXT_WINDOW = 1048576;
-const KIMI_K3_MAX_TOKENS = 131072;
-const KIMI_K3_THINKING_LEVEL_MAP = {
-	off: null,
-	minimal: "low",
-	low: "low",
-	medium: "high",
-	high: "high",
-	xhigh: "max",
-	max: "max"
-};
 const KIMI_CODING_INPUT = ["text", "image"];
 function buildKimiCodingProvider() {
 	return {
 		baseUrl: KIMI_BASE_URL,
 		api: "anthropic-messages",
 		headers: { "User-Agent": KIMI_CODING_USER_AGENT },
-		models: [
-			{
-				id: KIMI_DEFAULT_MODEL_ID,
-				name: "Kimi Code",
-				reasoning: true,
-				input: [...KIMI_CODING_INPUT],
-				cost: KIMI_CODING_DEFAULT_COST,
-				contextWindow: KIMI_CODING_DEFAULT_CONTEXT_WINDOW,
-				maxTokens: KIMI_CODING_DEFAULT_MAX_TOKENS
-			},
-			{
-				id: KIMI_HIGHSPEED_MODEL_ID,
-				name: "Kimi K2.7 Code HighSpeed",
-				reasoning: true,
-				input: [...KIMI_CODING_INPUT],
-				cost: KIMI_CODING_DEFAULT_COST,
-				contextWindow: KIMI_CODING_DEFAULT_CONTEXT_WINDOW,
-				maxTokens: KIMI_CODING_DEFAULT_MAX_TOKENS
-			},
-			...KIMI_K3_MODEL_IDS.map((id) => ({
-				id,
-				name: id === "k3" ? "Kimi K3" : "Kimi K3 (256k)",
-				reasoning: true,
-				thinkingLevelMap: { ...KIMI_K3_THINKING_LEVEL_MAP },
-				input: [...KIMI_CODING_INPUT],
-				cost: KIMI_K3_COST,
-				contextWindow: id === "k3" ? KIMI_K3_CONTEXT_WINDOW : KIMI_CODING_DEFAULT_CONTEXT_WINDOW,
-				maxTokens: KIMI_K3_MAX_TOKENS
-			}))
-		]
+		models: [{
+			id: KIMI_DEFAULT_MODEL_ID,
+			name: "Kimi Code",
+			reasoning: true,
+			input: [...KIMI_CODING_INPUT],
+			cost: KIMI_CODING_DEFAULT_COST,
+			contextWindow: KIMI_CODING_DEFAULT_CONTEXT_WINDOW,
+			maxTokens: KIMI_CODING_DEFAULT_MAX_TOKENS
+		}, ...KIMI_LEGACY_MODEL_IDS.map((id) => ({
+			id,
+			name: `Kimi Code (legacy ${id})`,
+			reasoning: true,
+			input: [...KIMI_CODING_INPUT],
+			cost: KIMI_CODING_DEFAULT_COST,
+			contextWindow: KIMI_CODING_DEFAULT_CONTEXT_WINDOW,
+			maxTokens: KIMI_CODING_DEFAULT_MAX_TOKENS
+		}))]
 	};
 }
 function normalizeKimiCodingModelId(modelId) {
-	if (modelId === "k3[1m]") return "k3";
 	return KIMI_LEGACY_MODEL_IDS.includes(modelId) ? KIMI_DEFAULT_MODEL_ID : modelId;
 }
 const KIMI_CODING_BASE_URL = KIMI_BASE_URL;

package/dist/stream.js

@@ -1,7 +1,6 @@
-import { isKimiK3ModelId } from "./provider-policy-api.js";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { streamSimple } from "openclaw/plugin-sdk/llm";
-import { normalizeOpenAICompatibleReasoningReplay, streamWithPayloadPatch } from "openclaw/plugin-sdk/provider-stream-shared";
+import { streamWithPayloadPatch } from "openclaw/plugin-sdk/provider-stream-shared";
 //#region extensions/kimi-coding/stream.ts
 const TOOL_CALLS_SECTION_BEGIN = "<|tool_calls_section_begin|>";
 const TOOL_CALLS_SECTION_END = "<|tool_calls_section_end|>";
@@ -19,15 +18,6 @@ const KIMI_ANTHROPIC_THINKING_BUDGETS = {
 };
 const KIMI_ANTHROPIC_VISIBLE_OUTPUT_RESERVE_TOKENS = 1024;
 const KIMI_ANTHROPIC_MIN_OUTPUT_TOKENS = 16e3;
-const KIMI_K3_THINKING_EFFORTS = {
-	minimal: "low",
-	low: "low",
-	medium: "high",
-	high: "high",
-	adaptive: "high",
-	xhigh: "max",
-	max: "max"
-};
 function normalizeKimiThinkingBudgetTokens(value) {
 	if (typeof value !== "number" || !Number.isFinite(value)) return;
 	const normalized = Math.floor(value);
@@ -44,6 +34,22 @@ function ensureKimiAnthropicMaxTokens(payloadObj, thinkingConfig) {
 	const current = normalizeKimiAnthropicMaxTokens(payloadObj.max_tokens);
 	payloadObj.max_tokens = current === void 0 ? required : Math.max(current, required);
 }
+function messageHasOpenAIToolCalls(message) {
+	return Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+}
+function ensureKimiOpenAIReasoningContent(payloadObj) {
+	if (!Array.isArray(payloadObj.messages)) return;
+	for (const message of payloadObj.messages) {
+		if (!message || typeof message !== "object") continue;
+		const record = message;
+		if (record.role !== "assistant" || !messageHasOpenAIToolCalls(record)) continue;
+		if (!("reasoning_content" in record)) record.reasoning_content = "";
+	}
+}
+function stripKimiOpenAIReasoningContent(payloadObj) {
+	if (!Array.isArray(payloadObj.messages)) return;
+	for (const message of payloadObj.messages) if (message && typeof message === "object") delete message.reasoning_content;
+}
 function normalizeKimiThinkingType(value) {
 	if (typeof value === "boolean") return value ? "enabled" : "disabled";
 	if (typeof value === "string") {
@@ -94,14 +100,8 @@ function resolveKimiThinkingConfig(params) {
 		budget_tokens: levelBudgetTokens
 	};
 }
-function resolveKimiK3ThinkingConfig(params) {
-	const configured = normalizeKimiThinkingConfig(params.configuredThinking);
-	if (configured?.type === "disabled") return { type: "disabled" };
-	if (!configured && params.thinkingLevel === "off") return { type: "disabled" };
-	return {
-		type: "adaptive",
-		effort: params.thinkingLevel && params.thinkingLevel !== "off" ? KIMI_K3_THINKING_EFFORTS[params.thinkingLevel] : "high"
-	};
+function resolveKimiThinkingType(params) {
+	return resolveKimiThinkingConfig(params).type;
 }
 function stripTaggedToolCallCounter(value) {
 	return value.trim().replace(/:\d+$/, "");
@@ -218,56 +218,19 @@ function createKimiToolCallMarkupWrapper(baseStreamFn) {
 		return wrapStreamMessageObjects(maybeStream, rewriteKimiTaggedToolCallsInMessage);
 	};
 }
-function createKimiThinkingWrapper(baseStreamFn, thinkingConfig, k3ThinkingConfig) {
+function createKimiThinkingWrapper(baseStreamFn, thinkingConfig) {
 	const underlying = baseStreamFn ?? streamSimple;
-	return (model, context, options) => {
-		const runtimeModel = model.api === "anthropic-messages" && isKimiK3ModelId(model.id) ? {
-			...model,
-			compat: {
-				...model.compat,
-				allowEmptySignature: true
-			}
-		} : model;
-		return streamWithPayloadPatch(underlying, runtimeModel, context, options, (payloadObj) => {
-			if (model.api === "anthropic-messages" && isKimiK3ModelId(model.id)) {
-				const outputConfig = payloadObj.output_config;
-				if (k3ThinkingConfig.type === "disabled") {
-					payloadObj.thinking = { type: "disabled" };
-					if (outputConfig && typeof outputConfig === "object" && !Array.isArray(outputConfig)) {
-						const nextOutputConfig = { ...outputConfig };
-						delete nextOutputConfig.effort;
-						if (Object.keys(nextOutputConfig).length > 0) payloadObj.output_config = nextOutputConfig;
-						else delete payloadObj.output_config;
-					} else delete payloadObj.output_config;
-				} else {
-					payloadObj.thinking = {
-						type: "adaptive",
-						display: "summarized"
-					};
-					payloadObj.output_config = outputConfig && typeof outputConfig === "object" && !Array.isArray(outputConfig) ? {
-						...outputConfig,
-						effort: k3ThinkingConfig.effort
-					} : { effort: k3ThinkingConfig.effort };
-				}
-				delete payloadObj.reasoning;
-				delete payloadObj.reasoning_effort;
-				delete payloadObj.reasoningEffort;
-				stripAnthropicCacheControlMarkers(payloadObj);
-				return;
-			}
-			const normalized = typeof thinkingConfig === "string" ? { type: thinkingConfig } : thinkingConfig;
-			payloadObj.thinking = model.api === "anthropic-messages" ? { ...normalized } : { type: normalized.type };
-			if (model.api === "anthropic-messages") ensureKimiAnthropicMaxTokens(payloadObj, normalized);
-			else normalizeOpenAICompatibleReasoningReplay(payloadObj, {
-				thinkingEnabled: normalized.type === "enabled",
-				shouldBackfillAssistantMessage: (message) => Array.isArray(message.tool_calls) && message.tool_calls.length > 0
-			});
-			delete payloadObj.reasoning;
-			delete payloadObj.reasoning_effort;
-			delete payloadObj.reasoningEffort;
-			stripAnthropicCacheControlMarkers(payloadObj);
-		});
-	};
+	return (model, context, options) => streamWithPayloadPatch(underlying, model, context, options, (payloadObj) => {
+		const normalized = typeof thinkingConfig === "string" ? { type: thinkingConfig } : thinkingConfig;
+		payloadObj.thinking = model.api === "anthropic-messages" ? { ...normalized } : { type: normalized.type };
+		if (model.api === "anthropic-messages") ensureKimiAnthropicMaxTokens(payloadObj, normalized);
+		else if (normalized.type === "enabled") ensureKimiOpenAIReasoningContent(payloadObj);
+		else stripKimiOpenAIReasoningContent(payloadObj);
+		delete payloadObj.reasoning;
+		delete payloadObj.reasoning_effort;
+		delete payloadObj.reasoningEffort;
+		stripAnthropicCacheControlMarkers(payloadObj);
+	});
 }
 function stripContentBlockCacheControl(block) {
 	if (!block || typeof block !== "object") return;
@@ -292,11 +255,7 @@ function wrapKimiProviderStream(ctx) {
 		configuredThinking: ctx.extraParams?.thinking,
 		thinkingLevel: ctx.thinkingLevel
 	});
-	const k3ThinkingConfig = resolveKimiK3ThinkingConfig({
-		configuredThinking: ctx.extraParams?.thinking,
-		thinkingLevel: ctx.thinkingLevel
-	});
-	return createKimiToolCallMarkupWrapper(createKimiThinkingWrapper(ctx.streamFn, thinkingConfig, k3ThinkingConfig));
+	return createKimiToolCallMarkupWrapper(createKimiThinkingWrapper(ctx.streamFn, thinkingConfig));
 }
 //#endregion
-export { wrapKimiProviderStream };
+export { createKimiThinkingWrapper, createKimiToolCallMarkupWrapper, resolveKimiThinkingType, wrapKimiProviderStream };

package/openclaw.plugin.json

@@ -57,8 +57,8 @@
       "appGuidedSecret": true,
       "choiceLabel": "Kimi Code API key (subscription)",
       "groupId": "moonshot",
-      "groupLabel": "Moonshot AI (Kimi)",
-      "groupHint": "Kimi Code membership · https://www.kimi.com/membership/pricing",
+      "groupLabel": "Moonshot AI (Kimi K2.6)",
+      "groupHint": "Kimi K2.6",
       "optionKey": "kimiCodeApiKey",
       "cliFlag": "--kimi-code-api-key",
       "cliOption": "--kimi-code-api-key <key>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/kimi-provider",
-  "version": "2026.7.2-beta.5",
+  "version": "2026.7.33",
   "description": "OpenClaw Kimi provider plugin.",
   "repository": {
     "type": "git",
@@ -18,10 +18,10 @@
       "minHostVersion": ">=2026.6.8"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.5"
+      "pluginApi": ">=2026.7.33"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.5",
+      "openclawVersion": "2026.7.33",
       "bundledDist": false
     },
     "release": {
@@ -38,7 +38,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.5"
+    "openclaw": ">=2026.7.33"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/provider-policy-api.js

@@ -1,36 +0,0 @@
-//#region extensions/kimi-coding/provider-policy-api.ts
-const KIMI_K3_MODEL_IDS = ["k3", "k3-256k"];
-const KIMI_K3_LEGACY_MODEL_IDS = ["k3[1m]"];
-const KIMI_K3_THINKING_LEVELS = [
-	{ id: "off" },
-	{ id: "minimal" },
-	{ id: "low" },
-	{ id: "medium" },
-	{ id: "high" },
-	{ id: "adaptive" },
-	{ id: "xhigh" },
-	{ id: "max" }
-];
-function isKimiK3ModelId(modelId) {
-	const normalized = modelId.trim().toLowerCase();
-	return KIMI_K3_MODEL_IDS.includes(normalized) || KIMI_K3_LEGACY_MODEL_IDS.includes(normalized);
-}
-function resolveThinkingProfile({ modelId }) {
-	if (isKimiK3ModelId(modelId)) return {
-		levels: KIMI_K3_THINKING_LEVELS,
-		defaultLevel: "high",
-		preserveWhenCatalogReasoningFalse: true
-	};
-	return {
-		levels: [{
-			id: "off",
-			label: "off"
-		}, {
-			id: "low",
-			label: "on"
-		}],
-		defaultLevel: "off"
-	};
-}
-//#endregion
-export { KIMI_K3_MODEL_IDS, isKimiK3ModelId, resolveThinkingProfile };