pi-provider-kimi-code 0.1.7 → 0.1.9

package/README.md

@@ -38,21 +38,100 @@ KIMI_API_KEY=sk-... pi
 
 ## Models
 
-| ID                 | Name             | Reasoning | Input       | Context  | Max Output |
-|--------------------|------------------|-----------|-------------|----------|------------|
-| `kimi-k2-thinking` | Kimi K2 Thinking | yes       | text        | 262 144  | 32 768     |
-| `k2p5`             | Kimi K2.5        | yes       | text, image | 262 144  | 32 768     |
+| ID                       | Name                             | Reasoning | Input       | Context | Max Output |
+| ------------------------ | -------------------------------- | --------- | ----------- | ------- | ---------- |
+| `kimi-code`              | Kimi Code (powered by kimi-k2.5) | yes       | text, image | 262 144 | 32 000     |
+| `kimi-k2.5`              | Kimi K2.5                        | yes       | text, image | 262 144 | 32 000     |
+| `kimi-k2-thinking-turbo` | Kimi K2 Thinking Turbo           | yes       | text        | 262 144 | 32 000     |
 
 Select a model inside pi:
 
 ```
-/model kimi-coding/kimi-k2-thinking
+/model kimi-coding/kimi-code
 ```
 
+## Environment Overrides
+
+- `KIMI_CODE_BASE_URL` — override the default API base URL (default depends on protocol; see below)
+- `KIMI_CODE_OAUTH_HOST` — override the OAuth host
+- `KIMI_OAUTH_HOST` — fallback OAuth host override for compatibility
+- `KIMI_CODE_PROTOCOL` — choose protocol mode:
+  - unset / `anthropic` → `anthropic-messages` via `/coding/v1/messages`
+  - `openai` → `openai-completions` via `/coding/v1/chat/completions`
+- `KIMI_MODEL_TEMPERATURE` — force temperature on outbound requests
+- `KIMI_MODEL_TOP_P` — force top-p on outbound requests
+- `KIMI_MODEL_MAX_TOKENS` — force max tokens on outbound requests
+- `KIMI_CODE_DEBUG=1` — print provider-side debug logs (request metadata, file upload logs)
+
+## Prompt Caching
+
+Kimi Code API requires a `prompt_cache_key` field at the payload root for prompt caching. The pi framework separately injects Anthropic-style `cache_control: { type: "ephemeral" }` markers. This extension bridges both:
+
+1. **Session key injection**: Extracts your current pi `sessionId` and injects it as `prompt_cache_key` on every request.
+2. **TTL**: Approximately **5-10 minutes**. Consistently hits at 300s, borderline at 600s, misses at 900s. Measure in your environment with `KIMI_E2E_ONLY_CACHE=1` (see [E2E test script](#end-to-end-test-script)).
+3. **Manual override**: Set `prompt_cache_key` explicitly in the payload or options to override the automatic session-based key.
+
+Cache usage is easiest to verify on the Anthropic-compatible endpoint, which returns `cache_read_input_tokens` / `cache_creation_input_tokens` fields.
+
+## OpenAI Compatibility Mode
+
+Set `KIMI_CODE_PROTOCOL=openai` to switch the provider to Kimi Coding's OpenAI-compatible chat completions endpoint. Internally this extension uses `openai-completions` (not `openai-responses`) and applies Kimi-specific compatibility overrides:
+
+- Maps `developer` role to `system` (Kimi does not recognize the OpenAI `developer` role)
+- Disables `store`
+- Uses `max_tokens`
+- Sends `KimiCLI/*` + `X-Msh-*` agent headers required by the Coding endpoint
+
+## End-to-End Test Script
+
+This repo includes a tracked smoke-test script:
+
+```bash
+KIMI_API_KEY=sk-... ./test_e2e.sh
+```
+
+By default it explicitly targets `--model kimi-coding/kimi-code`, disables extension discovery with `-ne`, and turns on provider debug logging.
+
+What it does:
+
+1. Runs a `pi -ne -e <extension-dir>` smoke test in Anthropic mode.
+2. Runs the same smoke test in OpenAI mode.
+3. Runs a high-thinking smoke test (saves full JSONL, extracts thinking + answer + usage).
+4. Runs a prompt-cache TTL probe and prints a conclusion on observed cache lifetime.
+5. Uploads a watermarked image to `/files`, then asks the model to read back the watermark via `ms://` reference.
+6. Sends a `prompt_cache_key` request directly to verify cache key injection.
+
+Useful environment variables for the test script:
+
+| Variable                   | Default                 | Description                             |
+| -------------------------- | ----------------------- | --------------------------------------- |
+| `KIMI_API_KEY`             | (required)              | API key (or pass as positional arg)     |
+| `KIMI_CODE_DEBUG`          | `1`                     | Provider debug logs                     |
+| `KIMI_E2E_VERBOSE`         | `1`                     | Command and environment diagnostics     |
+| `KIMI_E2E_MODEL`           | `kimi-coding/kimi-code` | Model for `pi` smoke tests              |
+| `KIMI_E2E_CACHE_INTERVALS` | `60,300`                | Absolute seconds from warmup per probe  |
+| `KIMI_E2E_CACHE_KEY`       | auto                    | Override cache key for TTL probe        |
+| `KIMI_E2E_CACHE_REPEAT`    | `2000`                  | Long-text repeat count for cache warmup |
+| `KIMI_E2E_SKIP_CACHE`      | `0`                     | Set `1` to skip the cache TTL phase     |
+| `KIMI_E2E_ONLY_CACHE`      | `0`                     | Set `1` to run only the cache TTL test  |
+
+### Proxy / networking note
+
+If `curl` can reach Kimi but `pi` reports `fetch failed`, check your `http_proxy` / `https_proxy` / `all_proxy` environment. `pi` runs on Node's `fetch` / undici stack, which may behave differently from `curl`; the test script prints the effective proxy-related environment for easier debugging.
+
 ## How It Works
 
-- Registers provider `kimi-coding` with base URL `https://api.kimi.com/coding`
-- Uses `api: "anthropic-messages"` — Kimi's API is wire-compatible with the Anthropic Messages format, so no custom streaming logic is needed
+- Registers provider `kimi-coding` with Kimi's API endpoint
+- Supports two protocol modes:
+  - `anthropic-messages` (default)
+  - `openai-completions` when `KIMI_CODE_PROTOCOL=openai`
+- Adds a small `streamSimple` wrapper to suppress Kimi's leaked `(Empty response: ...)` placeholder blocks
+- Injects `prompt_cache_key` automatically so Kimi's cache works with pi sessions
+- Maps pi thinking levels to Kimi-native `reasoning_effort` + `extra_body.thinking`
+- Pre-uploads large image / video attachments to Kimi Files API (returns `ms://` references)
+- Maps `developer` role to `system` for OpenAI protocol compatibility
+- Sends the same `KimiCLI/1.30.0` + `X-Msh-*` headers as current `kimi-cli`
+- Persists a stable device ID at `~/.pi/providers/kimi-coding/device_id`
 - OAuth uses [RFC 8628](https://datatracker.ietf.org/doc/html/rfc8628) device authorization grant against `https://auth.kimi.com`
 - Zero dependencies — types from `@mariozechner/pi-ai` and `@mariozechner/pi-coding-agent` are provided by the pi runtime
 - Zero build step — pi loads TypeScript directly via jiti

package/index.ts

@@ -9,10 +9,24 @@
  *   # Then /login kimi-coding, or set KIMI_API_KEY=...
  */
 
+import { execSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
-import type { OAuthCredentials, OAuthLoginCallbacks, AssistantMessageEvent, Context, Model, SimpleStreamOptions } from "@mariozechner/pi-ai";
-import { streamSimpleAnthropic, AssistantMessageEventStream } from "@mariozechner/pi-ai";
+import { dirname, join } from "node:path";
+import type {
+  OAuthCredentials,
+  OAuthLoginCallbacks,
+  AssistantMessageEvent,
+  Context,
+  Model,
+  SimpleStreamOptions,
+} from "@mariozechner/pi-ai";
+import {
+  streamSimpleAnthropic,
+  streamSimpleOpenAICompletions,
+  AssistantMessageEventStream,
+} from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
 // =============================================================================
@@ -20,52 +34,131 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 // =============================================================================
 
 const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
-const OAUTH_HOST = "https://auth.kimi.com";
-const KIMI_CLI_USER_AGENT = "KimiCLI/1.0.0";
+const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
+const PROTOCOL =
+  process.env.KIMI_CODE_PROTOCOL === "openai" ? "openai-completions" : "anthropic-messages";
+const DEFAULT_BASE_URL =
+  PROTOCOL === "openai-completions"
+    ? "https://api.kimi.com/coding/v1"
+    : "https://api.kimi.com/coding";
+const KIMI_CLI_VERSION = "1.30.0";
+const KIMI_CLI_USER_AGENT = `KimiCLI/${KIMI_CLI_VERSION}`;
 const KIMI_PLATFORM = "kimi_cli";
-const KIMI_CLI_VERSION = "1.0.0";
+const DEVICE_ID_PATH = join(os.homedir(), ".pi", "providers", "kimi-coding", "device_id");
 
 // =============================================================================
 // Device identification
 // =============================================================================
 
+function getOAuthHost(): string {
+  const value =
+    process.env.KIMI_CODE_OAUTH_HOST || process.env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST;
+  return value.trim() || DEFAULT_OAUTH_HOST;
+}
+
+function getBaseUrl(): string {
+  const value = process.env.KIMI_CODE_BASE_URL || DEFAULT_BASE_URL;
+  return value.trim() || DEFAULT_BASE_URL;
+}
+
 function createDeviceId(): string {
-	return randomBytes(16).toString("hex");
+  return randomBytes(16).toString("hex");
+}
+
+function ensurePrivateFile(path: string): void {
+  try {
+    chmodSync(path, 0o600);
+  } catch {
+    // Ignore chmod failures on platforms/filesystems that do not support it.
+  }
+}
+
+function readPersistedDeviceId(): string | null {
+  try {
+    if (!existsSync(DEVICE_ID_PATH)) return null;
+    const deviceId = readFileSync(DEVICE_ID_PATH, "utf8").trim();
+    return deviceId || null;
+  } catch {
+    return null;
+  }
+}
+
+function persistDeviceId(deviceId: string): void {
+  try {
+    mkdirSync(dirname(DEVICE_ID_PATH), { recursive: true });
+    writeFileSync(DEVICE_ID_PATH, deviceId, "utf8");
+    ensurePrivateFile(DEVICE_ID_PATH);
+  } catch {
+    // Ignore persistence failures and fall back to the in-memory device id.
+  }
+}
+
+function getMacOSVersion(): string {
+  try {
+    return execSync("sw_vers -productVersion", { encoding: "utf8" }).trim();
+  } catch {
+    return os.release();
+  }
 }
 
 function getDeviceModel(): string {
-	const platform = process.platform;
-	const arch = os.machine() || process.arch;
-	const release = os.release();
-	if (platform === "darwin") {
-		return release && arch ? `macOS ${release} ${arch}` : `macOS ${arch}`;
-	}
-	if (platform === "win32") {
-		return release && arch ? `Windows ${release} ${arch}` : `Windows ${arch}`;
-	}
-	return release && arch ? `${platform} ${release} ${arch}` : `${platform} ${arch}`;
+  const platform = process.platform;
+  const arch = os.machine() || process.arch;
+  if (platform === "darwin") {
+    const version = getMacOSVersion();
+    return version && arch ? `macOS ${version} ${arch}` : `macOS ${arch}`;
+  }
+  if (platform === "win32") {
+    const release = os.release();
+    return release && arch ? `Windows ${release} ${arch}` : `Windows ${arch}`;
+  }
+  const release = os.release();
+  return release && arch ? `${platform} ${release} ${arch}` : `${platform} ${arch}`;
+}
+
+function asciiHeaderValue(value: string, fallback = "unknown"): string {
+  const trimmed = value.trim();
+  /* oxlint-disable-next-line no-control-regex */
+  if (/^[\x00-\x7F]*$/.test(trimmed)) {
+    return trimmed;
+  }
+  /* oxlint-disable-next-line no-control-regex */
+  const sanitized = trimmed.replace(/[^\x00-\x7F]/g, "").trim();
+  return sanitized || fallback;
 }
 
 const DEVICE_MODEL = getDeviceModel();
 let DEVICE_ID: string | null = null;
 
 function getStableDeviceId(): string {
-	if (!DEVICE_ID) {
-		DEVICE_ID = createDeviceId();
-	}
-	return DEVICE_ID;
+  if (DEVICE_ID) {
+    return DEVICE_ID;
+  }
+
+  const persisted = readPersistedDeviceId();
+  if (persisted) {
+    DEVICE_ID = persisted;
+    return DEVICE_ID;
+  }
+
+  DEVICE_ID = createDeviceId();
+  persistDeviceId(DEVICE_ID);
+  return DEVICE_ID;
 }
 
 function getCommonHeaders(): Record<string, string> {
-	return {
-		"User-Agent": KIMI_CLI_USER_AGENT,
-		"X-Msh-Platform": KIMI_PLATFORM,
-		"X-Msh-Version": KIMI_CLI_VERSION,
-		"X-Msh-Device-Name": os.hostname(),
-		"X-Msh-Device-Model": DEVICE_MODEL,
-		"X-Msh-Os-Version": os.release(),
-		"X-Msh-Device-Id": getStableDeviceId(),
-	};
+  const headers = {
+    "User-Agent": KIMI_CLI_USER_AGENT,
+    "X-Msh-Platform": KIMI_PLATFORM,
+    "X-Msh-Version": KIMI_CLI_VERSION,
+    "X-Msh-Device-Name": os.hostname(),
+    "X-Msh-Device-Model": DEVICE_MODEL,
+    "X-Msh-Os-Version": os.release(),
+    "X-Msh-Device-Id": getStableDeviceId(),
+  };
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [key, asciiHeaderValue(value)]),
+  ) as Record<string, string>;
 }
 
 // =============================================================================
@@ -73,127 +166,127 @@ function getCommonHeaders(): Record<string, string> {
 // =============================================================================
 
 interface DeviceAuthorization {
-	user_code: string;
-	device_code: string;
-	verification_uri: string;
-	verification_uri_complete: string;
-	expires_in: number;
-	interval: number;
+  user_code: string;
+  device_code: string;
+  verification_uri: string;
+  verification_uri_complete: string;
+  expires_in: number;
+  interval: number;
 }
 
 interface TokenResponse {
-	access_token: string;
-	refresh_token: string;
-	expires_in: number;
-	scope: string;
-	token_type: string;
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+  scope: string;
+  token_type: string;
 }
 
 async function requestDeviceAuthorization(): Promise<DeviceAuthorization> {
-	const response = await fetch(`${OAUTH_HOST}/api/oauth/device_authorization`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/x-www-form-urlencoded",
-			...getCommonHeaders(),
-		},
-		body: new URLSearchParams({
-			client_id: CLIENT_ID,
-		}),
-	});
-
-	if (!response.ok) {
-		const text = await response.text().catch(() => "");
-		throw new Error(`Device authorization failed: ${response.status} ${text}`);
-	}
-
-	const data = (await response.json()) as {
-		user_code?: string;
-		device_code?: string;
-		verification_uri?: string;
-		verification_uri_complete?: string;
-		expires_in?: number;
-		interval?: number;
-	};
-
-	if (!data.user_code || !data.device_code || !data.verification_uri_complete) {
-		throw new Error("Invalid device authorization response");
-	}
-
-	return {
-		user_code: data.user_code,
-		device_code: data.device_code,
-		verification_uri: data.verification_uri || "",
-		verification_uri_complete: data.verification_uri_complete,
-		expires_in: data.expires_in || 1800,
-		interval: data.interval || 5,
-	};
+  const response = await fetch(`${getOAuthHost()}/api/oauth/device_authorization`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      ...getCommonHeaders(),
+    },
+    body: new URLSearchParams({
+      client_id: CLIENT_ID,
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Device authorization failed: ${response.status} ${text}`);
+  }
+
+  const data = (await response.json()) as {
+    user_code?: string;
+    device_code?: string;
+    verification_uri?: string;
+    verification_uri_complete?: string;
+    expires_in?: number;
+    interval?: number;
+  };
+
+  if (!data.user_code || !data.device_code || !data.verification_uri_complete) {
+    throw new Error("Invalid device authorization response");
+  }
+
+  return {
+    user_code: data.user_code,
+    device_code: data.device_code,
+    verification_uri: data.verification_uri || "",
+    verification_uri_complete: data.verification_uri_complete,
+    expires_in: data.expires_in || 1800,
+    interval: data.interval || 5,
+  };
 }
 
 async function requestDeviceToken(auth: DeviceAuthorization): Promise<TokenResponse | null> {
-	const response = await fetch(`${OAUTH_HOST}/api/oauth/token`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/x-www-form-urlencoded",
-			...getCommonHeaders(),
-		},
-		body: new URLSearchParams({
-			client_id: CLIENT_ID,
-			device_code: auth.device_code,
-			grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-		}),
-	});
-
-	if (response.status === 200) {
-		const data = (await response.json()) as TokenResponse;
-		if (data.access_token && data.refresh_token) {
-			return data;
-		}
-		throw new Error("Token response missing required fields");
-	}
-
-	if (response.status === 400) {
-		const data = (await response.json()) as { error?: string; error_description?: string };
-		if (data.error === "authorization_pending") {
-			return null; // Still waiting for user
-		}
-		if (data.error === "expired_token") {
-			throw new Error("expired_token");
-		}
-		throw new Error(`Token request failed: ${data.error_description || data.error || "unknown"}`);
-	}
-
-	const text = await response.text().catch(() => "");
-	throw new Error(`Token request failed: ${response.status} ${text}`);
+  const response = await fetch(`${getOAuthHost()}/api/oauth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      ...getCommonHeaders(),
+    },
+    body: new URLSearchParams({
+      client_id: CLIENT_ID,
+      device_code: auth.device_code,
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+    }),
+  });
+
+  if (response.status === 200) {
+    const data = (await response.json()) as TokenResponse;
+    if (data.access_token && data.refresh_token) {
+      return data;
+    }
+    throw new Error("Token response missing required fields");
+  }
+
+  if (response.status === 400) {
+    const data = (await response.json()) as { error?: string; error_description?: string };
+    if (data.error === "authorization_pending") {
+      return null;
+    }
+    if (data.error === "expired_token") {
+      throw new Error("expired_token");
+    }
+    throw new Error(`Token request failed: ${data.error_description || data.error || "unknown"}`);
+  }
+
+  const text = await response.text().catch(() => "");
+  throw new Error(`Token request failed: ${response.status} ${text}`);
 }
 
 async function refreshAccessToken(refreshToken: string): Promise<TokenResponse> {
-	const response = await fetch(`${OAUTH_HOST}/api/oauth/token`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/x-www-form-urlencoded",
-			...getCommonHeaders(),
-		},
-		body: new URLSearchParams({
-			client_id: CLIENT_ID,
-			grant_type: "refresh_token",
-			refresh_token: refreshToken,
-		}),
-	});
-
-	if (!response.ok) {
-		const text = await response.text().catch(() => "");
-		if (response.status === 401 || response.status === 403) {
-			throw new Error(`Token refresh unauthorized: ${text}`);
-		}
-		throw new Error(`Token refresh failed: ${response.status} ${text}`);
-	}
-
-	const data = (await response.json()) as TokenResponse;
-	if (!data.access_token || !data.refresh_token) {
-		throw new Error("Token refresh response missing required fields");
-	}
-
-	return data;
+  const response = await fetch(`${getOAuthHost()}/api/oauth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      ...getCommonHeaders(),
+    },
+    body: new URLSearchParams({
+      client_id: CLIENT_ID,
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    if (response.status === 401 || response.status === 403) {
+      throw new Error(`Token refresh unauthorized: ${text}`);
+    }
+    throw new Error(`Token refresh failed: ${response.status} ${text}`);
+  }
+
+  const data = (await response.json()) as TokenResponse;
+  if (!data.access_token || !data.refresh_token) {
+    throw new Error("Token refresh response missing required fields");
+  }
+
+  return data;
 }
 
 // =============================================================================
@@ -201,70 +294,70 @@ async function refreshAccessToken(refreshToken: string): Promise<TokenResponse>
 // =============================================================================
 
 async function loginKimiCode(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
-	// Keep trying until we get a token (handles expired device codes)
-	while (true) {
-		const auth = await requestDeviceAuthorization();
-
-		callbacks.onAuth({
-			url: auth.verification_uri_complete,
-			instructions: `Please visit the URL to authorize. Your code: ${auth.user_code}`,
-		});
-
-		const interval = Math.max(auth.interval, 1) * 1000;
-		const expiresAt = Date.now() + auth.expires_in * 1000;
-
-		let token: TokenResponse | null = null;
-		let printedWaiting = false;
-
-		while (Date.now() < expiresAt) {
-			try {
-				token = await requestDeviceToken(auth);
-				if (token) break;
-			} catch (error) {
-				if (error instanceof Error && error.message === "expired_token") {
-					// Device code expired, restart the flow
-					if (callbacks.onProgress) {
-						callbacks.onProgress("Device code expired, restarting...");
-					}
-					break;
-				}
-				throw error;
-			}
-
-			if (!printedWaiting) {
-				if (callbacks.onProgress) {
-					callbacks.onProgress("Waiting for authorization...");
-				}
-				printedWaiting = true;
-			}
-
-			// Check for abort
-			if (callbacks.signal?.aborted) {
-				throw new Error("Authorization aborted");
-			}
-
-			await new Promise((resolve) => setTimeout(resolve, interval));
-		}
-
-		if (token) {
-			return {
-				access: token.access_token,
-				refresh: token.refresh_token,
-				expires: Date.now() + token.expires_in * 1000,
-			};
-		}
-
-		// If we get here without a token, the device code expired - loop will retry
-	}
+  // Keep trying until we get a token (handles expired device codes)
+  while (true) {
+    const auth = await requestDeviceAuthorization();
+
+    callbacks.onAuth({
+      url: auth.verification_uri_complete,
+      instructions: `Please visit the URL to authorize. Your code: ${auth.user_code}`,
+    });
+
+    const interval = Math.max(auth.interval, 1) * 1000;
+    const expiresAt = Date.now() + auth.expires_in * 1000;
+
+    let token: TokenResponse | null = null;
+    let printedWaiting = false;
+
+    while (Date.now() < expiresAt) {
+      try {
+        token = await requestDeviceToken(auth);
+        if (token) break;
+      } catch (error) {
+        if (error instanceof Error && error.message === "expired_token") {
+          // Device code expired, restart the flow
+          if (callbacks.onProgress) {
+            callbacks.onProgress("Device code expired, restarting...");
+          }
+          break;
+        }
+        throw error;
+      }
+
+      if (!printedWaiting) {
+        if (callbacks.onProgress) {
+          callbacks.onProgress("Waiting for authorization...");
+        }
+        printedWaiting = true;
+      }
+
+      // Check for abort
+      if (callbacks.signal?.aborted) {
+        throw new Error("Authorization aborted");
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+
+    if (token) {
+      return {
+        access: token.access_token,
+        refresh: token.refresh_token,
+        expires: Date.now() + token.expires_in * 1000,
+      };
+    }
+
+    // If we get here without a token, the device code expired - loop will retry
+  }
 }
 
 async function refreshKimiCodeToken(credentials: OAuthCredentials): Promise<OAuthCredentials> {
-	const token = await refreshAccessToken(credentials.refresh);
-	return {
-		access: token.access_token,
-		refresh: token.refresh_token,
-		expires: Date.now() + token.expires_in * 1000,
-	};
+  const token = await refreshAccessToken(credentials.refresh);
+  return {
+    access: token.access_token,
+    refresh: token.refresh_token,
+    expires: Date.now() + token.expires_in * 1000,
+  };
 }
 
 // =============================================================================
@@ -276,78 +369,241 @@ async function refreshKimiCodeToken(credentials: OAuthCredentials): Promise<OAut
 
 const EMPTY_RESPONSE_PREFIX = "(Empty response:";
 
+function mapThinkingLevel(level?: string): { effort: string | null; enabled: boolean } | undefined {
+  if (!level) return undefined;
+  if (level === "none" || level === "off") return { effort: null, enabled: false };
+  if (level === "minimal" || level === "low") return { effort: "low", enabled: true };
+  if (level === "medium") return { effort: "medium", enabled: true };
+  if (level === "high" || level === "xhigh") return { effort: "high", enabled: true };
+  return undefined;
+}
+
+async function transformContextFiles(context: Context, apiKey: string): Promise<Context> {
+  const transformedMessages = [];
+  for (const message of context.messages) {
+    if (message.role === "user" && Array.isArray(message.content)) {
+      const newContent = [];
+      for (const block of message.content) {
+        if (block.type === "image") {
+          // If the image is extremely large or if it's actually a video masquerading as an image,
+          // upload it to Kimi's /v1/files endpoint.
+          // For Kimi, images > 5MB or videos should be uploaded. We'll use 5MB threshold.
+          const buffer = Buffer.from(block.data, "base64");
+          if (buffer.length > 5 * 1024 * 1024 || block.mimeType.startsWith("video/")) {
+            const formData = new FormData();
+            const filename = block.mimeType.startsWith("video/") ? "upload.mp4" : "upload.png";
+            formData.append("file", new Blob([buffer], { type: block.mimeType }), filename);
+            formData.append("purpose", block.mimeType.startsWith("video/") ? "video" : "image");
+
+            const filesBaseUrl = (
+              process.env.KIMI_CODE_BASE_URL || "https://api.kimi.com/coding/v1"
+            ).replace(/\/$/, "");
+            const uploadUrl = `${filesBaseUrl}/files`;
+            if (process.env.KIMI_CODE_DEBUG === "1") {
+              console.log(
+                `\n[kimi-coding] Uploading ${filename} to ${uploadUrl} (size: ${(buffer.length / 1024 / 1024).toFixed(2)} MB)...`,
+              );
+            }
+            const response = await fetch(uploadUrl, {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${apiKey}`,
+                ...getCommonHeaders(),
+              },
+              body: formData,
+            });
+
+            if (response.ok) {
+              const fileObj = (await response.json()) as { id?: string; url?: string };
+              const fileUrl = `ms://${fileObj.id}`;
+              if (process.env.KIMI_CODE_DEBUG === "1") {
+                console.log(`[kimi-coding] Upload success. File URL: ${fileUrl}`);
+              }
+              // Replace the block with Kimi's specific reference
+              if (block.mimeType.startsWith("video/")) {
+                newContent.push({
+                  type: "video_url" as any,
+                  video_url: { url: fileUrl },
+                });
+              } else {
+                newContent.push({
+                  type: "image_url" as any,
+                  image_url: { url: fileUrl },
+                });
+              }
+              continue;
+            } else {
+              console.error("Failed to upload file to Kimi API", await response.text());
+            }
+          }
+        }
+        newContent.push(block);
+      }
+      transformedMessages.push({ ...message, content: newContent });
+    } else {
+      transformedMessages.push(message);
+    }
+  }
+  return { ...context, messages: transformedMessages };
+}
+
 function streamSimpleKimi(
-	model: Model<"anthropic-messages">,
-	context: Context,
-	options?: SimpleStreamOptions,
+  model: Model<"anthropic-messages" | "openai-completions">,
+  context: Context,
+  options?: SimpleStreamOptions,
 ): AssistantMessageEventStream {
-	const upstream = streamSimpleAnthropic(model, context, options);
-	const filtered = new AssistantMessageEventStream();
-
-	// Buffer text block events so we can suppress the entire block if it
-	// turns out to be a Kimi "(Empty response: ...)" wrapper.
-	const suppressedIndices = new Set<number>();
-	let textBuffer: AssistantMessageEvent[] = [];
-	let bufferingIndex: number | null = null;
-
-	void (async () => {
-		try {
-			for await (const event of upstream) {
-				// Start buffering when a new text block begins
-				if (event.type === "text_start") {
-					bufferingIndex = event.contentIndex;
-					textBuffer = [event];
-					continue;
-				}
-
-				// Accumulate text deltas while buffering
-				if (bufferingIndex !== null && "contentIndex" in event && event.contentIndex === bufferingIndex) {
-					if (event.type === "text_delta") {
-						textBuffer.push(event);
-						continue;
-					}
-					if (event.type === "text_end") {
-						if (event.content.startsWith(EMPTY_RESPONSE_PREFIX)) {
-							// Suppress entire text block — discard buffered events.
-							// Do NOT splice content array: it is a shared reference
-							// into session state, and mutating it shifts subsequent
-							// contentIndex values, corrupting the stream.
-							suppressedIndices.add(bufferingIndex);
-						} else {
-							// Legitimate text block — flush buffer + end event
-							for (const buffered of textBuffer) filtered.push(buffered);
-							filtered.push(event);
-						}
-						textBuffer = [];
-						bufferingIndex = null;
-						continue;
-					}
-				}
-
-				// Skip events for already-suppressed indices
-				if ("contentIndex" in event && suppressedIndices.has(event.contentIndex)) {
-					continue;
-				}
-
-				// Clean suppressed blocks from the final message
-				if (event.type === "done" && suppressedIndices.size > 0) {
-					event.message.content = event.message.content.filter(
-						(block) => !(block.type === "text" && typeof block.text === "string" && block.text.startsWith(EMPTY_RESPONSE_PREFIX)),
-					);
-				}
-
-				filtered.push(event);
-			}
-		} catch (err) {
-			filtered.push({
-				type: "error",
-				reason: "error",
-				error: { content: [], stopReason: "error", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 } },
-			} as AssistantMessageEvent & { type: "error" });
-		}
-	})();
-
-	return filtered;
+  // Pre-process context files: upload large images/videos to Kimi API
+  const filtered = new AssistantMessageEventStream();
+  const apiKey = options?.apiKey || process.env.KIMI_API_KEY || "";
+
+  void (async () => {
+    let finalContext = context;
+    try {
+      if (apiKey) {
+        finalContext = await transformContextFiles(context, apiKey);
+      }
+    } catch (e) {
+      console.error("Error transforming context files", e);
+    }
+
+    // Intercept the payload to inject Kimi's proprietary prompt_cache_key
+    // because Kimi's Anthropic compatibility endpoint requires it alongside cache_control.
+    const originalOnPayload = options?.onPayload;
+    const patchedOptions: SimpleStreamOptions = {
+      ...options,
+      onPayload: async (payload: any, modelData) => {
+        let nextPayload = payload;
+        if (originalOnPayload) {
+          const res = await originalOnPayload(payload, modelData);
+          if (res !== undefined) nextPayload = res;
+        }
+
+        if (nextPayload && typeof nextPayload === "object") {
+          // Map unsupported roles: Kimi does not recognize "developer" (OpenAI-specific).
+          if (Array.isArray(nextPayload.messages)) {
+            nextPayload.messages = nextPayload.messages.map((msg: any) =>
+              msg.role === "developer" ? { ...msg, role: "system" } : msg,
+            );
+          }
+
+          // Inject prompt_cache_key: allow explicit override, fallback to stable sessionId.
+          const cacheKey =
+            nextPayload.prompt_cache_key ||
+            (options as any)?.prompt_cache_key ||
+            options?.sessionId;
+          if (cacheKey) {
+            nextPayload = { ...nextPayload, prompt_cache_key: cacheKey };
+          }
+
+          // Environment overrides
+          const envTemp = process.env.KIMI_MODEL_TEMPERATURE;
+          if (envTemp) nextPayload.temperature = parseFloat(envTemp);
+
+          const envTopP = process.env.KIMI_MODEL_TOP_P;
+          if (envTopP) nextPayload.top_p = parseFloat(envTopP);
+
+          const envMaxTokens = process.env.KIMI_MODEL_MAX_TOKENS;
+          if (envMaxTokens) nextPayload.max_tokens = parseInt(envMaxTokens, 10);
+
+          // Reasoning effort mapping
+          const reasoningLevel = (options as any)?.reasoning;
+          if (reasoningLevel) {
+            const mapped = mapThinkingLevel(reasoningLevel);
+            if (mapped) {
+              nextPayload.reasoning_effort = mapped.effort;
+              nextPayload.extra_body = nextPayload.extra_body || {};
+              nextPayload.extra_body.thinking = {
+                type: mapped.enabled ? "enabled" : "disabled",
+              };
+            }
+          }
+        }
+        return nextPayload;
+      },
+    };
+
+    const upstream =
+      model.api === "openai-completions"
+        ? streamSimpleOpenAICompletions(model as any, finalContext, patchedOptions)
+        : streamSimpleAnthropic(model as any, finalContext, patchedOptions);
+
+    // Buffer text block events so we can suppress the entire block if it
+    // turns out to be a Kimi "(Empty response: ...)" wrapper.
+    const suppressedIndices = new Set<number>();
+    let textBuffer: AssistantMessageEvent[] = [];
+    let bufferingIndex: number | null = null;
+
+    try {
+      for await (const event of upstream) {
+        // Start buffering when a new text block begins
+        if (event.type === "text_start") {
+          bufferingIndex = event.contentIndex;
+          textBuffer = [event];
+          continue;
+        }
+
+        // Accumulate text deltas while buffering
+        if (
+          bufferingIndex !== null &&
+          "contentIndex" in event &&
+          event.contentIndex === bufferingIndex
+        ) {
+          if (event.type === "text_delta") {
+            textBuffer.push(event);
+            continue;
+          }
+          if (event.type === "text_end") {
+            if (event.content.startsWith(EMPTY_RESPONSE_PREFIX)) {
+              // Suppress entire text block — discard buffered events.
+              // Do NOT splice content array: it is a shared reference
+              // into session state, and mutating it shifts subsequent
+              // contentIndex values, corrupting the stream.
+              suppressedIndices.add(bufferingIndex);
+            } else {
+              // Legitimate text block — flush buffer + end event
+              for (const buffered of textBuffer) filtered.push(buffered);
+              filtered.push(event);
+            }
+            textBuffer = [];
+            bufferingIndex = null;
+            continue;
+          }
+        }
+
+        // Skip events for already-suppressed indices
+        if ("contentIndex" in event && suppressedIndices.has(event.contentIndex)) {
+          continue;
+        }
+
+        // Clean suppressed blocks from the final message
+        if (event.type === "done" && suppressedIndices.size > 0) {
+          event.message.content = event.message.content.filter(
+            (block) =>
+              !(
+                block.type === "text" &&
+                typeof block.text === "string" &&
+                block.text.startsWith(EMPTY_RESPONSE_PREFIX)
+              ),
+          );
+        }
+
+        filtered.push(event);
+      }
+    } catch (err) {
+      console.error("[kimi-coding] stream error:", err);
+      filtered.push({
+        type: "error",
+        reason: "error",
+        error: {
+          content: [],
+          stopReason: "error",
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
+        },
+      } as AssistantMessageEvent & { type: "error" });
+    }
+  })();
+
+  return filtered;
 }
 
 // =============================================================================
