pi-provider-kimi-code 0.6.12 → 0.6.14

package/src/payload.ts

@@ -37,6 +37,8 @@ export interface KimiPayloadContext {
   cacheKey?: string;
   cacheRetention: CacheRetention;
   reasoning?: ThinkingLevel;
+  /** Per-request cap from the caller (pi options.maxTokens); wins over the omission policy. */
+  requestMaxTokens?: number;
   modelConfig: KimiResolvedModelConfig;
 }
 
@@ -264,6 +266,155 @@ async function transformOpenAIPayloadFiles(
   }
 }
 
+// -----------------------------------------------------------------------------
+// Per-request inline media budget (upstream kimi-code #3784,
+// mediaResolverService.applyMediaBudget): accumulated inline media count
+// against a 20 MB per-request base64 wire-size budget (not decoded media
+// bytes); when exceeded, the oldest items are dropped until the total is under
+// the 10 MB base64 wire-size low-water mark and replaced with an omission
+// placeholder. OpenAI data URLs count the full data: URL string, including its
+// small prefix overhead, while Anthropic base64 blocks count the source data
+// string. Uploaded ms:// references are tiny and never counted. Media is
+// deduped by content hash so a repeated image counts once and every occurrence
+// is dropped together.
+// -----------------------------------------------------------------------------
+
+const REQUEST_MEDIA_BUDGET_BYTES = 20 * 1024 * 1024;
+const REQUEST_MEDIA_BUDGET_LOW_BYTES = 10 * 1024 * 1024;
+
+interface InlineMediaBudgetEntry {
+  kind: "image" | "video";
+  key: string;
+  bytes: number;
+  /** Indices into messages[...].content[...] (a third index addresses a tool_result's content). */
+  path: number[];
+}
+
+function inlineMediaKey(kind: string, payload: string): string {
+  return createHash("sha256").update(kind).update("\0").update(payload).digest("hex");
+}
+
+function collectOpenAIInlineMedia(payload: JsonRecord): InlineMediaBudgetEntry[] {
+  const entries: InlineMediaBudgetEntry[] = [];
+  if (!Array.isArray(payload.messages)) return entries;
+  for (const [messageIndex, message] of payload.messages.entries()) {
+    if (!isRecord(message) || !Array.isArray(message.content)) continue;
+    for (const [blockIndex, block] of (message.content as unknown[]).entries()) {
+      if (!isRecord(block)) continue;
+      const field =
+        block.type === "image_url" ? "image_url" : block.type === "video_url" ? "video_url" : null;
+      if (!field) continue;
+      const kind = block.type === "image_url" ? "image" : "video";
+      const value = block[field];
+      const url =
+        typeof value === "string"
+          ? value
+          : isRecord(value) && typeof value.url === "string"
+            ? value.url
+            : null;
+      if (!url || !url.startsWith("data:")) continue;
+      entries.push({
+        kind,
+        key: inlineMediaKey(kind, url),
+        bytes: url.length,
+        path: [messageIndex, blockIndex],
+      });
+    }
+  }
+  return entries;
+}
+
+function collectAnthropicInlineMedia(payload: JsonRecord): InlineMediaBudgetEntry[] {
+  const entries: InlineMediaBudgetEntry[] = [];
+  if (!Array.isArray(payload.messages)) return entries;
+  const collect = (messageIndex: number, path: number[], block: unknown): void => {
+    if (!isRecord(block)) return;
+    const kind = block.type === "image" || block.type === "video" ? block.type : null;
+    if (
+      kind &&
+      isRecord(block.source) &&
+      block.source.type === "base64" &&
+      typeof block.source.media_type === "string" &&
+      typeof block.source.data === "string"
+    ) {
+      const data = block.source.data;
+      entries.push({
+        kind,
+        key: inlineMediaKey(kind, `${block.source.media_type}\0${data}`),
+        bytes: data.length,
+        path: [messageIndex, ...path],
+      });
+    }
+  };
+  for (const [messageIndex, message] of payload.messages.entries()) {
+    if (!isRecord(message) || !Array.isArray(message.content)) continue;
+    for (const [blockIndex, block] of (message.content as unknown[]).entries()) {
+      if (isRecord(block) && block.type === "tool_result" && Array.isArray(block.content)) {
+        for (const [nestedIndex, nested] of (block.content as unknown[]).entries()) {
+          collect(messageIndex, [blockIndex, nestedIndex], nested);
+        }
+        continue;
+      }
+      collect(messageIndex, [blockIndex], block);
+    }
+  }
+  return entries;
+}
+
+export function applyInlineMediaBudget(
+  payload: JsonRecord,
+  api: "anthropic-messages" | "openai-completions",
+  budgetBytes: number = REQUEST_MEDIA_BUDGET_BYTES,
+  lowBytes: number = REQUEST_MEDIA_BUDGET_LOW_BYTES,
+): boolean {
+  const entries =
+    api === "anthropic-messages"
+      ? collectAnthropicInlineMedia(payload)
+      : collectOpenAIInlineMedia(payload);
+  if (entries.length === 0) return false;
+
+  // Deduplicate by content: repeated media counts once, drops hit every copy.
+  const bytesByKey = new Map<string, number>();
+  for (const entry of entries) {
+    if (!bytesByKey.has(entry.key)) bytesByKey.set(entry.key, entry.bytes);
+  }
+  let total = 0;
+  for (const bytes of bytesByKey.values()) total += bytes;
+  if (total <= budgetBytes) return false;
+
+  const dropped = new Set<string>();
+  for (const [key, bytes] of bytesByKey) {
+    if (total <= lowBytes) break;
+    if (bytes === 0) continue;
+    dropped.add(key);
+    total -= bytes;
+  }
+
+  const messages = payload.messages as unknown[];
+  let droppedCount = 0;
+  for (const entry of entries) {
+    if (!dropped.has(entry.key)) continue;
+    const message = messages[entry.path[0]] as JsonRecord;
+    const content = message.content as unknown[];
+    const placeholder = {
+      type: "text",
+      text: `[${entry.kind} omitted: dropped to fit the request media budget]`,
+    };
+    if (entry.path.length === 2) {
+      content[entry.path[1]] = placeholder;
+    } else {
+      const toolResult = content[entry.path[1]] as JsonRecord;
+      (toolResult.content as unknown[])[entry.path[2]] = placeholder;
+    }
+    droppedCount += 1;
+  }
+  console.warn(
+    `[kimi-coding] inline media exceeded the ${String(budgetBytes / (1024 * 1024))} MB ` +
+      `per-request budget; ${String(droppedCount)} media item(s) omitted`,
+  );
+  return true;
+}
+
 function isEffectivelyEmptyOpenAIContent(content: unknown): boolean {
   if (typeof content === "string") return content.trim() === "";
   if (!Array.isArray(content)) return false;
@@ -472,6 +623,75 @@ async function transformAnthropicPayloadFiles(
 
 const RESPONSES_EFFORTS = new Set(["low", "high", "max"]);
 
+// Empty/whitespace-only text parts in the Responses `input` array. Assistant
+// turns that produced no text (reasoning + tool calls only) replay as
+// output_text:"" and upstream 400s on text non-emptiness; see issue #78.
+const RESPONSES_TEXT_PART_TYPES = new Set(["output_text", "text", "input_text"]);
+
+function isEmptyTextPart(part: unknown): boolean {
+  return (
+    isRecord(part) &&
+    typeof part.type === "string" &&
+    RESPONSES_TEXT_PART_TYPES.has(part.type) &&
+    (typeof part.text !== "string" || part.text.trim() === "")
+  );
+}
+
+export function stripEmptyResponsesTextParts(payload: JsonRecord): boolean {
+  if (!Array.isArray(payload.input)) return false;
+  let changed = false;
+  const input: unknown[] = [];
+  for (const item of payload.input) {
+    if (!isRecord(item)) {
+      input.push(item);
+      continue;
+    }
+    // Typed non-message items (function_call, reasoning, ...) pass through.
+    if (typeof item.type === "string" && item.type !== "message") {
+      input.push(item);
+      continue;
+    }
+    const role = item.role;
+    const content = item.content;
+    const isAssistantLike = role === "assistant" || role == null;
+    if (typeof content === "string") {
+      if (isAssistantLike && content.trim() === "") {
+        changed = true;
+        continue;
+      }
+      input.push(item);
+      continue;
+    }
+    if (!Array.isArray(content)) {
+      // A message item with missing/non-array content carries nothing to
+      // render; drop assistant-shaped ones instead of replaying a
+      // contentless message (the upstream 400 path this fix targets).
+      if (isAssistantLike && (content === undefined || content === null)) {
+        changed = true;
+        continue;
+      }
+      input.push(item);
+      continue;
+    }
+    const next = content.filter((part) => !isEmptyTextPart(part));
+    // An assistant message with nothing left — either filtered here or
+    // arriving empty — carries no information; drop it rather than send a
+    // contentless message. User/system messages keep their content.
+    if (next.length === 0 && isAssistantLike) {
+      changed = true;
+      continue;
+    }
+    if (next.length === content.length) {
+      input.push(item);
+      continue;
+    }
+    changed = true;
+    input.push({ ...item, content: next });
+  }
+  if (changed) payload.input = input;
+  return changed;
+}
+
 function responsesSupportedEfforts(ctx: KimiPayloadContext): string[] {
   const advertised = ctx.modelConfig.supportEfforts;
   if (advertised?.length) return advertised.filter((effort) => RESPONSES_EFFORTS.has(effort));
@@ -547,6 +767,19 @@ export async function applyKimiPayloadMutations(
     );
   }
 
+  // 1b. Responses wire: drop empty text parts replayed from text-less
+  // assistant turns (issue #78). pi-ai's Responses serializer keeps empty
+  // output_text blocks — unlike its Chat Completions serializer, which
+  // filters them — so a reasoning/tool-only turn is replayed as
+  // {role:"assistant", content:[{type:"output_text", text:""}]} on every
+  // subsequent request, and upstream endpoints reject the whole payload with
+  // a 400-class text-non-emptiness error. function_call / reasoning / all
+  // other part types are untouched; an assistant message left with no
+  // content is dropped entirely.
+  if (ctx.api === "openai-responses") {
+    stripEmptyResponsesTextParts(payload);
+  }
+
   // 2. File upload dispatch (protocol-specific).
   if (ctx.upload) {
     const uploadCache = ctx.uploadCacheScope ? uploadedFileCache : new Map<string, string>();
@@ -557,6 +790,11 @@ export async function applyKimiPayloadMutations(
       await transformAnthropicPayloadFiles(payload, ctx.upload, uploadCache, uploadCacheScope);
     }
   }
+  if (ctx.api === "openai-completions" || ctx.api === "anthropic-messages") {
+    // Runs after the upload transforms so media already promoted to ms://
+    // references (tiny URLs) are never counted against the budget.
+    applyInlineMediaBudget(payload, ctx.api);
+  }
   if (ctx.api === "openai-completions") {
     normalizeOpenAIAssistantToolCalls(payload);
   }
@@ -590,8 +828,12 @@ export async function applyKimiPayloadMutations(
 
   // 5. Spread extra_body into the top-level payload before normalization and
   //    config caps. Top-level fields retain precedence over extra_body.
+  let extraBodyHadCap = false;
   if (isRecord(payload.extra_body)) {
     const extraBody = payload.extra_body as JsonRecord;
+    extraBodyHadCap = ["max_tokens", "max_completion_tokens", "max_output_tokens"].some(
+      (key) => typeof extraBody[key] === "number",
+    );
     delete payload.extra_body;
     for (const [key, value] of Object.entries(extraBody)) {
       if (payload[key] === undefined) {
@@ -620,6 +862,29 @@ export async function applyKimiPayloadMutations(
   }
 
   const generation = ctx.modelConfig.generation;
+  // Output cap policy (mirrors upstream kimi-code #4091): omit the completion
+  // cap on the OpenAI wires unless explicitly configured. pi-ai seeds a cap
+  // clamped to the context window (clampMaxTokensToContext), and forwarding
+  // that value breaks strict serving stacks (e.g. bare vLLM) that reject a
+  // cap above the model's real output limit with repeated 400s. A cap counts
+  // as explicit when generation.maxCompletionTokens is configured
+  // (KIMI_MODEL_MAX_COMPLETION_TOKENS / config generation.maxCompletionTokens),
+  // model.maxTokens holds a non-window value, or the caller supplies a
+  // per-request cap through options.maxTokens / extra_body. Anthropic /messages requires
+  // max_tokens, so that wire keeps pi-ai's window-clamped cap — the same
+  // window - usedContextTokens value upstream fills in when unset.
+  if (ctx.api === "openai-completions" || ctx.api === "openai-responses") {
+    const capKey = ctx.api === "openai-responses" ? "max_output_tokens" : "max_completion_tokens";
+    const explicitModelCap =
+      typeof ctx.modelConfig.maxTokens === "number" &&
+      ctx.modelConfig.maxTokens > 0 &&
+      ctx.modelConfig.maxTokens !== ctx.modelConfig.contextWindow;
+    const explicitRequestCap =
+      extraBodyHadCap || (typeof ctx.requestMaxTokens === "number" && ctx.requestMaxTokens > 0);
+    if (generation.maxCompletionTokens === undefined && !explicitModelCap && !explicitRequestCap) {
+      delete payload[capKey];
+    }
+  }
   // 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:
@@ -720,7 +985,7 @@ export async function applyKimiPayloadMutations(
     }
   }
 
-  // 8. K2.7 Code API constraints: the server rejects tool_choice "required" /
+  // 8. Kimi coding endpoint constraints: the server rejects tool_choice "required" /
   //    function-specific when thinking is enabled (always-on). Responses only
   //    accepts auto. temperature/top_p are handled in step 6 — omitted unless
   //    explicitly configured, matching the official kimi-code client rather

package/src/schema-dedup.ts

@@ -1,5 +1,13 @@
 // Tool schema deduplication: extract repeated sub-schemas into $defs/$ref
 // to stay under Moonshot's ~15 KB per-tool function.parameters limit.
+//
+// Known risk (upstream kimi-code #4489-era): the official client does the
+// OPPOSITE for its Anthropic-protocol path — it fully dereferences $ref
+// (normalizeKimiToolSchema) because Anthropic-style serving stacks do not
+// resolve $defs. No managed Kimi model declares `protocol: "anthropic"` in
+// /models yet (verified 2026-11), so dedup is safe on the OpenAI-compatible
+// path this extension uses today. If a managed model ever ships with the
+// anthropic protocol, gate this dedup off for that protocol.
 
 import { createHash } from "node:crypto";
 

package/src/settings-ui.ts

@@ -58,10 +58,24 @@ export function setProtocol(
   return { ...config, protocol };
 }
 
+export function setRegion(
+  config: KimiCodeConfig,
+  region: KimiCodeConfig["region"],
+): KimiCodeConfig {
+  return { ...config, region };
+}
+
 export function setUploadThreshold(config: KimiCodeConfig, thresholdBytes: number): KimiCodeConfig {
   return { ...config, uploads: { ...config.uploads, thresholdBytes } };
 }
 
+export function setThinkingKeep(
+  config: KimiCodeConfig,
+  thinkingKeep: KimiCodeConfig["model"]["thinkingKeep"],
+): KimiCodeConfig {
+  return { ...config, model: { ...config.model, thinkingKeep } };
+}
+
 export function buildKimiMainTitle(
   config: KimiCodeConfig,
   extras: KimiOAuthExtras,
@@ -73,7 +87,9 @@ export function buildKimiMainTitle(
     "",
     `Model: ${modelName}`,
     `Protocol: ${config.protocol} (${sources.protocol})`,
+    `Region: ${formatRegionValue(config.region)} (${sources.region})`,
     `Upload threshold: ${formatByteSize(config.uploads.thresholdBytes)} (${sources.uploads.thresholdBytes})`,
+    `Thinking keep: ${config.model.thinkingKeep ?? "default"} (${sources.model.thinkingKeep})`,
     "",
     "Effective tools:",
     ...KIMI_TOOL_NAMES.map((toolName) => {
@@ -138,6 +154,18 @@ export function toolMenuItem(config: KimiCodeConfig, toolName: KimiToolName): st
   return `${toolName} -> ${formatToolStatus(config, toolName)}`;
 }
 
+export function formatRegionValue(region: KimiCodeConfig["region"]): string {
+  return region ?? "auto";
+}
+
+export function formatRegionStatus(config: KimiCodeConfig): string {
+  return `region: ${formatRegionValue(config.region)}`;
+}
+
+export function regionMenuItem(config: KimiCodeConfig): string {
+  return `Region -> ${formatRegionValue(config.region)}`;
+}
+
 export function protocolMenuItem(config: KimiCodeConfig): string {
   return `Protocol -> ${config.protocol}`;
 }

package/src/stream.ts

@@ -83,6 +83,16 @@ import {
   getBaseUrl,
 } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
+import { improveKimiErrorMessage } from "./errors.ts";
+
+function improveErrorEvent(event: AssistantMessageEvent): AssistantMessageEvent {
+  if (event.type !== "error") return event;
+  const message = event.error?.errorMessage;
+  if (!message) return event;
+  const improved = improveKimiErrorMessage(message);
+  if (improved === message || !event.error) return event;
+  return { ...event, error: { ...event.error, errorMessage: improved } };
+}
 import {
   isKimiAuthErrorMessage,
   readStoredOAuthCredential,
@@ -360,6 +370,7 @@ export function streamSimpleKimi(
             cacheKey,
             cacheRetention,
             reasoning: options?.reasoning,
+            requestMaxTokens: options?.maxTokens,
             modelConfig,
           });
           if (
@@ -470,10 +481,11 @@ export function streamSimpleKimi(
           }
 
           // First non-start, non-retry event: flush buffered prefix, then
-          // stream normally.
+          // stream normally. Quota-exhaustion errors get an actionable
+          // rewrite (hard limit, not a transient 429).
           for (const e of prefixBuffer) filtered.push(e);
           prefixBuffer = [];
-          filtered.push(event);
+          filtered.push(improveErrorEvent(event));
         }
 
         // Stream ended normally: flush any remaining buffered starts.
@@ -508,7 +520,9 @@ export function streamSimpleKimi(
               model: model.id,
               content: [],
               stopReason: "error",
-              errorMessage: err instanceof Error ? err.message : String(err),
+              errorMessage: improveKimiErrorMessage(
+                err instanceof Error ? err.message : String(err),
+              ),
               usage: {
                 input: 0,
                 output: 0,

package/src/tools/common.ts

@@ -1,7 +1,7 @@
 import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 
-import { PROVIDER_ID, getBaseUrl } from "../constants.ts";
+import { PROVIDER_ID, getBaseUrl, normalizeKimiBaseV1 } from "../constants.ts";
 import { getKimiProviderHeaders } from "../device.ts";
 import {
   KIMI_LOGIN_REQUIRED_MESSAGE,
@@ -57,8 +57,7 @@ export function buildTimeoutSignal(signal: AbortSignal | undefined): {
 }
 
 export function getKimiBaseV1(): string {
-  const base = getBaseUrl().replace(/\/+$/, "");
-  return base.endsWith("/v1") ? base : `${base}/v1`;
+  return normalizeKimiBaseV1(getBaseUrl());
 }
 
 export function getKimiDatasourceUrl(): string {