pi-provider-kimi-code 0.5.0 → 0.6.0

package/src/config.ts

@@ -1,11 +1,18 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
+export const KIMI_TOOL_NAMES = ["moonshot_search", "moonshot_fetch", "kimi_datasource"] as const;
+
+export type KimiToolName = (typeof KIMI_TOOL_NAMES)[number];
+
+export type KimiConfigSource = "project" | "home" | "default";
+
 export interface KimiCodeConfig {
-  tools: {
-    moonshot_search: { enabled: boolean; default_collapsed: boolean };
-    moonshot_fetch: { enabled: boolean; default_collapsed: boolean };
-  };
+  tools: Record<KimiToolName, { enabled: boolean; default_collapsed: boolean }>;
+}
+
+export interface KimiCodeConfigSources {
+  tools: Record<KimiToolName, { enabled: KimiConfigSource; default_collapsed: KimiConfigSource }>;
 }
 
 export interface LoadKimiCodeConfigOptions {
@@ -13,11 +20,16 @@ export interface LoadKimiCodeConfigOptions {
   home: string;
 }
 
+function makeDefaultTools(): KimiCodeConfig["tools"] {
+  const tools = {} as KimiCodeConfig["tools"];
+  for (const name of KIMI_TOOL_NAMES) {
+    tools[name] = { enabled: false, default_collapsed: true };
+  }
+  return tools;
+}
+
 export const DEFAULT_KIMI_CODE_CONFIG: KimiCodeConfig = {
-  tools: {
-    moonshot_search: { enabled: false, default_collapsed: true },
-    moonshot_fetch: { enabled: false, default_collapsed: true },
-  },
+  tools: makeDefaultTools(),
 };
 
 export function getGlobalKimiCodeConfigPath(home: string): string {
@@ -85,23 +97,61 @@ function readDefaultCollapsed(config: Record<string, unknown>, toolName: string)
   return tool.default_collapsed !== false;
 }
 
+function hasToolField(
+  config: Record<string, unknown>,
+  toolName: KimiToolName,
+  field: "enabled" | "default_collapsed",
+): boolean {
+  const tools = config.tools;
+  if (!isRecord(tools)) return false;
+  const tool = tools[toolName];
+  if (!isRecord(tool)) return false;
+  return Object.hasOwn(tool, field);
+}
+
+function readToolConfig(
+  config: Record<string, unknown>,
+  toolName: KimiToolName,
+): { enabled: boolean; default_collapsed: boolean } {
+  return {
+    enabled: readEnabled(config, toolName),
+    default_collapsed: readDefaultCollapsed(config, toolName),
+  };
+}
+
 export function loadKimiCodeConfig(options: LoadKimiCodeConfigOptions): KimiCodeConfig {
   const globalConfig = readConfigFile(getGlobalKimiCodeConfigPath(options.home));
   const projectConfig = readConfigFile(getProjectKimiCodeConfigPath(options.cwd));
   const merged = mergeConfig(globalConfig, projectConfig);
 
-  return {
-    tools: {
-      moonshot_search: {
-        enabled: readEnabled(merged, "moonshot_search"),
-        default_collapsed: readDefaultCollapsed(merged, "moonshot_search"),
-      },
-      moonshot_fetch: {
-        enabled: readEnabled(merged, "moonshot_fetch"),
-        default_collapsed: readDefaultCollapsed(merged, "moonshot_fetch"),
-      },
-    },
-  };
+  const tools = {} as KimiCodeConfig["tools"];
+  for (const name of KIMI_TOOL_NAMES) {
+    tools[name] = readToolConfig(merged, name);
+  }
+  return { tools };
+}
+
+export function loadKimiCodeConfigSources(
+  options: LoadKimiCodeConfigOptions,
+): KimiCodeConfigSources {
+  const homeConfig = readConfigFileQuiet(getGlobalKimiCodeConfigPath(options.home));
+  const projectConfig = readConfigFileQuiet(getProjectKimiCodeConfigPath(options.cwd));
+  const tools = {} as KimiCodeConfigSources["tools"];
+  for (const name of KIMI_TOOL_NAMES) {
+    tools[name] = {
+      enabled: hasToolField(projectConfig, name, "enabled")
+        ? "project"
+        : hasToolField(homeConfig, name, "enabled")
+          ? "home"
+          : "default",
+      default_collapsed: hasToolField(projectConfig, name, "default_collapsed")
+        ? "project"
+        : hasToolField(homeConfig, name, "default_collapsed")
+          ? "home"
+          : "default",
+    };
+  }
+  return { tools };
 }
 
 export function loadProjectKimiCodeConfig(cwd: string): KimiCodeConfig {
@@ -114,18 +164,11 @@ export function loadHomeKimiCodeConfig(home: string): KimiCodeConfig {
 
 function loadKimiCodeConfigFile(path: string): KimiCodeConfig {
   const projectConfig = readConfigFileQuiet(path);
-  return {
-    tools: {
-      moonshot_search: {
-        enabled: readEnabled(projectConfig, "moonshot_search"),
-        default_collapsed: readDefaultCollapsed(projectConfig, "moonshot_search"),
-      },
-      moonshot_fetch: {
-        enabled: readEnabled(projectConfig, "moonshot_fetch"),
-        default_collapsed: readDefaultCollapsed(projectConfig, "moonshot_fetch"),
-      },
-    },
-  };
+  const tools = {} as KimiCodeConfig["tools"];
+  for (const name of KIMI_TOOL_NAMES) {
+    tools[name] = readToolConfig(projectConfig, name);
+  }
+  return { tools };
 }
 
 export function saveProjectKimiCodeConfig(cwd: string, config: KimiCodeConfig): void {
@@ -138,13 +181,15 @@ export function saveHomeKimiCodeConfig(home: string, config: KimiCodeConfig): vo
 
 function saveKimiCodeConfigFile(path: string, config: KimiCodeConfig): void {
   const raw = readConfigFileQuiet(path);
+  const tools: Record<string, unknown> = {
+    ...(isRecord(raw.tools) ? raw.tools : {}),
+  };
+  for (const name of KIMI_TOOL_NAMES) {
+    tools[name] = { ...config.tools[name] };
+  }
   const next = {
     ...raw,
-    tools: {
-      ...(isRecord(raw.tools) ? raw.tools : {}),
-      moonshot_search: { ...config.tools.moonshot_search },
-      moonshot_fetch: { ...config.tools.moonshot_fetch },
-    },
+    tools,
   };
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, "utf8");

package/src/constants.ts

@@ -24,10 +24,9 @@ export const DEFAULT_BASE_URL = IS_OPENAI_PROTOCOL
   ? "https://api.kimi.com/coding/v1"
   : "https://api.kimi.com/coding";
 
-export const KIMI_CODE_VERSION = "0.1.1";
-export const KIMI_CODE_USER_AGENT_PRODUCT = "kimi-code-cli";
-export const KIMI_CODE_USER_AGENT = `${KIMI_CODE_USER_AGENT_PRODUCT}/${KIMI_CODE_VERSION}`;
-export const KIMI_PLATFORM = "kimi-code-cli";
+export const KIMI_CODE_VERSION = "0.6.0";
+export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_CODE_VERSION}`;
+export const KIMI_PLATFORM = "kimi_code_cli";
 
 export function getKimiCodeHome(): string {
   const value = process.env.KIMI_CODE_HOME?.trim();

package/src/models.ts

@@ -13,6 +13,7 @@ export interface KimiOAuthExtras {
   contextLength?: number;
   supportsReasoning?: boolean;
   supportsImageIn?: boolean;
+  supportsThinkingType?: "only" | "no" | "both";
 }
 
 export type KimiOAuthCredentials = OAuthCredentials & KimiOAuthExtras;
@@ -23,6 +24,12 @@ interface KimiServerModel {
   context_length?: unknown;
   supports_reasoning?: unknown;
   supports_image_in?: unknown;
+  supports_thinking_type?: unknown;
+}
+
+function parseSupportsThinkingType(value: unknown): "only" | "no" | "both" | undefined {
+  if (value === "only" || value === "no" || value === "both") return value;
+  return undefined;
 }
 
 export function buildModelsUrl(baseUrl: string): string {
@@ -55,7 +62,10 @@ export async function discoverKimiModelMetadata(accessToken: string): Promise<Ki
     if (typeof preferred.context_length === "number" && preferred.context_length > 0) {
       extras.contextLength = preferred.context_length;
     }
-    if (typeof preferred.supports_reasoning === "boolean") {
+    const thinkingType = parseSupportsThinkingType(preferred.supports_thinking_type);
+    if (thinkingType) {
+      extras.supportsThinkingType = thinkingType;
+    } else if (typeof preferred.supports_reasoning === "boolean") {
       extras.supportsReasoning = preferred.supports_reasoning;
     }
     if (typeof preferred.supports_image_in === "boolean") {
@@ -71,7 +81,8 @@ export function applyKimiOAuthExtrasToModel(
   model: Model<Api>,
   extras: KimiOAuthExtras,
 ): Model<Api> {
-  const next: Model<Api> & { wireModelId?: string } = { ...model };
+  const next: Model<Api> & { wireModelId?: string; supportsThinkingType?: "only" | "no" | "both" } =
+    { ...model };
   if (typeof extras.modelDisplay === "string" && extras.modelDisplay) {
     next.name = extras.modelDisplay;
   }
@@ -81,8 +92,12 @@ export function applyKimiOAuthExtrasToModel(
   if (typeof extras.wireModelId === "string" && extras.wireModelId) {
     next.wireModelId = extras.wireModelId;
   }
-  if (typeof extras.supportsReasoning === "boolean") {
+  if (typeof extras.supportsThinkingType === "string") {
+    next.reasoning = extras.supportsThinkingType !== "no";
+    next.supportsThinkingType = extras.supportsThinkingType;
+  } else if (typeof extras.supportsReasoning === "boolean") {
     next.reasoning = extras.supportsReasoning;
+    next.supportsThinkingType = undefined;
   }
   if (typeof extras.supportsImageIn === "boolean") {
     const input = ["text"];
@@ -101,7 +116,11 @@ function parseKimiModelCapabilities(value: string | undefined): KimiOAuthExtras
       .filter(Boolean),
   );
   return {
-    supportsReasoning: caps.has("thinking") || caps.has("always_thinking"),
+    supportsThinkingType: caps.has("always_thinking")
+      ? "only"
+      : caps.has("thinking")
+        ? "both"
+        : "no",
     supportsImageIn: caps.has("image_in"),
   };
 }

package/src/oauth.ts

@@ -388,6 +388,7 @@ export async function refreshKimiAuthToken(currentKey: string): Promise<string |
     console.error("[kimi-coding] auth refresh: requesting new access token");
     const refreshed = await refreshAccessToken(cred.refresh);
     const newCred: OAuthCredential = {
+      ...cred,
       type: "oauth",
       access: refreshed.access_token,
       refresh: refreshed.refresh_token,

package/src/payload.ts

@@ -39,6 +39,7 @@ export interface KimiPayloadContext {
   reasoning?: ThinkingLevel;
   thinkingKeep?: string;
   envOverrides: KimiEnvOverrides;
+  supportsThinkingType?: "only" | "no" | "both";
 }
 
 export function isRecord(value: unknown): value is JsonRecord {
@@ -54,6 +55,16 @@ function mapThinkingLevel(level?: string): { effort: string | null; enabled: boo
   return undefined;
 }
 
+function resolveThinkingLevel(ctx: KimiPayloadContext): ThinkingLevel | undefined {
+  if (ctx.supportsThinkingType === "no") return undefined;
+  if (ctx.supportsThinkingType === "only") {
+    if (!ctx.reasoning) return "low";
+    const mapped = mapThinkingLevel(ctx.reasoning);
+    if (mapped && !mapped.enabled) return "low";
+  }
+  return ctx.reasoning;
+}
+
 function parseInlineUploadThreshold(raw: string | undefined): number {
   const parsed = Number.parseInt(raw ?? "", 10);
   return Number.isFinite(parsed) && parsed >= 0
@@ -87,8 +98,7 @@ export function readEnvOverrides(): KimiEnvOverrides {
   if (temp) out.temperature = parseFloat(temp);
   const topP = process.env.KIMI_MODEL_TOP_P;
   if (topP) out.topP = parseFloat(topP);
-  const maxCompletionTokens =
-    process.env.KIMI_MODEL_MAX_COMPLETION_TOKENS ?? process.env.KIMI_MODEL_MAX_TOKENS;
+  const maxCompletionTokens = process.env.KIMI_MODEL_MAX_COMPLETION_TOKENS;
   if (maxCompletionTokens) out.maxCompletionTokens = parseInt(maxCompletionTokens, 10);
   return out;
 }
@@ -421,18 +431,24 @@ export async function applyKimiPayloadMutations(
     if (resolved) payload.prompt_cache_key = resolved;
   }
 
-  // 4. Env-level hyperparameter overrides (pre-parsed into numbers by caller).
+  // 4. Normalize deprecated max_tokens and apply env-level hyperparameter
+  //    overrides (pre-parsed into numbers by caller).
+  if (payload.max_completion_tokens === undefined && typeof payload.max_tokens === "number") {
+    payload.max_completion_tokens = payload.max_tokens;
+  }
+  delete payload.max_tokens;
+
   const { temperature, topP, maxCompletionTokens } = ctx.envOverrides;
   if (temperature !== undefined) payload.temperature = temperature;
   if (topP !== undefined) payload.top_p = topP;
   if (maxCompletionTokens !== undefined) {
     payload.max_completion_tokens = maxCompletionTokens;
-    delete payload.max_tokens;
   }
 
   // 5. Reasoning effort mapping.
-  if (ctx.reasoning) {
-    const mapped = mapThinkingLevel(ctx.reasoning);
+  const resolvedReasoning = resolveThinkingLevel(ctx);
+  if (resolvedReasoning) {
+    const mapped = mapThinkingLevel(resolvedReasoning);
     if (mapped) {
       payload.reasoning_effort = mapped.effort;
       const extraBody = isRecord(payload.extra_body) ? payload.extra_body : {};

package/src/stream.ts

@@ -19,6 +19,7 @@ import {
 } from "@earendil-works/pi-ai";
 
 import { IS_OPENAI_PROTOCOL, PROTOCOL } from "./constants.ts";
+import { getCommonHeaders } from "./device.ts";
 import { isKimiAuthErrorMessage, refreshKimiAuthToken } from "./oauth.ts";
 import {
   type Uploader,
@@ -46,24 +47,50 @@ export async function* filterEmptyResponseStream(
 ): AsyncIterable<AssistantMessageEvent> {
   const suppressedIndices = new Set<number>();
   let textBuffer: AssistantMessageEvent[] = [];
+  let bufferedText = "";
   let bufferingIndex: number | null = null;
 
+  const suppressBufferedTextBlock = (): void => {
+    if (bufferingIndex !== null) suppressedIndices.add(bufferingIndex);
+    textBuffer = [];
+    bufferedText = "";
+    bufferingIndex = null;
+  };
+
+  const flushBufferedTextBlock = async function* (): AsyncIterable<AssistantMessageEvent> {
+    for (const buffered of textBuffer) yield buffered;
+    textBuffer = [];
+    bufferedText = "";
+    bufferingIndex = null;
+  };
+
   for await (const event of upstream) {
-    // Start buffering when a new text block begins.
+    // Start buffering only long enough to decide whether this text block is
+    // Kimi's synthetic "(Empty response: ...)" wrapper. Normal text is flushed
+    // as soon as it diverges from the marker so output still streams.
     if (event.type === "text_start") {
       bufferingIndex = event.contentIndex;
       textBuffer = [event];
+      bufferedText = "";
       continue;
     }
 
-    // Accumulate text deltas + detect the empty-response marker on text_end.
     if (
       bufferingIndex !== null &&
       "contentIndex" in event &&
       event.contentIndex === bufferingIndex
     ) {
       if (event.type === "text_delta") {
+        bufferedText += event.delta;
         textBuffer.push(event);
+        if (bufferedText.startsWith(EMPTY_RESPONSE_PREFIX)) {
+          suppressBufferedTextBlock();
+          continue;
+        }
+        if (EMPTY_RESPONSE_PREFIX.startsWith(bufferedText)) {
+          continue;
+        }
+        yield* flushBufferedTextBlock();
         continue;
       }
       if (event.type === "text_end") {
@@ -72,14 +99,11 @@ export async function* filterEmptyResponseStream(
           // array: it is a shared reference into session state, and mutating
           // it would shift subsequent contentIndex values, corrupting the
           // stream.
-          suppressedIndices.add(bufferingIndex);
+          suppressBufferedTextBlock();
         } else {
-          // Legitimate text block — flush buffered events + end event.
-          for (const buffered of textBuffer) yield buffered;
+          yield* flushBufferedTextBlock();
           yield event;
         }
-        textBuffer = [];
-        bufferingIndex = null;
         continue;
       }
     }
@@ -103,19 +127,36 @@ export async function* filterEmptyResponseStream(
 
     yield event;
   }
+
+  if (bufferingIndex !== null) {
+    yield* flushBufferedTextBlock();
+  }
 }
 
 // =============================================================================
 // Stream wrapper: orchestrates payload mutation + event filter
 // =============================================================================
 
+const KIMI_API_KEY_ENV_REFERENCES = new Set(["$KIMI_API_KEY", "${KIMI_API_KEY}"]);
+
+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 apiKey || process.env.KIMI_API_KEY || "";
+}
+
+export function mergeKimiRequestHeaders(headers?: Record<string, string>): Record<string, string> {
+  return { ...getCommonHeaders(), ...headers };
+}
+
 export function streamSimpleKimi(
   model: Model<Api>,
   context: Context,
   options?: SimpleStreamOptions,
 ): AssistantMessageEventStream {
   const filtered = createAssistantMessageEventStream();
-  const initialKey = options?.apiKey || process.env.KIMI_API_KEY || "";
+  const initialKey = resolveKimiApiKey(options?.apiKey);
 
   const cacheKeyOverride = (
     options as (SimpleStreamOptions & { prompt_cache_key?: unknown }) | undefined
@@ -131,6 +172,9 @@ export function streamSimpleKimi(
   // the model object via modifyModels and rewritten into the request payload
   // here so /v1/chat/completions and /v1/messages see the real wire id.
   const wireModelId = (model as Model<Api> & { wireModelId?: unknown }).wireModelId;
+  const supportsThinkingType = (
+    model as Model<Api> & { supportsThinkingType?: "only" | "no" | "both" }
+  ).supportsThinkingType;
 
   const buildPatchedOptions = (apiKey: string): SimpleStreamOptions => {
     const upload: Uploader | undefined = apiKey
@@ -142,6 +186,7 @@ export function streamSimpleKimi(
     return {
       ...options,
       ...apiKeyOverride,
+      headers: mergeKimiRequestHeaders(options?.headers),
       onPayload: async (payload, modelData) => {
         let nextPayload: unknown = payload;
 
@@ -154,6 +199,7 @@ export function streamSimpleKimi(
             reasoning: options?.reasoning,
             thinkingKeep,
             envOverrides,
+            supportsThinkingType,
           });
           if (
             typeof wireModelId === "string" &&

package/src/tools/common.ts

@@ -0,0 +1,115 @@
+import { AuthStorage, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+import { PROVIDER_ID, getBaseUrl } from "../constants.ts";
+import { getCommonHeaders } from "../device.ts";
+import { refreshKimiAuthToken } from "../oauth.ts";
+
+export const KIMI_TOOL_TIMEOUT_MS = 180_000;
+
+export interface KimiToolDeps {
+  fetch: typeof fetch;
+  getAccessToken: () => string | null;
+  refreshAccessToken: (currentToken: string) => Promise<string | null>;
+}
+
+export interface BuildKimiToolOptions {
+  deps?: Partial<KimiToolDeps>;
+  defaultCollapsed?: boolean;
+}
+
+function defaultGetAccessToken(): string | null {
+  const credential = AuthStorage.create().get(PROVIDER_ID);
+  if (!credential || credential.type !== "oauth") return null;
+  return credential.access;
+}
+
+export function buildKimiToolDeps(options: BuildKimiToolOptions = {}): KimiToolDeps {
+  return {
+    fetch: options.deps?.fetch ?? fetch,
+    getAccessToken: options.deps?.getAccessToken ?? defaultGetAccessToken,
+    refreshAccessToken: options.deps?.refreshAccessToken ?? refreshKimiAuthToken,
+  };
+}
+
+export function buildTimeoutSignal(signal: AbortSignal | undefined): {
+  signal: AbortSignal;
+  cleanup: () => void;
+} {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), KIMI_TOOL_TIMEOUT_MS);
+  const abort = () => controller.abort();
+  if (signal?.aborted) {
+    controller.abort();
+  } else {
+    signal?.addEventListener("abort", abort, { once: true });
+  }
+
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    },
+  };
+}
+
+export function getKimiBaseV1(): string {
+  const base = getBaseUrl().replace(/\/+$/, "");
+  return base.endsWith("/v1") ? base : `${base}/v1`;
+}
+
+export function getKimiDatasourceUrl(): string {
+  const explicit = process.env.KIMI_DATASOURCE_API_URL?.trim();
+  if (explicit) return explicit;
+  return `${getKimiBaseV1()}/tools`;
+}
+
+export function buildHeaders(accessToken: string, toolCallId: string): Record<string, string> {
+  return {
+    ...getCommonHeaders(),
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "X-Msh-Tool-Call-Id": toolCallId,
+  };
+}
+
+export function errorResult<T>(message: string): AgentToolResult<T> {
+  return {
+    content: [{ type: "text", text: message }],
+    details: undefined as T,
+  };
+}
+
+export async function readErrorBody(response: Response): Promise<string> {
+  return response.text().catch(() => "");
+}
+
+export async function fetchWithAuthRetry(
+  deps: KimiToolDeps,
+  accessToken: string,
+  request: (token: string) => Promise<Response>,
+): Promise<Response> {
+  const response = await request(accessToken);
+  if (response.status !== 401) return response;
+
+  const refreshed = await deps.refreshAccessToken(accessToken);
+  if (!refreshed || refreshed === accessToken) return response;
+  return request(refreshed);
+}
+
+export function textComponent(text: string) {
+  return {
+    render: (width: number) => text.split("\n").map((line) => truncateToWidth(line, width, "…")),
+    invalidate: () => {},
+  };
+}
+
+export function firstText(result: AgentToolResult<unknown>): string {
+  const first = result.content[0];
+  return first?.type === "text" ? first.text : "";
+}
+
+export function shouldCollapse(defaultCollapsed: boolean, expanded: boolean | undefined): boolean {
+  return defaultCollapsed && expanded !== true;
+}