pi-provider-kimi-code 0.6.7 → 0.6.9

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 =

package/src/stream.ts

@@ -58,9 +58,13 @@ import {
   type KimiResolvedModelConfig,
 } from "./config.ts";
 
-import { ENV_KIMI_CODE_PROTOCOL, getApiProtocol, getBaseUrl } from "./constants.ts";
+import { ENV_KIMI_CODE_PROTOCOL, PROVIDER_ID, getApiProtocol, getBaseUrl } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
-import { isKimiAuthErrorMessage, refreshKimiAuthToken } from "./oauth.ts";
+import {
+  isKimiAuthErrorMessage,
+  readStoredOAuthCredential,
+  refreshKimiAuthToken,
+} from "./oauth.ts";
 import {
   type Uploader,
   applyKimiPayloadMutations,
@@ -190,11 +194,21 @@ export async function* filterEmptyResponseStream(
 
 const KIMI_API_KEY_ENV_REFERENCES = new Set(["$KIMI_API_KEY", "${KIMI_API_KEY}"]);
 
+// On the normal request path pi resolves the provider credential through its
+// ModelRuntime and hands it to us. Callers that arrive through pi-ai's global
+// api registry (a bare agentLoop() with no streamFn) have no ModelRuntime
+// behind them and pass nothing, so read the same credential store pi itself
+// would have read instead of sending an unauthenticated request. Kept last so
+// an explicit key and the environment override keep their existing precedence.
+function getStoredKimiAccessToken(): string {
+  return readStoredOAuthCredential(PROVIDER_ID)?.access?.trim() || "";
+}
+
 export function resolveKimiApiKey(apiKey: string | undefined): string {
   if (apiKey !== undefined && KIMI_API_KEY_ENV_REFERENCES.has(apiKey)) {
-    return process.env.KIMI_API_KEY?.trim() || "";
+    return process.env.KIMI_API_KEY?.trim() || getStoredKimiAccessToken();
   }
-  return apiKey || process.env.KIMI_API_KEY || "";
+  return apiKey || process.env.KIMI_API_KEY || getStoredKimiAccessToken();
 }
 
 // SimpleStreamOptions.headers is Record<string, string> on pi <=0.79 and
@@ -285,6 +299,7 @@ export function streamSimpleKimi(
           await applyKimiPayloadMutations(nextPayload, {
             api: apiProtocol,
             upload,
+            uploadCacheScope: apiKey ? `${getBaseUrl(wireProtocol)}:${apiKey}` : undefined,
             cacheKey,
             cacheRetention,
             reasoning: options?.reasoning,
@@ -323,6 +338,19 @@ export function streamSimpleKimi(
         ...model,
         api: apiProtocol,
         baseUrl: getBaseUrl(wireProtocol),
+        // Kimi's anthropic-protocol endpoint speaks adaptive thinking and
+        // rejects/ignores the interleaved-thinking beta header; pi-ai >=0.82
+        // keys both behaviors off these compat flags (its own built-in
+        // kimi-coding models carry them in generated metadata).
+        ...(wireProtocol === "anthropic"
+          ? {
+              compat: {
+                ...(model as { compat?: Record<string, unknown> }).compat,
+                forceAdaptiveThinking: true,
+                allowEmptySignature: true,
+              },
+            }
+          : {}),
       } as Model<Api>;
       const upstream =
         wireProtocol === "openai"

package/src/usage.ts

@@ -2,15 +2,6 @@ import { PROVIDER_ID, getBaseUrl } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
 import { readStoredOAuthCredential, refreshKimiAuthToken } from "./oauth.ts";
 
-const MEMBERSHIP_LEVEL_NAMES: Record<string, string> = {
-  LEVEL_FREE: "Free",
-  LEVEL_BASIC: "Adagio",
-  LEVEL_STANDARD: "Moderato",
-  LEVEL_INTERMEDIATE: "Allegretto",
-  LEVEL_ADVANCED: "Allegro",
-  LEVEL_PREMIUM: "Vivace",
-};
-
 const RESET_TIME_KEYS = [
   "resetTime",
   "reset_time",
@@ -36,7 +27,6 @@ export interface UsageFormatOptions {
 
 export interface KimiUsageSnapshot {
   summary: string;
-  membershipLevel: string | null;
 }
 
 interface BoosterWalletInfo {
@@ -174,9 +164,6 @@ export function parseUsageSummary(payload: unknown, options: UsageFormatOptions
 
   const record = payload as Record<string, unknown>;
   const lines: string[] = [];
-  const membership = parseMembership(record);
-  if (membership) lines.push(membership, "");
-
   const summary = parseUsageRow(record.usage, "Current week");
   if (summary)
     lines.push(formatUsageRow({ ...summary, label: normalizeUsageLabel(summary.label) }, options));
@@ -235,24 +222,6 @@ function formatWindowLabel(value: unknown, fallbackLabel: string): string {
   return `Current ${minutes}m window`;
 }
 
-export function parseMembershipLevel(record: Record<string, unknown>): string | null {
-  const user = record.user;
-  if (typeof user !== "object" || user === null || Array.isArray(user)) return null;
-  const membership = (user as Record<string, unknown>).membership;
-  if (typeof membership !== "object" || membership === null || Array.isArray(membership)) {
-    return null;
-  }
-  const level = (membership as Record<string, unknown>).level;
-  return typeof level === "string" && level ? level : null;
-}
-
-export function parseMembership(record: Record<string, unknown>): string | null {
-  const level = parseMembershipLevel(record);
-  if (!level) return null;
-  const name = MEMBERSHIP_LEVEL_NAMES[level];
-  return name ? `Membership: ${name} (${level})` : `Membership: ${level}`;
-}
-
 export function formatUsageRow(row: UsageRow, options: UsageFormatOptions = {}): string {
   if (row.limit <= 0) return `${row.label}\n${row.used} used`;
   const used = Math.max(0, Math.min(row.used, row.limit));
@@ -356,10 +325,7 @@ export async function fetchKimiUsageSnapshot(
 ): Promise<KimiUsageSnapshot> {
   const token = options.token ?? getKimiUsageToken();
   if (!token) {
-    return {
-      summary: "Usage: missing credentials. Run /login kimi-coding.",
-      membershipLevel: null,
-    };
+    return { summary: "Usage: missing credentials. Run /login kimi-coding." };
   }
 
   const controller = new AbortController();
@@ -371,17 +337,13 @@ export async function fetchKimiUsageSnapshot(
       if (refreshed) response = await fetchKimiUsage(refreshed, controller.signal);
     }
     if (!response.ok) {
-      return { summary: `Usage: fetch failed (${response.status})`, membershipLevel: null };
+      return { summary: `Usage: fetch failed (${response.status})` };
     }
     const payload = (await response.json()) as unknown;
-    const membershipLevel =
-      typeof payload === "object" && payload !== null && !Array.isArray(payload)
-        ? parseMembershipLevel(payload as Record<string, unknown>)
-        : null;
-    return { summary: parseUsageSummary(payload), membershipLevel };
+    return { summary: parseUsageSummary(payload) };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    return { summary: `Usage: fetch failed (${message})`, membershipLevel: null };
+    return { summary: `Usage: fetch failed (${message})` };
   } finally {
     clearTimeout(timeout);
   }