@openclaw/kilocode-provider 0.0.0 → 2026.6.9

package/README.md

@@ -1,3 +1,12 @@
-# @openclaw/kilocode-provider
+# OpenClaw Kilo Gateway Provider
 
-Reserved placeholder for the official OpenClaw plugin package. Use a published release version instead.
+Official OpenClaw provider plugin for Kilo Gateway.
+
+Install from OpenClaw:
+
+```bash
+openclaw plugins install @openclaw/kilocode-provider
+openclaw gateway restart
+```
+
+See <https://docs.openclaw.ai/providers/kilocode> for setup and configuration.

package/dist/api.js

@@ -0,0 +1,3 @@
+import { KILOCODE_BASE_URL, KILOCODE_DEFAULT_CONTEXT_WINDOW, KILOCODE_DEFAULT_COST, KILOCODE_DEFAULT_MAX_TOKENS, KILOCODE_DEFAULT_MODEL_ID, KILOCODE_DEFAULT_MODEL_NAME, KILOCODE_DEFAULT_MODEL_REF, KILOCODE_MODELS_URL, KILOCODE_MODEL_CATALOG, buildKilocodeModelDefinition, discoverKilocodeModels } from "./provider-models.js";
+import { buildKilocodeProvider, buildKilocodeProviderWithDiscovery } from "./provider-catalog.js";
+export { KILOCODE_BASE_URL, KILOCODE_DEFAULT_CONTEXT_WINDOW, KILOCODE_DEFAULT_COST, KILOCODE_DEFAULT_MAX_TOKENS, KILOCODE_DEFAULT_MODEL_ID, KILOCODE_DEFAULT_MODEL_NAME, KILOCODE_DEFAULT_MODEL_REF, KILOCODE_MODELS_URL, KILOCODE_MODEL_CATALOG, buildKilocodeModelDefinition, buildKilocodeProvider, buildKilocodeProviderWithDiscovery, discoverKilocodeModels };

package/dist/index.js

@@ -0,0 +1,42 @@
+import { KILOCODE_DEFAULT_MODEL_REF } from "./provider-models.js";
+import { buildKilocodeProvider, buildKilocodeProviderWithDiscovery } from "./provider-catalog.js";
+import { applyKilocodeConfig } from "./onboard.js";
+import { wrapKilocodeProviderStream } from "./stream.js";
+import { readConfiguredProviderCatalogEntries } from "openclaw/plugin-sdk/provider-catalog-shared";
+import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";
+import { PASSTHROUGH_GEMINI_REPLAY_HOOKS } from "openclaw/plugin-sdk/provider-model-shared";
+//#region extensions/kilocode/index.ts
+const PROVIDER_ID = "kilocode";
+var kilocode_default = defineSingleProviderPluginEntry({
+	id: PROVIDER_ID,
+	name: "Kilo Gateway Provider",
+	description: "Bundled Kilo Gateway provider plugin",
+	provider: {
+		label: "Kilo Gateway",
+		docsPath: "/providers/kilocode",
+		auth: [{
+			methodId: "api-key",
+			label: "Kilo Gateway API key",
+			hint: "API key (OpenRouter-compatible)",
+			optionKey: "kilocodeApiKey",
+			flagName: "--kilocode-api-key",
+			envVar: "KILOCODE_API_KEY",
+			promptMessage: "Enter Kilo Gateway API key",
+			defaultModel: KILOCODE_DEFAULT_MODEL_REF,
+			applyConfig: (cfg) => applyKilocodeConfig(cfg)
+		}],
+		catalog: {
+			buildProvider: buildKilocodeProviderWithDiscovery,
+			buildStaticProvider: buildKilocodeProvider
+		},
+		augmentModelCatalog: ({ config }) => readConfiguredProviderCatalogEntries({
+			config,
+			providerId: PROVIDER_ID
+		}),
+		...PASSTHROUGH_GEMINI_REPLAY_HOOKS,
+		wrapStreamFn: wrapKilocodeProviderStream,
+		isCacheTtlEligible: (ctx) => ctx.modelId.startsWith("anthropic/")
+	}
+});
+//#endregion
+export { kilocode_default as default };

package/dist/onboard.js

