pi-provider-kimi-code 0.6.8 → 0.6.10

package/src/constants.ts

@@ -41,12 +41,12 @@ export function getDefaultBaseUrl(protocol: KimiWireProtocol): string {
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const PROVIDER_VERSION = "0.6.8";
+export const PROVIDER_VERSION = "0.6.10";
 
 // Upstream kimi-code CLI version — used in User-Agent and X-Msh-Version
 // headers to match the official client's identity. Update this when
 // syncing with https://github.com/MoonshotAI/kimi-code.
-export const KIMI_UPSTREAM_VERSION = "0.28.0";
+export const KIMI_UPSTREAM_VERSION = "0.34.0";
 export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_UPSTREAM_VERSION}`;
 export const KIMI_PLATFORM = "kimi_code_cli";
 
@@ -63,6 +63,10 @@ export const RETRYABLE_REFRESH_STATUSES = new Set([429, 500, 502, 503, 504]);
 
 export const PROVIDER_ID = "kimi-coding";
 
+// Owner tag for the entries this extension adds to pi-ai's global api-provider
+// registry, so they can be identified and removed as a group.
+export const KIMI_GLOBAL_FALLBACK_SOURCE_ID = "pi-provider-kimi-code-global-fallback";
+
 export function getOAuthHost(): string {
   const value =
     process.env.KIMI_CODE_OAUTH_HOST || process.env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST;

package/src/device.ts

@@ -1,10 +1,10 @@
 // Device identification: device-id persistence, Kimi Code-compatible request
 // headers, and the cross-platform device-model string. Pure helpers live near
-// the side-effecting one-shots (file IO, exec) they support.
+// the side-effecting one-shots (file IO) they support.
 
-import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import os from "node:os";
 import { dirname } from "node:path";
 
@@ -97,25 +97,68 @@ export function computeDeviceModel(input: DeviceModelInput): string {
   return `${system} ${arch}`.trim();
 }
 
-function macOsProductVersion(): string | undefined {
-  try {
-    const version = execFileSync("/usr/bin/sw_vers", ["-productVersion"], {
-      encoding: "utf-8",
-      timeout: 1000,
-    }).trim();
-    return version.length > 0 ? version : undefined;
-  } catch {
-    return undefined;
-  }
+// Where macOS keeps its product version. Upstream Kimi Code reads it through
+// Python's platform.mac_ver(), which parses this same file, so it is the same
+// source of truth as `sw_vers -productVersion` without the process spawn: a
+// spawn costs ~10ms of blocked event loop, and pi pays it again on every
+// /reload because it re-evaluates extension modules.
+const MAC_PRODUCT_VERSION_PATH = "/System/Library/CoreServices/SystemVersion.plist";
+
+// Exposed for tests. The plist is a flat XML property list, so the version sits
+// in the <string> immediately after the ProductVersion key.
+export function parseMacProductVersion(plist: string): string | undefined {
+  const match = /<key>ProductVersion<\/key>\s*<string>([^<]*)<\/string>/.exec(plist);
+  return match?.[1].trim() || undefined;
 }
 
-function getDeviceModel(): string {
-  return computeDeviceModel({
+let DEVICE_MODEL: string | undefined;
+
+function setDeviceModel(macVersion: string | undefined): string {
+  DEVICE_MODEL ??= computeDeviceModel({
     platform: process.platform,
     release: os.release(),
     arch: os.machine() || process.arch,
-    macVersion: process.platform === "darwin" ? macOsProductVersion() : undefined,
+    macVersion,
   });
+  return DEVICE_MODEL;
+}
+
+async function loadMacDeviceModel(): Promise<void> {
+  try {
+    setDeviceModel(parseMacProductVersion(await readFile(MAC_PRODUCT_VERSION_PATH, "utf-8")));
+  } catch {
+    setDeviceModel(undefined);
+  }
+}
+
+/**
+ * Settles once the module-load lookup has produced a device model. Nothing in
+ * the provider waits for it — headers stay synchronous — but tests use it to
+ * exercise the async path without racing the fallback below.
+ */
+export const deviceModelReady: Promise<void> = (() => {
+  if (process.platform !== "darwin") {
+    // Nothing to read: every other platform derives the model from os.release().
+    setDeviceModel(undefined);
+    return Promise.resolve();
+  }
+  // Read the version off the event loop at module load so the value is usually
+  // in place before anything asks for a header.
+  return loadMacDeviceModel();
+})();
+
+function getDeviceModel(): string {
+  if (DEVICE_MODEL !== undefined) return DEVICE_MODEL;
+  // A header was needed before the async read landed. Read the same file
+  // synchronously rather than reporting the kernel release, which would put a
+  // different device model on the wire than every later request. This costs
+  // ~0.02ms against the ~10ms a `sw_vers` subprocess used to cost, and both
+  // paths memoize into the same slot.
+  try {
+    return setDeviceModel(parseMacProductVersion(readFileSync(MAC_PRODUCT_VERSION_PATH, "utf-8")));
+  } catch {
+    return setDeviceModel(undefined);
+  }
 }
 
 export function getOsVersion(): string {
@@ -133,7 +176,6 @@ export function asciiHeaderValue(value: string, fallback = "unknown"): string {
   return sanitized || fallback;
 }
 
-const DEVICE_MODEL = getDeviceModel();
 let DEVICE_ID: string | null = null;
 
 function getStableDeviceId(): string {
@@ -174,7 +216,7 @@ export function getCommonHeaders(): Record<string, string> {
     "X-Msh-Platform": KIMI_PLATFORM,
     "X-Msh-Version": KIMI_UPSTREAM_VERSION,
     "X-Msh-Device-Name": os.hostname(),
-    "X-Msh-Device-Model": DEVICE_MODEL,
+    "X-Msh-Device-Model": getDeviceModel(),
     "X-Msh-Os-Version": getOsVersion(),
     "X-Msh-Device-Id": getStableDeviceId(),
   };

package/src/models.ts

@@ -8,6 +8,7 @@ import type {
   ModelConfig,
   ModelReasoningMap,
 } from "./config.ts";
+import { DEFAULT_KIMI_CODE_CONFIG } from "./config.ts";
 
 import { type KimiWireProtocol, getBaseUrl } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
@@ -36,6 +37,10 @@ const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
 
 export interface DiscoverKimiModelMetadataOptions {
   timeoutMs?: number;
+  // 401 recovery for runtime callers (extension startup, settings menu).
+  // oauth.ts's login/refresh flows must NOT pass this: they call discovery
+  // while holding the OAuth lock, and refreshKimiAuthToken would re-enter it.
+  refreshAccessToken?: (currentToken: string) => Promise<string | null>;
 }
 
 function mergeInputModalities(
@@ -84,6 +89,36 @@ function resolveModelCost(
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
 
+// Policy: a model's output cap tracks its context window unless the user
+// explicitly configured model.maxTokens. pi-ai clamps the request cap to
+// contextWindow - used - 4096 (clampMaxTokensToContext in
+// @earendil-works/pi-ai), so setting maxTokens to the window yields the official
+// kimi-code behavior (computeCompletionBudgetCap: maxCtx, clamped to
+// maxCtx - usedContext) instead of a fixed small cap that truncates long
+// max-effort reasoning (reasoning_content counts toward the cap). A deliberate
+// per-request cap still wins (options.maxTokens ?? model.maxTokens). Reconcile
+// wherever contextWindow is authored so the two stay in lockstep.
+//
+// "Explicitly configured" means any value other than the built-in default:
+// ensureKimiCodeConfig materializes the full default config (including
+// maxTokens) into the home config file, so config-source tracking cannot
+// distinguish a deliberate 32000 from a materialized default. A user who
+// explicitly sets the default value gets the window cap — indistinguishable
+// from the materialized-default case, and the intended new behavior anyway.
+const DEFAULT_MODEL_MAX_TOKENS = DEFAULT_KIMI_CODE_CONFIG.model.maxTokens;
+
+// True while the cap is "unset": still the built-in default, or already
+// tracking the context window (set by an earlier withWindowCappedMaxTokens
+// call, before discovery grew the window).
+function isWindowTrackedMaxTokens(model: Model<Api>): boolean {
+  return model.maxTokens === DEFAULT_MODEL_MAX_TOKENS || model.maxTokens === model.contextWindow;
+}
+
+function withWindowCappedMaxTokens<M extends Model<Api>>(model: M): M {
+  if (!isWindowTrackedMaxTokens(model)) return model;
+  return { ...model, maxTokens: model.contextWindow };
+}
+
 export function buildKimiModelFromConfig(
   config: ModelConfig,
   modelId = KIMI_CODING_MODEL_ID,
@@ -97,7 +132,7 @@ export function buildKimiModelFromConfig(
         : modelId === KIMI_CODING_MODEL_ID
           ? "Kimi for Coding"
           : modelId;
-  return {
+  return withWindowCappedMaxTokens({
     id: modelId,
     name,
     reasoning: config.reasoning,
@@ -105,7 +140,7 @@ export function buildKimiModelFromConfig(
     cost: { ...resolveModelCost(modelId) },
     contextWindow: config.contextWindow,
     maxTokens: config.maxTokens,
-  } as Model<Api>;
+  } as Model<Api>);
 }
 
 export function resolveKimiModelConfig(
@@ -225,15 +260,30 @@ export async function discoverKimiModelMetadata(
   const controller = new AbortController();
   const timeout =
     timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs).unref() : undefined;
-  try {
-    const response = await fetch(modelsUrl, {
-      signal: controller.signal,
+  const requestModels = (token: string, signal: AbortSignal) =>
+    fetch(modelsUrl, {
+      signal,
       headers: {
         ...getKimiProviderHeaders(),
-        Authorization: `Bearer ${accessToken}`,
+        Authorization: `Bearer ${token}`,
         Accept: "application/json",
       },
     });
+  try {
+    let response = await requestModels(accessToken, controller.signal);
+    if (response.status === 401 && options.refreshAccessToken) {
+      const refreshed = await options.refreshAccessToken(accessToken);
+      if (refreshed && refreshed !== accessToken) {
+        const retryController = new AbortController();
+        const retryTimeout =
+          timeoutMs > 0 ? setTimeout(() => retryController.abort(), timeoutMs).unref() : undefined;
+        try {
+          response = await requestModels(refreshed, retryController.signal);
+        } finally {
+          if (retryTimeout) clearTimeout(retryTimeout);
+        }
+      }
+    }
     if (!response.ok) return {};
     const json = (await response.json()) as { data?: unknown };
     const list = Array.isArray(json.data) ? (json.data as KimiServerModel[]) : [];
@@ -306,6 +356,9 @@ export function applyKimiOAuthExtrasToModel(
   extras: KimiModelMetadata,
   reasoningMap?: ModelReasoningMap,
 ): Model<Api> {
+  // Capture before extras grow the window: a window-tracked cap must follow
+  // the new window, an explicit cap must survive unchanged.
+  const windowTracked = isWindowTrackedMaxTokens(model);
   const next: Model<Api> & {
     wireModelId?: string;
     supportsThinkingType?: "only" | "no" | "both";
@@ -347,5 +400,7 @@ export function applyKimiOAuthExtrasToModel(
     if (thinkingLevelMap) next.thinkingLevelMap = thinkingLevelMap;
     else delete next.thinkingLevelMap;
   }
+  // Reconcile the output cap with the (possibly discovery-updated) window.
+  if (windowTracked) next.maxTokens = next.contextWindow;
   return next;
 }

package/src/oauth.ts

@@ -658,7 +658,13 @@ export function isKimiAuthErrorMessage(message: unknown): boolean {
     /\b401\b/.test(text) ||
     text.includes("unauthorized") ||
     text.includes("incorrect api key") ||
-    text.includes("invalid api key")
+    text.includes("invalid api key") ||
+    // Kimi's production 401 body: "The API Key appears to be invalid or may
+    // have expired..." with type "invalid_authentication_error". Neither
+    // contains the substrings above, so without these the digit fallback is
+    // the only match and vanishes when a transport strips the status prefix.
+    text.includes("api key appears to be invalid") ||
+    text.includes("invalid_authentication_error")
   );
 }
 

package/src/payload.ts

@@ -2,11 +2,14 @@
 // per-protocol message transforms, OpenAI tool-call / tool-schema normalizers,
 // and the top-level applyKimiPayloadMutations that orchestrates them.
 
+import { createHash } from "node:crypto";
+
 import type { CacheRetention, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { KimiResolvedModelConfig, ModelReasoningEntry } from "./config.ts";
 
 import { getBaseUrl } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
+import { refreshKimiAuthToken } from "./oauth.ts";
 import { optimizeToolSchemas } from "./schema-dedup.ts";
 
 // =============================================================================
@@ -30,6 +33,7 @@ export function resolveCacheRetention(value?: CacheRetention): CacheRetention {
 export interface KimiPayloadContext {
   api: "anthropic-messages" | "openai-completions";
   upload?: Uploader;
+  uploadCacheScope?: string;
   cacheKey?: string;
   cacheRetention: CacheRetention;
   reasoning?: ThinkingLevel;
@@ -80,6 +84,16 @@ function getUploadFilename(mimeType: string): string {
     "image/png": "upload.png",
     "image/gif": "upload.gif",
     "image/webp": "upload.webp",
+    // Video extensions mirror upstream kimi-code's MIME_TO_EXT
+    // (packages/kosong/src/providers/kimi-files.ts).
+    "video/mp4": "upload.mp4",
+    "video/mpeg": "upload.mpeg",
+    "video/quicktime": "upload.mov",
+    "video/webm": "upload.webm",
+    "video/x-matroska": "upload.mkv",
+    "video/x-msvideo": "upload.avi",
+    "video/x-flv": "upload.flv",
+    "video/3gpp": "upload.3gp",
   };
   return map[mimeType] ?? "upload.bin";
 }
@@ -88,22 +102,34 @@ function getUploadFilename(mimeType: string): string {
 // File upload (I/O edge)
 // =============================================================================
 
+export interface UploadKimiFileDeps {
+  fetch?: typeof fetch;
+  refreshAccessToken?: (currentToken: string) => Promise<string | null>;
+}
+
 export async function uploadKimiFile(
   apiKey: string,
   mimeType: string,
   data: string,
   thresholdBytes?: number,
+  deps?: UploadKimiFileDeps,
 ): Promise<string | null> {
+  const fetchImpl = deps?.fetch ?? fetch;
+  const refreshAccessToken = deps?.refreshAccessToken ?? refreshKimiAuthToken;
   const buffer = Buffer.from(data, "base64");
-  if (!mimeType.startsWith("image/")) return null;
+  const isVideo = mimeType.startsWith("video/");
+  if (!mimeType.startsWith("image/") && !isVideo) return null;
   const threshold =
     thresholdBytes ?? parseInlineUploadThreshold(process.env.KIMI_CODE_UPLOAD_THRESHOLD_BYTES);
-  if (buffer.length <= threshold) return null;
+  // The inline threshold applies to images only: the Kimi API has no inline
+  // video path (upstream kimi-code uploads every video via /files), so videos
+  // always upload.
+  if (!isVideo && buffer.length <= threshold) return null;
 
   const filename = getUploadFilename(mimeType);
   const formData = new FormData();
   formData.append("file", new Blob([buffer], { type: mimeType }), filename);
-  formData.append("purpose", "image");
+  formData.append("purpose", isVideo ? "video" : "image");
 
   const uploadUrl = `${deriveFilesBaseUrl(getBaseUrl())}/files`;
   const debug = process.env.KIMI_CODE_DEBUG === "1";
@@ -113,13 +139,31 @@ export async function uploadKimiFile(
     );
   }
 
-  try {
-    const response = await fetch(uploadUrl, {
+  const postUpload = (token: string) =>
+    fetchImpl(uploadUrl, {
       method: "POST",
-      headers: { ...getKimiProviderHeaders(), Authorization: `Bearer ${apiKey}` },
+      headers: { ...getKimiProviderHeaders(), Authorization: `Bearer ${token}` },
       body: formData,
     });
-    if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
+
+  try {
+    let response = await postUpload(apiKey);
+    // Kimi access tokens are short-lived and invalidated server-side as soon
+    // as any peer process rotates them, so a 401 here usually means our key
+    // snapshot went stale mid-session, not that login is broken. Mirror the
+    // chat-stream recovery: force one refresh and retry once.
+    let responseText: string | undefined;
+    if (response.status === 401) {
+      responseText = await response.text();
+      const refreshed = await refreshAccessToken(apiKey);
+      if (refreshed && refreshed !== apiKey) {
+        console.error("[kimi-coding] upload got 401, retrying with refreshed token");
+        response = await postUpload(refreshed);
+        responseText = undefined;
+      }
+    }
+    if (!response.ok)
+      throw new Error(`${response.status} ${responseText ?? (await response.text())}`);
     const fileObj = (await response.json()) as { id?: string };
     if (!fileObj.id) throw new Error("missing file id");
     const fileUrl = `ms://${fileObj.id}`;
