pi-provider-kimi-code 0.6.11 → 0.6.13

package/src/settings-ui.ts

@@ -58,6 +58,13 @@ 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 } };
 }
@@ -73,6 +80,7 @@ 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})`,
     "",
     "Effective tools:",
@@ -138,6 +146,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

@@ -32,8 +32,10 @@ type KimiStreamSimple = (
 const piAiRuntime = piAi as unknown as {
   anthropicMessagesApi?: () => { streamSimple: KimiStreamSimple };
   openAICompletionsApi?: () => { streamSimple: KimiStreamSimple };
+  openAIResponsesApi?: () => { streamSimple: KimiStreamSimple };
   streamSimpleAnthropic?: KimiStreamSimple;
   streamSimpleOpenAICompletions?: KimiStreamSimple;
+  streamSimpleOpenAIResponses?: KimiStreamSimple;
   lazyApi?: (load: () => Promise<object>) => { streamSimple: KimiStreamSimple };
 };
 
@@ -43,22 +45,43 @@ const piAiRuntime = piAi as unknown as {
 // evaluated in plain-Node environments where the subpaths do resolve.
 const anthropicMessagesModule = "@earendil-works/pi-ai/api/anthropic-messages";
 const openAICompletionsModule = "@earendil-works/pi-ai/api/openai-completions";
+const openAIResponsesModule = "@earendil-works/pi-ai/api/openai-responses";
 
-const streamSimpleAnthropic: KimiStreamSimple =
-  piAiRuntime.anthropicMessagesApi?.().streamSimple ??
-  piAiRuntime.streamSimpleAnthropic ??
-  piAiRuntime.lazyApi?.(() => import(anthropicMessagesModule)).streamSimple!;
-const streamSimpleOpenAICompletions: KimiStreamSimple =
-  piAiRuntime.openAICompletionsApi?.().streamSimple ??
-  piAiRuntime.streamSimpleOpenAICompletions ??
-  piAiRuntime.lazyApi?.(() => import(openAICompletionsModule)).streamSimple!;
+// lazyApi is the last resort; it only exists on pi-ai versions that ship the
+// ./api/* subpath modules. Undefined when none of the three lookup paths
+// resolve (e.g. pi <=0.79 has no responses entry point at all).
+function lazyStreamSimple(load: () => Promise<object>): KimiStreamSimple | undefined {
+  return piAiRuntime.lazyApi?.(load)?.streamSimple;
+}
+
+// Not readonly: tests swap entries to simulate runtimes missing an API.
+const streamSimpleImpls: Record<KimiWireProtocol, KimiStreamSimple | undefined> = {
+  openai:
+    piAiRuntime.openAICompletionsApi?.().streamSimple ??
+    piAiRuntime.streamSimpleOpenAICompletions ??
+    lazyStreamSimple(() => import(openAICompletionsModule)),
+  anthropic:
+    piAiRuntime.anthropicMessagesApi?.().streamSimple ??
+    piAiRuntime.streamSimpleAnthropic ??
+    lazyStreamSimple(() => import(anthropicMessagesModule)),
+  responses:
+    piAiRuntime.openAIResponsesApi?.().streamSimple ??
+    piAiRuntime.streamSimpleOpenAIResponses ??
+    lazyStreamSimple(() => import(openAIResponsesModule)),
+};
 import {
   DEFAULT_KIMI_CODE_CONFIG,
   type KimiCodeConfig,
   type KimiResolvedModelConfig,
 } from "./config.ts";
 
-import { ENV_KIMI_CODE_PROTOCOL, PROVIDER_ID, getApiProtocol, getBaseUrl } from "./constants.ts";
+import {
+  ENV_KIMI_CODE_PROTOCOL,
+  PROVIDER_ID,
+  type KimiWireProtocol,
+  getApiProtocol,
+  getBaseUrl,
+} from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
 import {
   isKimiAuthErrorMessage,
@@ -224,6 +247,40 @@ export function mergeKimiRequestHeaders(headers?: HeaderMap): HeaderMap {
   return { ...getKimiProviderHeaders(), ...headers };
 }
 
+function streamSimpleForProtocol(
+  protocol: KimiWireProtocol,
+  model: Model<Api>,
+  context: Context,
+  options: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  const impl = streamSimpleImpls[protocol];
+  // Resolution runs once at module load against whichever pi-ai shape is
+  // installed, so an old pi-ai can leave the entry point undefined. Throw a
+  // descriptive error here — the caller invokes this inside the retry loop's
+  // try, so it surfaces as a stream error event instead of an unhandled
+  // rejection from a bare "not a function" TypeError.
+  if (!impl) {
+    throw new Error(
+      `installed pi-ai has no streamSimple entry point for ${getApiProtocol(protocol)}; ` +
+        "upgrade pi-ai or choose another KIMI_CODE_PROTOCOL",
+    );
+  }
+  return impl(model, context, options);
+}
+
+// Test hook: swap a resolved stream factory (pass undefined to simulate a
+// pi-ai runtime that lacks the entry point). Returns a restore function.
+export function overrideStreamSimpleForTests(
+  protocol: KimiWireProtocol,
+  impl: KimiStreamSimple | undefined,
+): () => void {
+  const original = streamSimpleImpls[protocol];
+  streamSimpleImpls[protocol] = impl;
+  return () => {
+    streamSimpleImpls[protocol] = original;
+  };
+}
+
 export function streamSimpleKimi(
   model: Model<Api>,
   context: Context,
@@ -303,6 +360,7 @@ export function streamSimpleKimi(
             cacheKey,
             cacheRetention,
             reasoning: options?.reasoning,
+            requestMaxTokens: options?.maxTokens,
             modelConfig,
           });
           if (
@@ -332,8 +390,9 @@ export function streamSimpleKimi(
       const patchedOptions = buildPatchedOptions(currentKey);
       // Route by the module-level protocol flag, not model.api, since we
       // register with a custom api type (kimi-openai-completions /
-      // kimi-anthropic-messages) to avoid overriding the built-in
-      // Anthropic/OpenAI stream handlers.
+      // kimi-anthropic-messages / kimi-openai-responses) to avoid overriding
+      // the built-in Anthropic/OpenAI stream handlers.
+      const existingCompat = (model as { compat?: Record<string, unknown> }).compat;
       const runtimeModel = {
         ...model,
         api: apiProtocol,
@@ -342,33 +401,38 @@ export function streamSimpleKimi(
         // 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).
+        // Responses rejects prompt_cache_retention (400) unless this is off.
         ...(wireProtocol === "anthropic"
           ? {
               compat: {
-                ...(model as { compat?: Record<string, unknown> }).compat,
+                ...existingCompat,
                 forceAdaptiveThinking: true,
                 allowEmptySignature: true,
               },
             }
-          : {}),
+          : wireProtocol === "responses"
+            ? {
+                compat: {
+                  ...existingCompat,
+                  supportsLongCacheRetention: false,
+                },
+              }
+            : {}),
       } as Model<Api>;
-      const upstream =
-        wireProtocol === "openai"
-          ? streamSimpleOpenAICompletions(
-              runtimeModel as Model<"openai-completions">,
-              context,
-              patchedOptions,
-            )
-          : streamSimpleAnthropic(
-              runtimeModel as Model<"anthropic-messages">,
-              context,
-              patchedOptions,
-            );
 
       let shouldRetry = false;
       let prefixBuffer: AssistantMessageEvent[] = [];
 
       try {
+        // Inside the try so a missing pi-ai stream entry point (old pi-ai +
+        // a protocol it does not ship) surfaces through the catch's error
+        // event instead of escaping the async IIFE as an unhandled rejection.
+        const upstream = streamSimpleForProtocol(
+          wireProtocol,
+          runtimeModel,
+          context,
+          patchedOptions,
+        );
         for await (const event of filterEmptyResponseStream(upstream)) {
           // streamAnthropic emits a synthetic "start" event synchronously,
           // before the for-await loop begins iterating and therefore before

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 {

package/src/usage.ts

@@ -1,4 +1,4 @@
-import { PROVIDER_ID, getBaseUrl } from "./constants.ts";
+import { PROVIDER_ID, getBaseUrl, normalizeKimiBaseV1 } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
 import { readStoredOAuthCredential, refreshKimiAuthToken } from "./oauth.ts";
 
@@ -51,6 +51,13 @@ function toNumber(value: unknown): number | null {
   return Number.isFinite(number) ? number : null;
 }
 
+function toOptionalNumber(value: unknown): number | null {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || !value.trim()) return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
 function toStringValue(value: unknown): string | undefined {
   if (typeof value === "string" && value.trim()) return value;
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
@@ -141,6 +148,85 @@ function formatExtraUsage(info: BoosterWalletInfo): string[] {
   return lines;
 }
 
+// Quota model (upstream kimi-code #3787): the platform /usages payload now
+// serves per-window used ratios under `usages` instead of absolute used/limit
+// rows. Keys are snake_case (`limit_5h`, `limit_7d`, `limit_month_total`,
+// `limit_month_code`); each entry carries `used_ratio` (0..1, sometimes a
+// decimal string) and an optional `reset_time`. Rows are presence-driven —
+// the backend omits windows the plan does not have. The legacy `usage` /
+// `limits` rows are still served alongside during the transition, but the
+// legacy wire is gone from kap-server, so quota rows win when present.
+interface QuotaEntry {
+  usedRatio: number;
+  resetTime?: string;
+}
+
+const QUOTA_WINDOWS = [
+  ["limit_5h", "5h limit"],
+  ["limit_7d", "Weekly limit"],
+  ["limit_month_total", "Monthly limit"],
+] as const;
+
+const QUOTA_MONTH_CODE_KEY = "limit_month_code";
+
+function isRecordValue(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function toRatio(value: unknown): number | undefined {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : undefined;
+  }
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : undefined;
+}
+
+function parseQuotaEntry(value: unknown): QuotaEntry | undefined {
+  if (!isRecordValue(value)) return undefined;
+  const usedRatio = toRatio(value.used_ratio);
+  if (usedRatio === undefined) return undefined;
+  const resetTime = toStringValue(value.reset_time);
+  return {
+    usedRatio,
+    ...(resetTime ? { resetTime } : {}),
+  };
+}
+
+function parseQuotaWindows(record: Record<string, unknown>): Map<string, QuotaEntry> {
+  const windows = new Map<string, QuotaEntry>();
+  const usages = record.usages;
+  if (!isRecordValue(usages)) return windows;
+  for (const key of [...QUOTA_WINDOWS.map(([key]) => key), QUOTA_MONTH_CODE_KEY]) {
+    const entry = parseQuotaEntry(usages[key]);
+    if (entry) windows.set(key, entry);
+  }
+  return windows;
+}
+
+function formatQuotaRow(label: string, entry: QuotaEntry, options: UsageFormatOptions): string {
+  const percent = Math.min(100, Math.max(0, Math.ceil(entry.usedRatio * 100)));
+  const lines = [label, `${quotaBar(entry.usedRatio * 100, 100)} ${percent}% used`];
+  const reset = formatResetTime(entry.resetTime, options);
+  if (reset) lines.push(`Resets ${reset}`);
+  return lines.join("\n");
+}
+
+// The kimi/code split of the monthly quota on the new plan: `code` is the
+// code-typed share of the monthly total as served, `kimi` the remainder
+// (mirrors upstream monthlyBreakdown in apps/kimi-code usage-format).
+function formatMonthlyBreakdown(
+  total: QuotaEntry,
+  windows: Map<string, QuotaEntry>,
+): string | null {
+  const code = windows.get(QUOTA_MONTH_CODE_KEY);
+  if (!code) return null;
+  const codePercent = Math.min(100, Math.max(0, Math.ceil(code.usedRatio * 100)));
+  const totalPercent = Math.min(100, Math.max(0, Math.ceil(total.usedRatio * 100)));
+  const kimiPercent = Math.max(0, totalPercent - codePercent);
+  return `kimi ${kimiPercent}% · code ${codePercent}%`;
+}
+
 export function parseUsageRow(value: unknown, fallbackLabel: string): UsageRow | null {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
@@ -164,11 +250,28 @@ export function parseUsageSummary(payload: unknown, options: UsageFormatOptions
 
   const record = payload as Record<string, unknown>;
   const lines: string[] = [];
-  const summary = parseUsageRow(record.usage, "Current week");
+
+  const quotaWindows = parseQuotaWindows(record);
+  // A code-split entry without a monthly total renders no row of its own; it
+  // only feeds the breakdown line, so it must not suppress the legacy rows.
+  const hasQuotaRows = QUOTA_WINDOWS.some(([key]) => quotaWindows.has(key));
+  if (hasQuotaRows) {
+    for (const [key, label] of QUOTA_WINDOWS) {
+      const entry = quotaWindows.get(key);
+      if (!entry) continue;
+      if (lines.length > 0) lines.push("");
+      lines.push(...formatQuotaRow(label, entry, options).split("\n"));
+      const breakdown =
+        key === "limit_month_total" ? formatMonthlyBreakdown(entry, quotaWindows) : null;
+      if (breakdown) lines.push(breakdown);
+    }
+  }
+
+  const summary = hasQuotaRows ? null : parseUsageRow(record.usage, "Current week");
   if (summary)
     lines.push(formatUsageRow({ ...summary, label: normalizeUsageLabel(summary.label) }, options));
 
-  if (Array.isArray(record.limits)) {
+  if (!hasQuotaRows && Array.isArray(record.limits)) {
     for (const [index, item] of record.limits.entries()) {
       const itemRecord =
         typeof item === "object" && item !== null && !Array.isArray(item)
@@ -307,8 +410,7 @@ function partialBlock(value: number): string {
 }
 
 export function buildKimiUsageUrl(baseUrl = getBaseUrl("openai")): string {
-  const normalized = baseUrl.replace(/\/+$/, "");
-  return normalized.endsWith("/v1") ? `${normalized}/usages` : `${normalized}/v1/usages`;
+  return `${normalizeKimiBaseV1(baseUrl)}/usages`;
 }
 
 function fetchKimiUsage(token: string, signal: AbortSignal): Promise<Response> {
@@ -383,6 +485,12 @@ export interface KimiUserInfo {
   userLevel: number;
   userLevelName: string;
   email?: string;
+  /**
+   * Plan generation from the managed /me profile (upstream #3921). upstream
+   * gates feedback surveys and plan-dependent surfaces by it; the monthly
+   * kimi/code quota split only exists on newer goods versions.
+   */
+  goodsVersion?: number;
 }
 
 export function parseKimiUserInfo(payload: unknown): KimiUserInfo | null {
@@ -391,12 +499,14 @@ export function parseKimiUserInfo(payload: unknown): KimiUserInfo | null {
   const userId = toStringValue(record.user_id);
   if (!userId) return null;
   const email = toStringValue(record.email);
+  const goodsVersion = toOptionalNumber(record.goods_version);
   return {
     userId,
     nickname: toStringValue(record.nickname) ?? "",
     userLevel: toNumber(record.user_level) ?? 0,
     userLevelName: toStringValue(record.user_level_name) ?? "",
     ...(email ? { email } : {}),
+    ...(goodsVersion !== null ? { goodsVersion } : {}),
   };
 }
 
@@ -412,8 +522,7 @@ export function formatKimiUserInfo(info: KimiUserInfo): string {
 }
 
 export function buildKimiUserInfoUrl(baseUrl = getBaseUrl("openai")): string {
-  const normalized = baseUrl.replace(/\/+$/, "");
-  return normalized.endsWith("/v1") ? `${normalized}/me` : `${normalized}/v1/me`;
+  return `${normalizeKimiBaseV1(baseUrl)}/me`;
 }
 
 function fetchKimiUserInfo(token: string, signal: AbortSignal): Promise<Response> {