@@ -0,0 +1,22 @@
+import { KILOCODE_BASE_URL, KILOCODE_DEFAULT_MODEL_REF } from "./provider-models.js";
+import { buildKilocodeProvider } from "./provider-catalog.js";
+import { createModelCatalogPresetAppliers } from "openclaw/plugin-sdk/provider-onboard";
+//#region extensions/kilocode/onboard.ts
+const kilocodePresetAppliers = createModelCatalogPresetAppliers({
+	primaryModelRef: KILOCODE_DEFAULT_MODEL_REF,
+	resolveParams: (_cfg) => ({
+		providerId: "kilocode",
+		api: "openai-completions",
+		baseUrl: KILOCODE_BASE_URL,
+		catalogModels: buildKilocodeProvider().models ?? [],
+		aliases: [{
+			modelRef: KILOCODE_DEFAULT_MODEL_REF,
+			alias: "Kilo Gateway"
+		}]
+	})
+});
+function applyKilocodeConfig(cfg) {
+	return kilocodePresetAppliers.applyConfig(cfg);
+}
+//#endregion
+export { KILOCODE_BASE_URL, KILOCODE_DEFAULT_MODEL_REF, applyKilocodeConfig };

package/dist/provider-catalog.js

@@ -0,0 +1,26 @@
+import { KILOCODE_BASE_URL, KILOCODE_DEFAULT_COST, KILOCODE_MODEL_CATALOG, discoverKilocodeModels } from "./provider-models.js";
+//#region extensions/kilocode/provider-catalog.ts
+function buildKilocodeProvider() {
+	return {
+		baseUrl: KILOCODE_BASE_URL,
+		api: "openai-completions",
+		models: KILOCODE_MODEL_CATALOG.map((model) => ({
+			id: model.id,
+			name: model.name,
+			reasoning: model.reasoning,
+			input: model.input,
+			cost: KILOCODE_DEFAULT_COST,
+			contextWindow: model.contextWindow ?? 1e6,
+			maxTokens: model.maxTokens ?? 128e3
+		}))
+	};
+}
+async function buildKilocodeProviderWithDiscovery() {
+	return {
+		baseUrl: KILOCODE_BASE_URL,
+		api: "openai-completions",
+		models: await discoverKilocodeModels()
+	};
+}
+//#endregion
+export { buildKilocodeProvider, buildKilocodeProviderWithDiscovery };

package/dist/provider-models.js

