pi-provider-kimi-code 0.6.2 → 0.6.5

package/src/payload.ts

@@ -6,7 +6,7 @@ import type { CacheRetention, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { KimiResolvedModelConfig, ModelReasoningEntry } from "./config.ts";
 
 import { getBaseUrl } from "./constants.ts";
-import { getCommonHeaders } from "./device.ts";
+import { getKimiProviderHeaders } from "./device.ts";
 import { optimizeToolSchemas } from "./schema-dedup.ts";
 
 // =============================================================================
@@ -116,7 +116,7 @@ export async function uploadKimiFile(
   try {
     const response = await fetch(uploadUrl, {
       method: "POST",
-      headers: { Authorization: `Bearer ${apiKey}`, ...getCommonHeaders() },
+      headers: { ...getKimiProviderHeaders(), Authorization: `Bearer ${apiKey}` },
       body: formData,
     });
     if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
@@ -425,7 +425,19 @@ export async function applyKimiPayloadMutations(
       : { include_usage: true };
   }
 
-  // 5. Normalize deprecated max_tokens (OpenAI path only — Anthropic
+  // 5. Spread extra_body into the top-level payload before normalization and
+  //    config caps. Top-level fields retain precedence over extra_body.
+  if (isRecord(payload.extra_body)) {
+    const extraBody = payload.extra_body as JsonRecord;
+    delete payload.extra_body;
+    for (const [key, value] of Object.entries(extraBody)) {
+      if (payload[key] === undefined) {
+        payload[key] = value;
+      }
+    }
+  }
+
+  // 6. Normalize deprecated max_tokens (OpenAI path only — Anthropic
   //    /messages uses max_tokens natively).
   if (ctx.api === "openai-completions") {
     if (payload.max_completion_tokens === undefined && typeof payload.max_tokens === "number") {
@@ -438,44 +450,45 @@ export async function applyKimiPayloadMutations(
   if (generation.temperature !== undefined) payload.temperature = generation.temperature;
   if (generation.topP !== undefined) payload.top_p = generation.topP;
   if (generation.maxCompletionTokens !== undefined) {
-    payload.max_completion_tokens = generation.maxCompletionTokens;
+    const maxTokensKey = ctx.api === "anthropic-messages" ? "max_tokens" : "max_completion_tokens";
+    const currentMaxTokens = payload[maxTokensKey];
+    payload[maxTokensKey] =
+      typeof currentMaxTokens === "number"
+        ? Math.min(currentMaxTokens, generation.maxCompletionTokens)
+        : generation.maxCompletionTokens;
   }
 
-  // 5. Spread extra_body into top-level payload before reasoning mapping,
-  //    matching upstream (Kimi expects thinking etc. at the root).
-  if (isRecord(payload.extra_body)) {
-    const extraBody = payload.extra_body as JsonRecord;
-    delete payload.extra_body;
-    for (const [key, value] of Object.entries(extraBody)) {
-      if (payload[key] === undefined) {
-        payload[key] = value;
-      }
-    }
+  // 7. Reasoning effort mapping. Kimi now accepts effort only inside the
+  //    thinking object, and only for values advertised by the model catalog.
+  delete payload.reasoning_effort;
+  if (ctx.modelConfig.supportsThinkingType === "no") {
+    delete payload.thinking;
   }
-
-  // 6. Reasoning effort mapping. Merges into any existing top-level thinking
-  //    field (which may have come from extra_body above).
   const resolvedReasoning = resolveThinkingLevel(ctx);
   if (resolvedReasoning) {
     const mapped = resolveReasoningForLevel(resolvedReasoning, ctx.modelConfig);
     if (mapped) {
-      if (mapped.effort !== null) {
-        payload.reasoning_effort = mapped.effort;
-      } else {
-        delete payload.reasoning_effort;
-      }
       const oldThinking = isRecord(payload.thinking) ? 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) {
-        (payload.thinking as JsonRecord).keep = ctx.modelConfig.thinkingKeep;
+        thinking.keep = ctx.modelConfig.thinkingKeep;
       }
+      payload.thinking = thinking;
     }
   }
 
-  // 7. K2.7 Code API constraints: the server rejects non-default values for
+  // 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) {

package/src/project-trust.ts

@@ -0,0 +1,24 @@
+export async function isKimiProjectConfigApproved(ctx: unknown, cwd: string): Promise<boolean> {
+  const check = (ctx as { isProjectTrusted?: () => boolean } | undefined)?.isProjectTrusted;
+  if (typeof check !== "function") return true;
+
+  let sessionTrusted: boolean;
+  try {
+    sessionTrusted = check.call(ctx);
+  } catch {
+    return false;
+  }
+  if (!sessionTrusted) return false;
+
+  const mod = (await import("@earendil-works/pi-coding-agent")) as unknown as {
+    ProjectTrustStore?: new (agentDir: string) => { get(cwd: string): boolean | null };
+    getAgentDir?: () => string;
+  };
+  if (!mod.ProjectTrustStore || !mod.getAgentDir) return true;
+
+  try {
+    return new mod.ProjectTrustStore(mod.getAgentDir()).get(cwd) === true;
+  } catch {
+    return false;
+  }
+}

package/src/settings-ui.ts

@@ -0,0 +1,204 @@
+import os from "node:os";
+import { relative } from "node:path";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { SettingsListTheme } from "@earendil-works/pi-tui";
+
+import {
+  type KimiCodeConfig,
+  type KimiCodeConfigSources,
+  KIMI_TOOL_NAMES,
+  type KimiToolName,
+  getGlobalKimiCodeConfigPath,
+  getProjectKimiCodeConfigPath,
+} from "./config.ts";
+import { PROVIDER_VERSION } from "./constants.ts";
+import type { KimiOAuthExtras } from "./models.ts";
+
+export type KimiConfigScope = "project" | "home";
+
+export function moonshotStatus(config: KimiCodeConfig): string {
+  return KIMI_TOOL_NAMES.map((toolName) => {
+    const tool = config.tools[toolName];
+    const enabled = tool.enabled ? "enabled" : "disabled";
+    const collapsed = tool.default_collapsed ? "collapsed" : "expanded";
+    return `${toolName}: ${enabled}, default ${collapsed}`;
+  }).join("\n");
+}
+
+export function toggleEnabled(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
+  return {
+    ...config,
+    tools: {
+      ...config.tools,
+      [toolName]: {
+        ...config.tools[toolName],
+        enabled: !config.tools[toolName].enabled,
+      },
+    },
+  };
+}
+
+export function toggleCollapsed(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
+  return {
+    ...config,
+    tools: {
+      ...config.tools,
+      [toolName]: {
+        ...config.tools[toolName],
+        default_collapsed: !config.tools[toolName].default_collapsed,
+      },
+    },
+  };
+}
+
+export function setProtocol(
+  config: KimiCodeConfig,
+  protocol: KimiCodeConfig["protocol"],
+): KimiCodeConfig {
+  return { ...config, protocol };
+}
+
+export function setUploadThreshold(config: KimiCodeConfig, thresholdBytes: number): KimiCodeConfig {
+  return { ...config, uploads: { ...config.uploads, thresholdBytes } };
+}
+
+export function buildKimiMainTitle(
+  config: KimiCodeConfig,
+  extras: KimiOAuthExtras,
+  sources: KimiCodeConfigSources,
+): string {
+  const modelName = extras.modelDisplay || "kimi-for-coding";
+  return [
+    `Kimi settings (provider v${PROVIDER_VERSION})`,
+    "",
+    `Model: ${modelName}`,
+    `Protocol: ${config.protocol} (${sources.protocol})`,
+    `Upload threshold: ${formatByteSize(config.uploads.thresholdBytes)} (${sources.uploads.thresholdBytes})`,
+    "",
+    "Effective tools:",
+    ...KIMI_TOOL_NAMES.map((toolName) => {
+      const enabled = config.tools[toolName].enabled ? "enabled" : "disabled";
+      return `- ${toolName}: ${enabled} (${sources.tools[toolName].enabled})`;
+    }),
+  ].join("\n");
+}
+
+export function buildConfigScopeTitle(
+  scope: KimiConfigScope,
+  config: KimiCodeConfig,
+  filePath: string,
+): string {
+  return [
+    `Edit ${scope} config`,
+    `File: ${filePath}`,
+    "",
+    formatProtocolStatus(config),
+    formatUploadThresholdStatus(config),
+    "",
+    moonshotStatus(config),
+  ].join("\n");
+}
+
+export function buildSettingsTheme(theme: Theme): SettingsListTheme {
+  return {
+    label: (text: string, selected: boolean) => (selected ? theme.fg("accent", text) : text),
+    value: (text: string, selected: boolean) =>
+      selected ? theme.bold(theme.fg("accent", text)) : theme.fg("muted", text),
+    description: (text: string) => theme.fg("dim", text),
+    cursor: theme.fg("accent", "> "),
+    hint: (text: string) => theme.fg("dim", text),
+  };
+}
+
+export function formatScopeDescription(
+  scope: KimiConfigScope,
+  cwd: string,
+  home = os.homedir(),
+): string {
+  const filePath =
+    scope === "project" ? getProjectKimiCodeConfigPath(cwd) : getGlobalKimiCodeConfigPath(home);
+  const displayPath = scope === "home" ? homeRelative(filePath, home) : relative(cwd, filePath);
+  return `Writes to the ${scope} config file: ${displayPath}`;
+}
+
+export function homeRelative(filePath: string, home = os.homedir()): string {
+  const normalizedHome = home.replace(/[\\/]+$/, "");
+  if (filePath === normalizedHome) return "~";
+
+  const slashPrefix = `${normalizedHome}/`;
+  if (filePath.startsWith(slashPrefix)) return `~/${filePath.slice(slashPrefix.length)}`;
+
+  const backslashPrefix = `${normalizedHome}\\`;
+  if (filePath.startsWith(backslashPrefix)) return `~\\${filePath.slice(backslashPrefix.length)}`;
+
+  return filePath;
+}
+
+export function toolMenuItem(config: KimiCodeConfig, toolName: KimiToolName): string {
+  return `${toolName} -> ${formatToolStatus(config, toolName)}`;
+}
+
+export function protocolMenuItem(config: KimiCodeConfig): string {
+  return `Protocol -> ${config.protocol}`;
+}
+
+export function uploadThresholdMenuItem(config: KimiCodeConfig): string {
+  return `Upload threshold -> ${formatByteSize(config.uploads.thresholdBytes)}`;
+}
+
+export function formatByteSize(bytes: number): string {
+  const units = [
+    { suffix: "GiB", size: 1024 ** 3 },
+    { suffix: "MiB", size: 1024 ** 2 },
+    { suffix: "KiB", size: 1024 },
+  ];
+  for (const unit of units) {
+    if (bytes >= unit.size && bytes % unit.size === 0) {
+      return `${bytes / unit.size} ${unit.suffix}`;
+    }
+  }
+  for (const unit of units) {
+    if (bytes >= unit.size) {
+      return `${(bytes / unit.size).toFixed(2).replace(/\.00$/, "")} ${unit.suffix}`;
+    }
+  }
+  return `${bytes} B`;
+}
+
+export function parseByteSizeInput(input: string): number | undefined {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(b|bytes?|kib|kb|mib|mb|gib|gb)?$/i);
+  if (!match) return undefined;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+  const unit = (match[2] ?? "mib").toLowerCase();
+  const multipliers: Record<string, number> = {
+    b: 1,
+    byte: 1,
+    bytes: 1,
+    kib: 1024,
+    kb: 1000,
+    mib: 1024 ** 2,
+    mb: 1000 ** 2,
+    gib: 1024 ** 3,
+    gb: 1000 ** 3,
+  };
+  const multiplier = multipliers[unit];
+  if (!multiplier) return undefined;
+  const bytes = Math.round(value * multiplier);
+  return Number.isSafeInteger(bytes) && bytes > 0 ? bytes : undefined;
+}
+
+export function formatProtocolStatus(config: KimiCodeConfig): string {
+  return `protocol: ${config.protocol}`;
+}
+
+export function formatUploadThresholdStatus(config: KimiCodeConfig): string {
+  return `upload threshold: ${formatByteSize(config.uploads.thresholdBytes)}`;
+}
+
+export function formatToolStatus(config: KimiCodeConfig, toolName: KimiToolName): string {
+  const tool = config.tools[toolName];
+  const enabled = tool.enabled ? "enabled" : "disabled";
+  const collapsed = tool.default_collapsed ? "default collapsed" : "default expanded";
+  return `${enabled}, ${collapsed}`;
+}

package/src/stream.ts

@@ -24,7 +24,7 @@ import {
 } from "./config.ts";
 
 import { ENV_KIMI_CODE_PROTOCOL, getApiProtocol, getBaseUrl } from "./constants.ts";
-import { getCommonHeaders } from "./device.ts";
+import { getKimiProviderHeaders } from "./device.ts";
 import { isKimiAuthErrorMessage, refreshKimiAuthToken } from "./oauth.ts";
 import {
   type Uploader,
@@ -163,7 +163,7 @@ export function resolveKimiApiKey(apiKey: string | undefined): string {
 }
 
 export function mergeKimiRequestHeaders(headers?: Record<string, string>): Record<string, string> {
-  return { ...getCommonHeaders(), ...headers };
+  return { ...getKimiProviderHeaders(), ...headers };
 }
 
 export function streamSimpleKimi(
@@ -192,8 +192,27 @@ export function streamSimpleKimi(
     protocol: ENV_KIMI_CODE_PROTOCOL,
     uploads: DEFAULT_KIMI_CODE_CONFIG.uploads,
   };
-  const modelConfig = streamConfig.model;
-  const apiProtocol = getApiProtocol(streamConfig.protocol);
+  const discoveredModel = model as Model<Api> & {
+    supportsThinkingType?: "only" | "no" | "both";
+    wireProtocol?: KimiCodeConfig["protocol"];
+    supportEfforts?: string[];
+    defaultEffort?: string;
+  };
+  const modelConfig: KimiResolvedModelConfig = {
+    ...streamConfig.model,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    input: [...model.input],
+    reasoning: model.reasoning,
+    supportsThinkingType:
+      discoveredModel.supportsThinkingType ?? (model.reasoning ? undefined : "no"),
+    supportEfforts: discoveredModel.supportEfforts
+      ? [...discoveredModel.supportEfforts]
+      : undefined,
+    defaultEffort: discoveredModel.defaultEffort,
+  };
+  const wireProtocol = discoveredModel.wireProtocol ?? streamConfig.protocol;
+  const apiProtocol = getApiProtocol(wireProtocol);
   const originalOnPayload = options?.onPayload;
   // The pi-side model id ("kimi-for-coding") is what users select via /model
   // and what gets persisted into sessions. The wire model id discovered at
@@ -257,10 +276,10 @@ export function streamSimpleKimi(
       const runtimeModel = {
         ...model,
         api: apiProtocol,
-        baseUrl: getBaseUrl(streamConfig.protocol),
+        baseUrl: getBaseUrl(wireProtocol),
       } as Model<Api>;
       const upstream =
-        streamConfig.protocol === "openai"
+        wireProtocol === "openai"
           ? streamSimpleOpenAICompletions(
               runtimeModel as Model<"openai-completions">,
               context,

package/src/tools/common.ts

@@ -2,8 +2,8 @@ import { AuthStorage, type AgentToolResult } from "@earendil-works/pi-coding-age
 import { truncateToWidth } from "@earendil-works/pi-tui";
 
 import { PROVIDER_ID, getBaseUrl } from "../constants.ts";
-import { getCommonHeaders } from "../device.ts";
-import { refreshKimiAuthToken } from "../oauth.ts";
+import { getKimiProviderHeaders } from "../device.ts";
+import { KIMI_LOGIN_REQUIRED_MESSAGE, refreshKimiAuthToken } from "../oauth.ts";
 
 export const KIMI_TOOL_TIMEOUT_MS = 180_000;
 
@@ -67,7 +67,7 @@ export function getKimiDatasourceUrl(): string {
 
 export function buildHeaders(accessToken: string, toolCallId: string): Record<string, string> {
   return {
-    ...getCommonHeaders(),
+    ...getKimiProviderHeaders(),
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json",
     "X-Msh-Tool-Call-Id": toolCallId,
@@ -94,7 +94,9 @@ export async function fetchWithAuthRetry(
   if (response.status !== 401) return response;
 
   const refreshed = await deps.refreshAccessToken(accessToken);
-  if (!refreshed || refreshed === accessToken) return response;
+  if (!refreshed || refreshed === accessToken) {
+    throw new Error(KIMI_LOGIN_REQUIRED_MESSAGE);
+  }
   return request(refreshed);
 }
 

package/src/tools/moonshot.ts

@@ -17,20 +17,6 @@ import {
 
 export const moonshotSearchSchema = Type.Object({
   query: Type.String({ description: "The query text to search for." }),
-  limit: Type.Optional(
-    Type.Number({
-      description: "The number of results to return.",
-      default: 5,
-      minimum: 1,
-      maximum: 20,
-    }),
-  ),
-  include_content: Type.Optional(
-    Type.Boolean({
-      description: "Whether to include fetched page content in the search results.",
-      default: false,
-    }),
-  ),
 });
 
 export const moonshotFetchSchema = Type.Object({
@@ -44,7 +30,8 @@ export interface MoonshotSearchResult {
   url: string;
   title: string;
   snippet: string;
-  content?: string;
+  date?: string;
+  siteName?: string;
 }
 
 export interface MoonshotFetchResult {
@@ -52,11 +39,6 @@ export interface MoonshotFetchResult {
   content: string;
 }
 
-function clampLimit(value: number | undefined): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) return 5;
-  return Math.max(1, Math.min(20, Math.trunc(value)));
-}
-
 interface MoonshotSearchResponse {
   search_results?: unknown;
 }
@@ -66,7 +48,7 @@ function stringField(record: Record<string, unknown>, key: string): string {
   return typeof value === "string" ? value : "";
 }
 
-function mapSearchResults(value: unknown, includeContent: boolean): MoonshotSearchResult[] {
+function mapSearchResults(value: unknown): MoonshotSearchResult[] {
   if (!Array.isArray(value)) return [];
   return value
     .filter((item): item is Record<string, unknown> => typeof item === "object" && item !== null)
@@ -76,9 +58,10 @@ function mapSearchResults(value: unknown, includeContent: boolean): MoonshotSear
         title: stringField(item, "title"),
         snippet: stringField(item, "snippet"),
       };
-      if (includeContent) {
-        result.content = stringField(item, "content");
-      }
+      const date = stringField(item, "date");
+      if (date) result.date = date;
+      const siteName = stringField(item, "site_name");
+      if (siteName) result.siteName = siteName;
       return result;
     });
 }
@@ -130,8 +113,10 @@ export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
   return defineTool({
     name: "moonshot_search",
     label: "Moonshot Search",
-    description: "Search the web through Kimi Coding's server-side Moonshot search service.",
-    promptSnippet: "Search the web with Kimi Coding's Moonshot search service",
+    description:
+      "Search the web through Kimi Coding. Results are summaries; use moonshot_fetch to read relevant pages.",
+    promptSnippet:
+      "Search the web with Kimi Coding, then fetch the few relevant result URLs before answering",
     parameters: moonshotSearchSchema,
 
     async execute(toolCallId, params, signal) {
@@ -142,20 +127,13 @@ export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
         );
       }
 
-      const limit = clampLimit(params.limit);
-      const includeContent = params.include_content === true;
       const timeout = buildTimeoutSignal(signal);
       try {
         const response = await fetchWithAuthRetry(deps, accessToken, (token) =>
           deps.fetch(`${getKimiBaseV1()}/search`, {
             method: "POST",
             headers: buildHeaders(token, toolCallId),
-            body: JSON.stringify({
-              text_query: params.query,
-              limit,
-              enable_page_crawling: includeContent,
-              timeout_seconds: 30,
-            }),
+            body: JSON.stringify({ text_query: params.query }),
             signal: timeout.signal,
           }),
         );
@@ -168,7 +146,7 @@ export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
         }
 
         const data = (await response.json()) as MoonshotSearchResponse;
-        const results = mapSearchResults(data.search_results, includeContent);
+        const results = mapSearchResults(data.search_results);
         return {
           content: [{ type: "text", text: searchResultsText(results) }],
           details: results,