@@ -132,24 +176,69 @@ export async function uploadKimiFile(
 }
 
 // =============================================================================
-// Payload file transformers (pure given an Uploader)
+// Payload file transformers
 //
 // These walk the provider-specific payload shape and replace inline base64
 // image blocks with ms:// references returned by the injected uploader. They
 // take an Uploader rather than an apiKey so they can be unit-tested with a
 // fake uploader; all network I/O stays behind that boundary.
+//
+// Successful uploads are remembered in a module-level cache shared across
+// requests: payloads are rebuilt from session context every request, so
+// without it a conversation's images would re-upload on every turn. Keys are
+// content hashes rather than the data URLs themselves so the cache does not
+// retain every image's base64 payload in memory. Failures are not cached and
+// retry on the next request.
 // =============================================================================
 
-async function transformOpenAIPayloadFiles(payload: JsonRecord, upload: Uploader): Promise<void> {
+const MAX_UPLOADED_FILE_CACHE_ENTRIES = 512;
+const uploadedFileCache = new Map<string, string>();
+
+function uploadedFileCacheKey(cacheScope: string, mimeType: string, data: string): string {
+  return createHash("sha256")
+    .update(cacheScope)
+    .update("\0")
+    .update(mimeType)
+    .update("\0")
+    .update(data)
+    .digest("hex");
+}
+
+function rememberUploadedFile(
+  uploadCache: Map<string, string>,
+  cacheKey: string,
+  url: string,
+): void {
+  if (
+    uploadCache === uploadedFileCache &&
+    !uploadCache.has(cacheKey) &&
+    uploadCache.size >= MAX_UPLOADED_FILE_CACHE_ENTRIES
+  ) {
+    const oldest = uploadCache.keys().next().value;
+    if (oldest !== undefined) uploadCache.delete(oldest);
+  }
+  uploadCache.set(cacheKey, url);
+}
+
+export function clearKimiUploadedFileCache(): void {
+  uploadedFileCache.clear();
+}
+
+async function transformOpenAIPayloadFiles(
+  payload: JsonRecord,
+  upload: Uploader,
+  uploadCache: Map<string, string>,
+  uploadCacheScope: string,
+): Promise<void> {
   if (!Array.isArray(payload.messages)) return;
-  const cache = new Map<string, string>();
 
   for (const message of payload.messages) {
     if (!isRecord(message) || !Array.isArray(message.content)) continue;
 
     for (const block of message.content) {
       if (!isRecord(block)) continue;
-      const key = block.type === "image_url" ? "image_url" : null;
+      const key =
+        block.type === "image_url" ? "image_url" : block.type === "video_url" ? "video_url" : null;
       if (!key) continue;
 
       const field = block[key];
@@ -164,9 +253,10 @@ async function transformOpenAIPayloadFiles(payload: JsonRecord, upload: Uploader
       const parsed = parseDataUrl(urlValue);
       if (!parsed) continue;
 
-      const uploaded = cache.get(urlValue) ?? (await upload(parsed.mimeType, parsed.data));
+      const cacheKey = uploadedFileCacheKey(uploadCacheScope, parsed.mimeType, parsed.data);
+      const uploaded = uploadCache.get(cacheKey) ?? (await upload(parsed.mimeType, parsed.data));
       if (!uploaded) continue;
-      cache.set(urlValue, uploaded);
+      rememberUploadedFile(uploadCache, cacheKey, uploaded);
 
       block[key] =
         typeof field === "string" ? uploaded : { ...(field as JsonRecord), url: uploaded };
@@ -330,9 +420,10 @@ function normalizeOpenAIToolSchemas(payload: JsonRecord): void {
 async function transformAnthropicPayloadFiles(
   payload: JsonRecord,
   upload: Uploader,
+  uploadCache: Map<string, string>,
+  uploadCacheScope: string,
 ): Promise<void> {
   if (!Array.isArray(payload.messages)) return;
-  const cache = new Map<string, string>();
 
   const transformImageBlock = async (block: unknown): Promise<unknown> => {
     if (!isRecord(block) || block.type !== "image") return block;
@@ -342,10 +433,10 @@ async function transformAnthropicPayloadFiles(
     const data = source.data;
     if (typeof mediaType !== "string" || typeof data !== "string") return block;
 
-    const cacheKey = `${mediaType}:${data}`;
-    const uploaded = cache.get(cacheKey) ?? (await upload(mediaType, data));
+    const cacheKey = uploadedFileCacheKey(uploadCacheScope, mediaType, data);
+    const uploaded = uploadCache.get(cacheKey) ?? (await upload(mediaType, data));
     if (!uploaded) return block;
-    cache.set(cacheKey, uploaded);
+    rememberUploadedFile(uploadCache, cacheKey, uploaded);
 
     const next: JsonRecord = { type: "image", source: { type: "url", url: uploaded } };
     if (block.cache_control !== undefined) next.cache_control = block.cache_control;
@@ -390,10 +481,12 @@ export async function applyKimiPayloadMutations(
 
   // 2. File upload dispatch (protocol-specific).
   if (ctx.upload) {
+    const uploadCache = ctx.uploadCacheScope ? uploadedFileCache : new Map<string, string>();
+    const uploadCacheScope = ctx.uploadCacheScope ?? "request";
     if (ctx.api === "openai-completions") {
-      await transformOpenAIPayloadFiles(payload, ctx.upload);
+      await transformOpenAIPayloadFiles(payload, ctx.upload, uploadCache, uploadCacheScope);
     } else if (ctx.api === "anthropic-messages") {
-      await transformAnthropicPayloadFiles(payload, ctx.upload);
+      await transformAnthropicPayloadFiles(payload, ctx.upload, uploadCache, uploadCacheScope);
     }
   }
   if (ctx.api === "openai-completions") {
@@ -447,8 +540,17 @@ export async function applyKimiPayloadMutations(
   }
 
   const generation = ctx.modelConfig.generation;
+  // Official kimi-code sends temperature/top_p only when explicitly configured
+  // (env KIMI_MODEL_TEMPERATURE / KIMI_MODEL_TOP_P → generation.*); otherwise it
+  // omits them and lets the server apply its own defaults. Mirror that exactly:
+  // drop any value pi-ai seeded by default when the user hasn't configured one
+  // (the official client does not pin these to 1.0 / 0.95).
   if (generation.temperature !== undefined) payload.temperature = generation.temperature;
+  else delete payload.temperature;
   if (generation.topP !== undefined) payload.top_p = generation.topP;
+  else delete payload.top_p;
+  // Output cap: an explicit cap (KIMI_MODEL_MAX_COMPLETION_TOKENS / config →
+  // generation.maxCompletionTokens) is honored as a hardCap on the request value.
   if (generation.maxCompletionTokens !== undefined) {
     const maxTokensKey = ctx.api === "anthropic-messages" ? "max_tokens" : "max_completion_tokens";
     const currentMaxTokens = payload[maxTokensKey];
@@ -469,22 +571,39 @@ export async function applyKimiPayloadMutations(
     const mapped = resolveReasoningForLevel(resolvedReasoning, ctx.modelConfig);
     if (mapped) {
       const oldThinking = isRecord(payload.thinking) ? payload.thinking : {};
-      const thinking: JsonRecord = {
-        ...oldThinking,
-        type: mapped.enabled ? "enabled" : "disabled",
-      };
-      delete thinking.effort;
-      if (!mapped.enabled) delete thinking.keep;
       const effort = ctx.reasoning
         ? mapped.effort
         : (ctx.modelConfig.defaultEffort ?? mapped.effort);
-      if (mapped.enabled && effort !== null && ctx.modelConfig.supportEfforts?.includes(effort)) {
-        thinking.effort = effort;
-      }
-      if (mapped.enabled && ctx.modelConfig.thinkingKeep) {
-        thinking.keep = ctx.modelConfig.thinkingKeep;
+      const effortSupported =
+        effort !== null && ctx.modelConfig.supportEfforts?.includes(effort) === true;
+      if (ctx.api === "anthropic-messages" && oldThinking.type === "adaptive") {
+        // pi-ai >=0.82 builds adaptive thinking for models carrying
+        // compat.forceAdaptiveThinking (streamSimpleKimi sets it on the
+        // anthropic runtime model). Keep the adaptive shape — effort lives in
+        // top-level output_config there, not inside thinking — and only
+        // replace it with an explicit disable when the level maps to off.
+        if (mapped.enabled) {
+          if (effortSupported) payload.output_config = { effort };
+          else delete payload.output_config;
+        } else {
+          payload.thinking = { type: "disabled" };
+          delete payload.output_config;
+        }
+      } else {
+        const thinking: JsonRecord = {
+          ...oldThinking,
+          type: mapped.enabled ? "enabled" : "disabled",
+        };
+        delete thinking.effort;
+        if (!mapped.enabled) delete thinking.keep;
+        if (mapped.enabled && effortSupported) {
+          thinking.effort = effort;
+        }
+        if (mapped.enabled && ctx.modelConfig.thinkingKeep) {
+          thinking.keep = ctx.modelConfig.thinkingKeep;
+        }
+        payload.thinking = thinking;
       }
-      payload.thinking = thinking;
     }
   }
 
@@ -510,15 +629,10 @@ export async function applyKimiPayloadMutations(
     }
   }
 
-  // 8. K2.7 Code API constraints: the server rejects non-default values for
-  //    temperature (must be 1.0) and top_p (must be 0.95), and tool_choice
-  //    "required" / function-specific when thinking is enabled (always-on).
-  if (payload.temperature !== undefined && payload.temperature !== 1) {
-    delete payload.temperature;
-  }
-  if (payload.top_p !== undefined && payload.top_p !== 0.95) {
-    delete payload.top_p;
-  }
+  // 8. K2.7 Code API constraints: the server rejects tool_choice "required" /
+  //    function-specific when thinking is enabled (always-on). temperature/top_p
+  //    are handled in step 6 — omitted unless explicitly configured, matching the
+  //    official kimi-code client rather than pinned to 1.0/0.95.
   if (payload.tool_choice !== undefined) {
     const tc = payload.tool_choice;
     const isAllowed =