@@ -0,0 +1,137 @@
+import { readProviderJsonArrayFieldResponse } from "openclaw/plugin-sdk/provider-http";
+import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+import { fetchWithSsrFGuard, ssrfPolicyFromHttpBaseUrlAllowedHostname } from "openclaw/plugin-sdk/ssrf-runtime";
+import { asPositiveSafeInteger, normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/kilocode/provider-models.ts
+const log = createSubsystemLogger("kilocode-models");
+const KILOCODE_BASE_URL = "https://api.kilo.ai/api/gateway/";
+const KILOCODE_DEFAULT_MODEL_ID = "kilo/auto";
+const KILOCODE_DEFAULT_MODEL_REF = `kilocode/${KILOCODE_DEFAULT_MODEL_ID}`;
+const KILOCODE_DEFAULT_MODEL_NAME = "Kilo Auto";
+const KILOCODE_MODEL_CATALOG = [{
+	id: KILOCODE_DEFAULT_MODEL_ID,
+	name: KILOCODE_DEFAULT_MODEL_NAME,
+	input: ["text", "image"],
+	reasoning: true
+}];
+const KILOCODE_DEFAULT_CONTEXT_WINDOW = 1e6;
+const KILOCODE_DEFAULT_MAX_TOKENS = 128e3;
+const KILOCODE_DEFAULT_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+};
+const KILOCODE_MODELS_URL = `${KILOCODE_BASE_URL}models`;
+const DISCOVERY_TIMEOUT_MS = 5e3;
+function toPricePerMillion(perToken) {
+	if (!perToken) return 0;
+	const num = Number(perToken);
+	if (!Number.isFinite(num) || num < 0) return 0;
+	return num * 1e6;
+}
+function parseModality(entry) {
+	const modalities = entry.architecture?.input_modalities;
+	if (!Array.isArray(modalities)) return ["text"];
+	return modalities.some((m) => typeof m === "string" && normalizeLowercaseStringOrEmpty(m) === "image") ? ["text", "image"] : ["text"];
+}
+function parseReasoning(entry) {
+	const params = entry.supported_parameters;
+	if (!Array.isArray(params)) return false;
+	return params.includes("reasoning") || params.includes("include_reasoning");
+}
+function toModelDefinition(entry) {
+	return {
+		id: entry.id,
+		name: entry.name || entry.id,
+		reasoning: parseReasoning(entry),
+		input: parseModality(entry),
+		cost: {
+			input: toPricePerMillion(entry.pricing.prompt),
+			output: toPricePerMillion(entry.pricing.completion),
+			cacheRead: toPricePerMillion(entry.pricing.input_cache_read),
+			cacheWrite: toPricePerMillion(entry.pricing.input_cache_write)
+		},
+		contextWindow: asPositiveSafeInteger(entry.context_length) ?? 1e6,
+		maxTokens: asPositiveSafeInteger(entry.top_provider?.max_completion_tokens) ?? 128e3
+	};
+}
+function buildStaticCatalog() {
+	return KILOCODE_MODEL_CATALOG.map((model) => ({
+		id: model.id,
+		name: model.name,
+		reasoning: model.reasoning,
+		input: model.input,
+		cost: KILOCODE_DEFAULT_COST,
+		contextWindow: model.contextWindow ?? 1e6,
+		maxTokens: model.maxTokens ?? 128e3
+	}));
+}
+function asGatewayModelEntry(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Kilocode model list: malformed JSON response");
+	const entry = value;
+	if (typeof entry.id !== "string" || typeof entry.pricing !== "object" || entry.pricing === null || Array.isArray(entry.pricing)) throw new Error("Kilocode model list: malformed JSON response");
+	return value;
+}
+function readGatewayModelId(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return "";
+	const id = value.id;
+	return typeof id === "string" ? id.trim() : "";
+}
+async function discoverKilocodeModels() {
+	if (process.env.VITEST) return buildStaticCatalog();
+	try {
+		const { response, release } = await fetchWithSsrFGuard({
+			url: KILOCODE_MODELS_URL,
+			init: { headers: { Accept: "application/json" } },
+			timeoutMs: DISCOVERY_TIMEOUT_MS,
+			policy: ssrfPolicyFromHttpBaseUrlAllowedHostname(KILOCODE_BASE_URL),
+			auditContext: "kilocode.model_discovery"
+		});
+		try {
+			if (!response.ok) {
+				log.warn(`Failed to discover models: HTTP ${response.status}, using static catalog`);
+				return buildStaticCatalog();
+			}
+			const data = await readProviderJsonArrayFieldResponse(response, "Kilocode model list", "data");
+			if (data.length === 0) {
+				log.warn("No models found from gateway API, using static catalog");
+				return buildStaticCatalog();
+			}
+			const models = [];
+			const discoveredIds = /* @__PURE__ */ new Set();
+			for (const rawEntry of data) {
+				const id = readGatewayModelId(rawEntry);
+				try {
+					const entry = asGatewayModelEntry(rawEntry);
+					if (!id || discoveredIds.has(id)) continue;
+					models.push(toModelDefinition(entry));
+					discoveredIds.add(id);
+				} catch (e) {
+					log.warn(`Skipping malformed model entry "${id}": ${String(e)}`);
+				}
+			}
+			const staticModels = buildStaticCatalog();
+			for (const staticModel of staticModels) if (!discoveredIds.has(staticModel.id)) models.unshift(staticModel);
+			return models.length > 0 ? models : buildStaticCatalog();
+		} finally {
+			await release();
+		}
+	} catch (error) {
+		log.warn(`Discovery failed: ${String(error)}, using static catalog`);
+		return buildStaticCatalog();
+	}
+}
+function buildKilocodeModelDefinition() {
+	return {
+		id: KILOCODE_DEFAULT_MODEL_ID,
+		name: KILOCODE_DEFAULT_MODEL_NAME,
+		reasoning: true,
+		input: ["text", "image"],
+		cost: KILOCODE_DEFAULT_COST,
+		contextWindow: KILOCODE_DEFAULT_CONTEXT_WINDOW,
+		maxTokens: KILOCODE_DEFAULT_MAX_TOKENS
+	};
+}
+//#endregion
+export { KILOCODE_BASE_URL, KILOCODE_DEFAULT_CONTEXT_WINDOW, KILOCODE_DEFAULT_COST, KILOCODE_DEFAULT_MAX_TOKENS, KILOCODE_DEFAULT_MODEL_ID, KILOCODE_DEFAULT_MODEL_NAME, KILOCODE_DEFAULT_MODEL_REF, KILOCODE_MODELS_URL, KILOCODE_MODEL_CATALOG, buildKilocodeModelDefinition, discoverKilocodeModels };