@@ -355,49 +611,49 @@ function streamSimpleKimi(
 // =============================================================================
 
 export default function (pi: ExtensionAPI) {
-	pi.registerProvider("kimi-coding", {
-		baseUrl: "https://api.kimi.com/coding",
-		apiKey: "KIMI_API_KEY",
-		api: "anthropic-messages",
-		streamSimple: streamSimpleKimi,
-
-		headers: getCommonHeaders(),
-
-		models: [
-			{
-				id: "kimi-code",
-				name: "Kimi Code (powered by kimi-k2.5)",
-				reasoning: true,
-				input: ["text", "image"],
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: 262144,
-				maxTokens: 32768,
-			},
-			{
-				id: "kimi-k2.5",
-				name: "Kimi K2.5",
-				reasoning: true,
-				input: ["text", "image"],
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: 262144,
-				maxTokens: 32768,
-			},
-			{
-				id: "kimi-k2-thinking-turbo",
-				name: "Kimi K2 Thinking Turbo",
-				reasoning: true,
-				input: ["text"],
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: 262144,
-				maxTokens: 32768,
-			},
-		],
-
-		oauth: {
-			name: "Kimi Code (OAuth)",
-			login: loginKimiCode,
-			refreshToken: refreshKimiCodeToken,
-			getApiKey: (cred) => cred.access,
-		},
-	});
+  pi.registerProvider("kimi-coding", {
+    baseUrl: getBaseUrl(),
+    apiKey: "KIMI_API_KEY",
+    api: PROTOCOL,
+    streamSimple: streamSimpleKimi,
+
+    headers: getCommonHeaders(),
+
+    models: [
+      {
+        id: "kimi-code",
+        name: "Kimi Code (powered by kimi-k2.5)",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 262144,
+        maxTokens: 32000,
+      },
+      {
+        id: "kimi-k2.5",
+        name: "Kimi K2.5",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 262144,
+        maxTokens: 32000,
+      },
+      {
+        id: "kimi-k2-thinking-turbo",
+        name: "Kimi K2 Thinking Turbo",
+        reasoning: true,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 262144,
+        maxTokens: 32000,
+      },
+    ],
+
+    oauth: {
+      name: "Kimi Code (OAuth)",
+      login: loginKimiCode,
+      refreshToken: refreshKimiCodeToken,
+      getApiKey: (cred) => cred.access,
+    },
+  });
 }

package/package.json

@@ -1,30 +1,39 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "pi custom provider extension for Kimi Code models with OAuth device-code login",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Leechael/pi-provider-kimi-code"
-  },
   "keywords": [
-    "pi",
-    "pi-extension",
+    "coding-agent",
     "kimi",
     "kimi-code",
     "llm",
-    "coding-agent"
+    "pi",
+    "pi-extension"
   ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Leechael/pi-provider-kimi-code"
+  },
   "files": [
     "index.ts",
     "package.json",
     "README.md"
   ],
+  "type": "module",
   "scripts": {
     "clean": "echo 'nothing to clean'",
     "build": "echo 'nothing to build'",
-    "check": "echo 'nothing to check'"
+    "check": "echo 'nothing to check'",
+    "lint": "oxlint .",
+    "format": "oxfmt . --write",
+    "format:check": "oxfmt . --check",
+    "pre-commit": "prek run"
+  },
+  "devDependencies": {
+    "@j178/prek": "^0.3.8",
+    "oxfmt": "^0.44.0",
+    "oxlint": "^1.59.0"
   },
   "pi": {
     "extensions": [