package/dist/stream.js

@@ -0,0 +1,83 @@
+import { resolveProviderRequestHeaders } from "openclaw/plugin-sdk/provider-http";
+import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/kilocode/stream.ts
+const KILOCODE_FEATURE_HEADER = "X-KILOCODE-FEATURE";
+const KILOCODE_FEATURE_DEFAULT = "openclaw";
+const KILOCODE_FEATURE_ENV_VAR = "KILOCODE_FEATURE";
+function resolveKilocodeAppHeaders() {
+	const feature = process.env[KILOCODE_FEATURE_ENV_VAR]?.trim() || KILOCODE_FEATURE_DEFAULT;
+	return { [KILOCODE_FEATURE_HEADER]: feature };
+}
+function mapThinkingLevelToReasoningEffort(thinkingLevel) {
+	if (thinkingLevel === "off") return "none";
+	if (thinkingLevel === "adaptive") return "medium";
+	if (thinkingLevel === "max") return "xhigh";
+	return thinkingLevel;
+}
+function normalizeKilocodeReasoningPayload(payloadObj, thinkingLevel) {
+	delete payloadObj.reasoning_effort;
+	if (!thinkingLevel || thinkingLevel === "off") return;
+	const existingReasoning = payloadObj.reasoning;
+	if (existingReasoning && typeof existingReasoning === "object" && !Array.isArray(existingReasoning)) {
+		const reasoningObj = existingReasoning;
+		if (!("max_tokens" in reasoningObj) && !("effort" in reasoningObj)) reasoningObj.effort = mapThinkingLevelToReasoningEffort(thinkingLevel);
+	} else if (!existingReasoning) payloadObj.reasoning = { effort: mapThinkingLevelToReasoningEffort(thinkingLevel) };
+}
+function normalizeKilocodeStopPayload(payloadObj) {
+	if (typeof payloadObj.stop === "string") payloadObj.stop = [payloadObj.stop];
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function normalizeKilocodeStopAfterCaller(value, fallbackPayload) {
+	const replacementPayload = asRecord(value);
+	if (replacementPayload) {
+		normalizeKilocodeStopPayload(replacementPayload);
+		return value;
+	}
+	if (fallbackPayload) normalizeKilocodeStopPayload(fallbackPayload);
+	return value;
+}
+function isProxyReasoningUnsupported(modelId) {
+	const trimmed = normalizeOptionalLowercaseString(modelId);
+	const slashIndex = trimmed?.indexOf("/") ?? -1;
+	return slashIndex > 0 && trimmed?.slice(0, slashIndex) === "x-ai";
+}
+function resolveKilocodeThinkingLevel(ctx) {
+	if (ctx.modelId === "kilo/auto" || isProxyReasoningUnsupported(ctx.modelId)) return;
+	return ctx.thinkingLevel;
+}
+function createKilocodeStreamWrapper(baseStreamFn, thinkingLevel) {
+	if (!baseStreamFn) return;
+	const underlying = baseStreamFn;
+	return (model, context, options) => {
+		const originalOnPayload = options?.onPayload;
+		const headers = resolveProviderRequestHeaders({
+			provider: typeof model.provider === "string" ? model.provider : "kilocode",
+			api: model.api,
+			baseUrl: typeof model.baseUrl === "string" ? model.baseUrl : void 0,
+			capability: "llm",
+			transport: "stream",
+			callerHeaders: options?.headers,
+			defaultHeaders: resolveKilocodeAppHeaders(),
+			precedence: "defaults-win"
+		});
+		return underlying(model, context, {
+			...options,
+			headers,
+			onPayload(payload, payloadModel) {
+				const payloadObj = asRecord(payload);
+				if (payloadObj) normalizeKilocodeReasoningPayload(payloadObj, thinkingLevel);
+				const result = originalOnPayload?.(payload, payloadModel);
+				if (result && typeof result.then === "function") return Promise.resolve(result).then((resolved) => normalizeKilocodeStopAfterCaller(resolved, payloadObj));
+				return normalizeKilocodeStopAfterCaller(result, payloadObj);
+			}
+		});
+	};
+}
+function wrapKilocodeProviderStream(ctx) {
+	if (normalizeOptionalLowercaseString(ctx.provider) !== "kilocode") return;
+	return createKilocodeStreamWrapper(ctx.streamFn, resolveKilocodeThinkingLevel(ctx));
+}
+//#endregion
+export { createKilocodeStreamWrapper, wrapKilocodeProviderStream };

package/npm-shrinkwrap.json

@@ -0,0 +1,12 @@
+{
+  "name": "@openclaw/kilocode-provider",
+  "version": "2026.6.9",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@openclaw/kilocode-provider",
+      "version": "2026.6.9"
+    }
+  }
+}

package/openclaw.plugin.json

@@ -0,0 +1,76 @@
+{
+  "id": "kilocode",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providers": ["kilocode"],
+  "modelPricing": {
+    "providers": {
+      "kilocode": {
+        "openRouter": {
+          "passthroughProviderModel": true
+        },
+        "liteLLM": {
+          "passthroughProviderModel": true
+        }
+      }
+    }
+  },
+  "setup": {
+    "providers": [
+      {
+        "id": "kilocode",
+        "envVars": ["KILOCODE_API_KEY"]
+      }
+    ]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "kilocode",
+      "method": "api-key",
+      "choiceId": "kilocode-api-key",
+      "choiceLabel": "Kilo Gateway API key",
+      "choiceHint": "API key (OpenRouter-compatible)",
+      "groupId": "kilocode",
+      "groupLabel": "Kilo Gateway",
+      "groupHint": "API key (OpenRouter-compatible)",
+      "optionKey": "kilocodeApiKey",
+      "cliFlag": "--kilocode-api-key",
+      "cliOption": "--kilocode-api-key <key>",
+      "cliDescription": "Kilo Gateway API key"
+    }
+  ],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  },
+  "modelCatalog": {
+    "providers": {
+      "kilocode": {
+        "baseUrl": "https://api.kilo.ai/api/gateway/",
+        "api": "openai-completions",
+        "models": [
+          {
+            "id": "kilo/auto",
+            "name": "Kilo Auto",
+            "reasoning": true,
+            "input": ["text", "image"],
+            "cost": {
+              "input": 0,
+              "output": 0,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            },
+            "contextWindow": 1000000,
+            "maxTokens": 128000
+          }
+        ]
+      }
+    },
+    "discovery": {
+      "kilocode": "refreshable"
+    }
+  }
+}

package/package.json

@@ -1,14 +1,50 @@
 {
   "name": "@openclaw/kilocode-provider",
-  "version": "0.0.0",
-  "description": "Reserved package name for an official OpenClaw plugin.",
-  "license": "MIT",
+  "version": "2026.6.9",
+  "description": "OpenClaw Kilo Gateway provider plugin.",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/openclaw/openclaw.git"
+    "url": "https://github.com/openclaw/openclaw"
   },
-  "publishConfig": {
-    "access": "public",
-    "tag": "placeholder"
-  }
+  "type": "module",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "clawhubSpec": "clawhub:@openclaw/kilocode-provider",
+      "npmSpec": "@openclaw/kilocode-provider",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.6.8"
+    },
+    "compat": {
+      "pluginApi": ">=2026.6.9"
+    },
+    "build": {
+      "openclawVersion": "2026.6.9",
+      "bundledDist": false
+    },
+    "release": {
+      "publishToClawHub": true,
+      "publishToNpm": true
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ]
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json",
+    "npm-shrinkwrap.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.6.9"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "bundledDependencies": []
 }