pi-provider-kimi-code 0.5.1 → 0.6.0

package/README.md

@@ -5,28 +5,32 @@
 
 **Use Kimi Code in Pi, with the Kimi parts handled.**
 
-Pi already has a basic `kimi-coding` provider. This extension is for the parts that start to matter once Kimi Code becomes part of your real Pi workflow: account login reuse, file uploads, measured cache behavior, live model metadata, and optional Moonshot search/fetch tools.
+Pi already has a basic `kimi-coding` provider. This extension is for the parts that start to matter once Kimi Code becomes part of your real Pi workflow: account login reuse, file uploads, measured cache behavior, live model metadata, and optional Moonshot search/fetch/datasource tools.
+
+> **Kimi K2.7 supported.** The provider automatically discovers the current model from Kimi's `/v1/models` endpoint at login time, so new rollouts (including K2.7) are picked up immediately without a package update.
 
 ## Why this exists
 
-Pi is a small harness you adapt to your own workflow. Kimi CLI is Moonshot's official Kimi Code path. This package sits between them: Kimi Code as a Pi provider, plus the Kimi-specific details that the basic provider keeps simple.
+Pi is a small harness you adapt to your own workflow. Kimi Code is Moonshot's official coding agent. This package sits between them: Kimi Code as a Pi provider, plus the Kimi-specific details that the basic provider keeps simple.
+
+Kimi's API surface goes beyond the LLM itself. It includes file uploads, web search, page fetch, and a growing set of datasource APIs. This extension wires those capabilities into Pi so you can use them alongside the community's existing extensions — MCP servers, custom themes, skills, and any other Pi add-on — without leaving the harness.
 
-- **Use your Kimi account.** Log in with `/login kimi-coding`, or reuse an existing `kimi-cli` session.
+- **Use your Kimi account.** Log in with `/login kimi-coding`, or reuse an existing `kimi-code` session.
 - **Send files the Kimi way.** Large inline images go through Kimi's Files API and become `ms://` references instead of huge base64 payloads.
 - **Know what the cache is doing.** Kimi caches by content prefix. This repo measures that behavior instead of pretending `prompt_cache_key` controls it.
 - **Use the safer protocol by default.** OpenAI-compatible mode is the default because tool results are less ambiguous there. Anthropic-compatible mode is still available.
-- **Turn on Kimi-native tools when you want them.** `moonshot_search` and `moonshot_fetch` are opt-in, configurable per user or per project.
+- **Turn on Kimi-native tools when you want them.** `moonshot_search`, `moonshot_fetch`, and `kimi_datasource` are opt-in, configurable per user or per project.
 
 ## What this package adds
 
 - Kimi account login in Pi, plus `KIMI_API_KEY` for CI or pay-per-token use.
-- `kimi-cli` credential reuse from `~/.kimi/credentials/kimi-code.json`.
+- `kimi-code` credential reuse from `~/.kimi/credentials/kimi-code.json`.
 - Kimi Files API uploads for large inline images.
 - Live model metadata from Kimi at login / refresh time.
 - OpenAI-compatible mode by default, Anthropic-compatible mode on request.
 - Kimi K2.6 reasoning level mapping for Pi's reasoning controls.
 - Stream cleanup for Kimi's thinking-only placeholder text.
-- Optional `moonshot_search` and `moonshot_fetch` tools via `/kimi-settings`.
+- Optional `moonshot_search`, `moonshot_fetch`, and unified datasource `kimi_datasource` tools via `/kimi-settings`.
 - No build step; Pi loads the TypeScript extension directly.
 
 ## Install
@@ -62,13 +66,13 @@ Inside Pi, run:
 
 A browser tab opens, you sign into your Kimi account, and Pi stores the credential at `~/.pi/agent/auth.json`. Tokens refresh automatically.
 
-If you already use `kimi-cli`, this extension can reuse its credential file:
+If you already use `kimi-code`, this extension can reuse its credential file:
 
 ```text
 ~/.kimi/credentials/kimi-code.json
 ```
 
-The file is read-only from this extension's side. Set `KIMI_SHARE_DIR` if your `kimi-cli` share directory lives somewhere else.
+The file is read-only from this extension's side. Set `KIMI_SHARE_DIR` if your `kimi-code` share directory lives somewhere else.
 
 For CI or pay-per-token use, set `KIMI_API_KEY` instead:
 
@@ -90,32 +94,20 @@ Select it inside Pi:
 /model kimi-coding/kimi-for-coding
 ```
 
-Kimi keeps Coding models behind aliases. Rather than hardcoding a stale model list, this extension asks Kimi for the current model info when you log in or refresh. If your account is on a newer rollout or internal test, Pi can pick up the latest model name and context size without waiting for a package release.
+Kimi keeps Coding models behind aliases. Rather than hardcoding a stale model list, this extension asks Kimi for the current model info when you log in or refresh. If your account is on a newer rollout (e.g., Kimi K2.7) or internal test, Pi can pick up the latest model name and context size without waiting for a package release.
 
 Fallback values:
 
-- Context window: `262144` tokens
-- Max output: `32000` tokens
+- Context window: `256k` tokens
+- Max output: `32k` tokens
 - Input: text and image
 - Reasoning: enabled
 
-Kimi K2.6 supports Pi's reasoning levels. This provider maps them to Kimi's current reasoning efforts:
-
-- `off` / `none` — reasoning disabled
-- `minimal` / `low` — low effort
-- `medium` — medium effort
-- `high` / `xhigh` — high effort
-
-If Kimi reports a larger context window, the provider uses that value. You can also override the advertised context or model name with `KIMI_MODEL_MAX_CONTEXT_SIZE` / `KIMI_MODEL_NAME`; see [docs/ENV.md](docs/ENV.md).
+The provider maps Pi's reasoning levels to Kimi's reasoning-effort controls. The exact mapping depends on the model returned by the server at login time, and the provider refreshes it automatically on every credential refresh.
 
-## Optional Moonshot tools
+## Optional tools
 
-Kimi Coding has server-side search and fetch tools. This extension can expose them to Pi as:
-
-- `moonshot_search`
-- `moonshot_fetch`
-
-They are off by default. Turn them on when you want Kimi's own search/fetch path in the agent loop.
+Kimi Coding has server-side capabilities that this extension can expose as opt-in tools. All tools are off by default. Enable them individually through `/kimi-settings` or JSON config.
 
 Inside Pi, run:
 
@@ -130,18 +122,50 @@ Config files are JSON:
 - Home: `~/.pi/pi-provider-kimi-code.json`
 - Project override: `<cwd>/.pi/pi-provider-kimi-code.json`
 
-Project config overrides home config with a deep merge. Missing files or missing keys mean both tools stay off.
+Project config overrides home config with a deep merge. Missing files or missing keys mean all tools stay off.
+
+### Available tools
+
+| Tool              | Description                                    |
+| ----------------- | ---------------------------------------------- |
+| `moonshot_search` | Web search through Kimi's Moonshot service     |
+| `moonshot_fetch`  | Web page fetch through Kimi's Moonshot service |
+| `kimi_datasource` | Unified Kimi datasource tool                   |
+
+### Example config
 
 ```json
 {
   "tools": {
     "moonshot_search": { "enabled": true, "default_collapsed": true },
-    "moonshot_fetch": { "enabled": true, "default_collapsed": true }
+    "moonshot_fetch": { "enabled": true, "default_collapsed": true },
+    "kimi_datasource": { "enabled": true, "default_collapsed": true }
   }
 }
 ```
 
-Both tools require `/login kimi-coding` OAuth credentials. `KIMI_API_KEY` is not used for these tools. Your account also needs access to Moonshot's server-side search/fetch services; if not, the upstream service can return subscription or whitelist errors.
+### Datasource tool
+
+`kimi_datasource` calls Kimi's `/tools` endpoint. It accepts `data_source_name` plus optional `api_name` and `params`:
+
+- Without `api_name`: returns the datasource description (available APIs).
+- With `api_name` and `params`: calls the specified API.
+
+Supported datasource names:
+
+| Datasource             | Description                           |
+| ---------------------- | ------------------------------------- |
+| `stock_finance_data`   | Chinese stock and financial data      |
+| `yahoo_finance`        | Yahoo Finance market data             |
+| `world_bank_open_data` | World Bank open statistics            |
+| `tianyancha`           | Chinese enterprise and corporate data |
+| `arxiv`                | Academic paper search and metadata    |
+| `scholar`              | Academic literature search            |
+| `yuandian_law`         | Chinese legal database and case law   |
+
+### Common notes
+
+All tools require `/login kimi-coding` OAuth credentials. `KIMI_API_KEY` is not used for these tools. Your account also needs access to Moonshot's server-side services; if not, the upstream service can return subscription or whitelist errors.
 
 `default_collapsed` controls only the TUI preview. The full tool result still goes to the model; set it to `false` if you want previews expanded by default.
 
@@ -156,13 +180,13 @@ Most users do not need environment variables. Two are worth knowing:
 
 Moonshot search/fetch tools are configured through `/kimi-settings` or JSON config files, not env vars.
 
-The full env list, including base URL overrides, `kimi-cli` path overrides, upload tuning, debug logs, and model metadata overrides, lives in [docs/ENV.md](docs/ENV.md).
+The full env list, including base URL overrides, `kimi-code` path overrides, upload tuning, debug logs, and model metadata overrides, lives in [docs/ENV.md](docs/ENV.md).
 
 ## Notes
 
-### Kimi CLI vs Pi
+### Kimi Code vs Pi
 
-`kimi-cli` is Moonshot's official terminal agent. Pi is the harness you adapt to your own workflow: extensions, skills, prompts, themes, custom commands, status bars, and UI pieces. This package lets you keep Kimi Code as the model path while staying inside Pi.
+`kimi-code` is Moonshot's official terminal agent. Pi is the harness you adapt to your own workflow: extensions, skills, prompts, themes, custom commands, status bars, and UI pieces. This package lets you keep Kimi Code as the model path while staying inside Pi.
 
 ### Cache behavior
 
@@ -189,7 +213,7 @@ The OpenAI-compatible protocol uses a dedicated `role: "tool"` message, so the b
 
 ### Is this affiliated with Moonshot AI?
 
-No. This is an independent extension. The login flow is derived from the public implementation in the open-source [`kimi-cli`](https://github.com/MoonshotAI/kimi-cli) repository.
+No. This is an independent extension. The login flow is derived from the public implementation in the open-source Kimi Code repository.
 
 ## Troubleshooting
 
@@ -203,17 +227,17 @@ The login flow always prints a verification URL. If your terminal or OS blocks a
 
 ### "Access denied" or subscription errors after a successful login
 
-Your Moonshot account needs an active Kimi Code subscription for the provider to do anything useful. If the same account works in `kimi-cli`, re-run `/login kimi-coding` to refresh credentials.
+Your Moonshot account needs an active Kimi Code Plan for the provider to do anything useful. If the same account works in `kimi-code`, re-run `/login kimi-coding` to refresh credentials.
 
-### Moonshot tools do not show up
+### Tools do not show up
 
-Run `/kimi-settings` and check whether `moonshot_search` / `moonshot_fetch` are enabled in the home or project config. These tools also require `/login kimi-coding`; `KIMI_API_KEY` is not enough.
+Run `/kimi-settings` and check whether the tool is enabled in the home or project config. All tools also require `/login kimi-coding`; `KIMI_API_KEY` is not enough.
 
 If you changed the JSON config by hand, reload it through `/kimi-settings` or start a new Pi session.
 
-### Moonshot tools return subscription or whitelist errors
+### Tools return subscription or whitelist errors
 
-The tools call Moonshot's server-side search/fetch services. Some accounts may not have access even with an active Kimi Code Plan. The error comes from the upstream service.
+The tools call Moonshot's server-side services. Some accounts may not have access even with an active Kimi Code Plan. The error comes from the upstream service.
 
 ### Large images fail with a payload error
 
@@ -238,7 +262,6 @@ In OpenAI mode this extension maps the `developer` role to `system` (Kimi's Codi
 ## References
 
 - Pi: [earendil-works/pi](https://github.com/earendil-works/pi)
-- Upstream login implementation and feature request: [MoonshotAI/kimi-cli](https://github.com/MoonshotAI/kimi-cli) · [kimi-cli#757](https://github.com/MoonshotAI/kimi-cli/issues/757)
 - Environment variables: [docs/ENV.md](docs/ENV.md)
 - Testing guide: [docs/TESTING.md](docs/TESTING.md)
 - Cache behavior: [docs/caching.md](docs/caching.md)
@@ -246,7 +269,7 @@ In OpenAI mode this extension maps the `developer` role to `system` (Kimi's Codi
 
 ## Credits
 
-Based on the login implementation from [`kimi-cli`](https://github.com/MoonshotAI/kimi-cli) by Moonshot AI. Built as a Pi extension by [@badlogic](https://github.com/badlogic).
+Based on the login implementation from Kimi Code by Moonshot AI. Built as a Pi extension by [@badlogic](https://github.com/badlogic).
 
 ## License
 

package/index.ts

@@ -29,13 +29,16 @@ import { relative } from "node:path";
 
 import {
   type KimiCodeConfig,
+  KIMI_TOOL_NAMES,
   getProjectKimiCodeConfigPath,
   getGlobalKimiCodeConfigPath,
   loadHomeKimiCodeConfig,
   loadKimiCodeConfig,
+  loadKimiCodeConfigSources,
   loadProjectKimiCodeConfig,
   saveHomeKimiCodeConfig,
   saveProjectKimiCodeConfig,
+  type KimiToolName,
 } from "./src/config.ts";
 import {
   DEFAULT_KIMI_MODEL_INPUT,
@@ -49,12 +52,10 @@ import {
   applyKimiEnvOverridesToModel,
   applyKimiOAuthExtrasToModel,
 } from "./src/models.ts";
-import { loginKimiCode, refreshKimiCodeToken } from "./src/oauth.ts";
+import { loginKimiCode, refreshKimiAuthToken, refreshKimiCodeToken } from "./src/oauth.ts";
 import { streamSimpleKimi } from "./src/stream.ts";
 import { buildMoonshotFetchTool, buildMoonshotSearchTool } from "./src/tools/moonshot.ts";
-
-const MOONSHOT_TOOL_NAMES = ["moonshot_search", "moonshot_fetch"] as const;
-type MoonshotToolName = (typeof MOONSHOT_TOOL_NAMES)[number];
+import { buildKimiDatasourceTool } from "./src/tools/datasource.ts";
 type KimiConfigScope = "project" | "home";
 const MEMBERSHIP_LEVEL_NAMES: Record<string, string> = {
   LEVEL_FREE: "Free",
@@ -71,30 +72,30 @@ interface UsageRow {
   limit: number;
 }
 
+function buildKimiTool(toolName: KimiToolName, config: KimiCodeConfig) {
+  const opts = { defaultCollapsed: config.tools[toolName].default_collapsed };
+  if (toolName === "moonshot_search") return buildMoonshotSearchTool(opts);
+  if (toolName === "moonshot_fetch") return buildMoonshotFetchTool(opts);
+  if (toolName === "kimi_datasource") return buildKimiDatasourceTool(opts);
+  return undefined;
+}
+
 function registerConfiguredMoonshotTools(
   pi: ExtensionAPI,
   config: KimiCodeConfig,
   options: { updateActiveTools: boolean },
 ): void {
-  if (config.tools.moonshot_search.enabled) {
-    pi.registerTool(
-      buildMoonshotSearchTool({
-        defaultCollapsed: config.tools.moonshot_search.default_collapsed,
-      }),
-    );
-  }
-  if (config.tools.moonshot_fetch.enabled) {
-    pi.registerTool(
-      buildMoonshotFetchTool({
-        defaultCollapsed: config.tools.moonshot_fetch.default_collapsed,
-      }),
-    );
+  for (const toolName of KIMI_TOOL_NAMES) {
+    if (config.tools[toolName].enabled) {
+      const tool = buildKimiTool(toolName, config);
+      if (tool) pi.registerTool(tool);
+    }
   }
 
   if (!options.updateActiveTools) return;
 
   const activeTools = new Set(pi.getActiveTools());
-  for (const toolName of MOONSHOT_TOOL_NAMES) {
+  for (const toolName of KIMI_TOOL_NAMES) {
     if (config.tools[toolName].enabled) {
       activeTools.add(toolName);
     } else {
@@ -186,6 +187,17 @@ function quotaBar(remaining: number, limit: number): string {
   return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
 }
 
+function fetchKimiUsage(token: string, signal: AbortSignal): Promise<Response> {
+  return fetch("https://api.kimi.com/coding/v1/usages", {
+    method: "GET",
+    headers: {
+      ...getCommonHeaders(),
+      Authorization: `Bearer ${token}`,
+    },
+    signal,
+  });
+}
+
 async function fetchKimiUsageSummary(): Promise<string> {
   const token = getKimiUsageToken();
   if (!token) return "Usage: missing credentials. Run /login kimi-coding.";
@@ -193,14 +205,11 @@ async function fetchKimiUsageSummary(): Promise<string> {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 15_000);
   try {
-    const response = await fetch("https://api.kimi.com/coding/v1/usages", {
-      method: "GET",
-      headers: {
-        ...getCommonHeaders(),
-        Authorization: `Bearer ${token}`,
-      },
-      signal: controller.signal,
-    });
+    let response = await fetchKimiUsage(token, controller.signal);
+    if (response.status === 401) {
+      const refreshed = await refreshKimiAuthToken(token);
+      if (refreshed) response = await fetchKimiUsage(refreshed, controller.signal);
+    }
     if (!response.ok) return `Usage: fetch failed (${response.status})`;
     return parseUsageSummary(await response.json());
   } catch (error) {
@@ -212,7 +221,7 @@ async function fetchKimiUsageSummary(): Promise<string> {
 }
 
 function moonshotStatus(config: KimiCodeConfig): string {
-  return MOONSHOT_TOOL_NAMES.map((toolName) => {
+  return KIMI_TOOL_NAMES.map((toolName) => {
     const tool = config.tools[toolName];
     const enabled = tool.enabled ? "enabled" : "disabled";
     const collapsed = tool.default_collapsed ? "collapsed" : "expanded";
@@ -220,7 +229,7 @@ function moonshotStatus(config: KimiCodeConfig): string {
   }).join("\n");
 }
 
-function toggleEnabled(config: KimiCodeConfig, toolName: MoonshotToolName): KimiCodeConfig {
+function toggleEnabled(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
   return {
     tools: {
       ...config.tools,
@@ -232,7 +241,7 @@ function toggleEnabled(config: KimiCodeConfig, toolName: MoonshotToolName): Kimi
   };
 }
 
-function toggleCollapsed(config: KimiCodeConfig, toolName: MoonshotToolName): KimiCodeConfig {
+function toggleCollapsed(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
   return {
     tools: {
       ...config.tools,
@@ -278,18 +287,15 @@ async function editConfigScope(
 ): Promise<KimiCodeConfig> {
   let current = loadScopeKimiCodeConfig(scope, ctx.cwd);
   while (true) {
-    const choice = await ctx.ui.select(buildConfigScopeTitle(scope, current, ctx.cwd), [
-      toolMenuItem(current, "moonshot_search"),
-      toolMenuItem(current, "moonshot_fetch"),
-      "Back",
-    ]);
+    const items = KIMI_TOOL_NAMES.map((name) => toolMenuItem(current, name));
+    items.push("Back");
+    const choice = await ctx.ui.select(buildConfigScopeTitle(scope, current, ctx.cwd), items);
     if (!choice || choice === "Back") {
       return loadKimiCodeConfig({ cwd: ctx.cwd, home: os.homedir() });
     }
-    if (choice.startsWith("moonshot_search")) {
-      current = await editMoonshotTool(pi, ctx, scope, current, "moonshot_search");
-    } else if (choice.startsWith("moonshot_fetch")) {
-      current = await editMoonshotTool(pi, ctx, scope, current, "moonshot_fetch");
+    const toolName = KIMI_TOOL_NAMES.find((name) => choice.startsWith(name));
+    if (toolName) {
+      current = await editMoonshotTool(pi, ctx, scope, current, toolName);
     }
   }
 }
@@ -299,7 +305,7 @@ async function editMoonshotTool(
   ctx: ExtensionCommandContext,
   scope: KimiConfigScope,
   config: KimiCodeConfig,
-  toolName: MoonshotToolName,
+  toolName: KimiToolName,
 ): Promise<KimiCodeConfig> {
   let current = config;
   while (true) {
@@ -322,6 +328,7 @@ async function editMoonshotTool(
     const effective = loadKimiCodeConfig({ cwd: ctx.cwd, home: os.homedir() });
     registerConfiguredMoonshotTools(pi, effective, { updateActiveTools: true });
     ctx.ui.notify(`Saved ${toolName} config`, "info");
+    return current;
   }
 }
 
@@ -342,8 +349,17 @@ function saveScopeKimiCodeConfig(
   }
 }
 
-function buildKimiMainTitle(_config: KimiCodeConfig, _cwd: string): string {
-  return "Kimi settings";
+function buildKimiMainTitle(config: KimiCodeConfig, cwd: string): string {
+  const sources = loadKimiCodeConfigSources({ cwd, home: os.homedir() });
+  return [
+    "Kimi settings",
+    "",
+    "Effective tools:",
+    ...KIMI_TOOL_NAMES.map((toolName) => {
+      const enabled = config.tools[toolName].enabled ? "enabled" : "disabled";
+      return `- ${toolName}: ${enabled} (${sources.tools[toolName].enabled})`;
+    }),
+  ].join("\n");
 }
 
 function buildConfigScopeTitle(
@@ -363,11 +379,11 @@ function homeRelative(filePath: string): string {
   return filePath.startsWith(`${home}/`) ? `~/${filePath.slice(home.length + 1)}` : filePath;
 }
 
-function toolMenuItem(config: KimiCodeConfig, toolName: MoonshotToolName): string {
+function toolMenuItem(config: KimiCodeConfig, toolName: KimiToolName): string {
   return `${toolName} -> ${formatToolStatus(config, toolName)}`;
 }
 
-function formatToolStatus(config: KimiCodeConfig, toolName: MoonshotToolName): string {
+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";
@@ -379,12 +395,10 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerProvider(PROVIDER_ID, {
     baseUrl: getBaseUrl(),
-    apiKey: "KIMI_API_KEY",
+    apiKey: "$KIMI_API_KEY",
     api: KIMI_API_TYPE,
     streamSimple: streamSimpleKimi,
 
-    headers: getCommonHeaders(),
-
     models: [
       applyKimiEnvOverridesToModel({
         id: "kimi-for-coding",

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
   "keywords": [
     "ai-provider",
     "coding-agent",
-    "device-code",
     "kimi",
-    "kimi-coder",
+    "kimi-code",
     "kimi-for-coding",
     "kimi-k2",
     "kimi-k2.5",
     "kimi-k2.6",
+    "kimi-k2.7",
     "llm",
     "llm-provider",
     "moonshot",
@@ -20,10 +20,8 @@
     "pi",
     "pi-coding-agent",
     "pi-extension",
-    "pi-mono",
     "pi-package",
-    "pi-provider",
-    "subscription"
+    "pi-provider"
   ],
   "bugs": {
     "url": "https://github.com/Leechael/pi-provider-kimi-code/issues"
@@ -54,7 +52,8 @@
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.78.0",
     "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@j178/prek": "^0.3.8",
+    "@earendil-works/pi-tui": "^0.78.1",
+    "@j178/prek": "^0.4.4",
     "@types/node": "^24.0.0",
     "oxfmt": "^0.44.0",
     "oxlint": "^1.59.0",
@@ -62,7 +61,8 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "pi": {
     "extensions": [

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/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/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
@@ -435,8 +446,9 @@ export async function applyKimiPayloadMutations(
   }
 
   // 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,
@@ -136,13 +137,26 @@ export async function* filterEmptyResponseStream(
 // 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
@@ -158,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
@@ -169,6 +186,7 @@ export function streamSimpleKimi(
     return {
       ...options,
       ...apiKeyOverride,
+      headers: mergeKimiRequestHeaders(options?.headers),
       onPayload: async (payload, modelData) => {
         let nextPayload: unknown = payload;
 
@@ -181,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;
+}

package/src/tools/datasource.ts

@@ -0,0 +1,191 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type, type Static } from "@earendil-works/pi-ai";
+
+import {
+  type BuildKimiToolOptions,
+  buildHeaders,
+  getKimiDatasourceUrl,
+  buildKimiToolDeps,
+  buildTimeoutSignal,
+  errorResult,
+  fetchWithAuthRetry,
+  firstText,
+  readErrorBody,
+  shouldCollapse,
+  textComponent,
+} from "./common.ts";
+
+const DATASOURCE_DEFINITIONS = [
+  {
+    name: "stock_finance_data",
+    description: "A/HK/US stocks, prices, financial reports, indicators, shareholders.",
+  },
+  {
+    name: "yahoo_finance",
+    description: "Global finance: quotes, analyst ratings, options, indexes, historical prices.",
+  },
+  {
+    name: "world_bank_open_data",
+    description: "World Bank macro data: GDP, inflation, population, country comparisons.",
+  },
+  {
+    name: "tianyancha",
+    description: "Chinese enterprise registry: shareholders, legal representative, risks, patents.",
+  },
+  { name: "arxiv", description: "arXiv preprints: paper search, abstracts, arXiv IDs." },
+  {
+    name: "scholar",
+    description: "Google Scholar: academic papers, authors, citations, high-citation surveys.",
+  },
+  {
+    name: "yuandian_law",
+    description: "Chinese laws, regulations, judicial cases; labor contracts and legal clauses.",
+  },
+] as const;
+
+const DATASOURCE_NAMES = DATASOURCE_DEFINITIONS.map((source) => source.name);
+
+export const kimiDatasourceSchema = Type.Object({
+  data_source_name: Type.Union(
+    DATASOURCE_NAMES.map((name) => Type.Literal(name)),
+    {
+      description:
+        "Source: stock_finance_data stocks/reports; yahoo_finance quotes/options; world_bank_open_data GDP/population; tianyancha Chinese company registry/legal rep; arxiv preprints; scholar citations; yuandian_law Chinese laws/cases/contracts.",
+    },
+  ),
+  api_name: Type.Optional(
+    Type.String({
+      description: "API name from the datasource docs. Omit to get docs first.",
+    }),
+  ),
+  params: Type.Optional(
+    Type.Record(Type.String(), Type.Unknown(), {
+      description: "Parameters matching the selected datasource API docs.",
+    }),
+  ),
+});
+
+export type KimiDatasourceParams = Static<typeof kimiDatasourceSchema>;
+
+interface DatasourceToolResponse {
+  is_success?: boolean;
+  error?: unknown;
+  result?: {
+    assistant?: unknown;
+    user?: unknown;
+  };
+}
+
+function extractTextFromResult(result: unknown): string {
+  if (!Array.isArray(result)) return "";
+  const texts: string[] = [];
+  for (const item of result) {
+    if (typeof item === "string") {
+      texts.push(item);
+    } else if (typeof item === "object" && item !== null) {
+      const record = item as Record<string, unknown>;
+      if (typeof record.text === "string") {
+        texts.push(record.text);
+      }
+    }
+  }
+  return texts.join("\n");
+}
+
+function extractResponseText(data: DatasourceToolResponse): string {
+  if (data.result?.assistant) {
+    const text = extractTextFromResult(data.result.assistant);
+    if (text) return text;
+  }
+  if (data.result?.user) {
+    const text = extractTextFromResult(data.result.user);
+    if (text) return text;
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+export function buildKimiDatasourceTool(options: BuildKimiToolOptions = {}) {
+  const deps = buildKimiToolDeps(options);
+  const defaultCollapsed = options.defaultCollapsed ?? true;
+
+  return defineTool({
+    name: "kimi_datasource",
+    label: "Kimi Datasource",
+    description:
+      "Call Kimi datasource APIs. Covers stocks/finance, macro data, Chinese company registry, papers, and Chinese law/cases/contracts. First omit api_name to get docs, then call api_name with documented params.",
+    promptSnippet: "Query Kimi datasource APIs; get docs first, then call documented api_name",
+    parameters: kimiDatasourceSchema,
+
+    async execute(toolCallId, params, signal) {
+      const accessToken = deps.getAccessToken();
+      if (!accessToken) {
+        return errorResult<string>(
+          "Missing Kimi Code OAuth credentials. Run /login kimi-coding first.",
+        );
+      }
+
+      const timeout = buildTimeoutSignal(signal);
+      try {
+        const apiName = params.api_name?.trim();
+        const body = apiName
+          ? {
+              method: "call_data_source_tool",
+              params: {
+                data_source_name: params.data_source_name,
+                api_name: apiName,
+                params: params.params ?? {},
+              },
+            }
+          : {
+              method: "get_data_source_desc",
+              params: { data_source_name: params.data_source_name },
+            };
+
+        const response = await fetchWithAuthRetry(deps, accessToken, (token) =>
+          deps.fetch(getKimiDatasourceUrl(), {
+            method: "POST",
+            headers: buildHeaders(token, toolCallId),
+            body: JSON.stringify(body),
+            signal: timeout.signal,
+          }),
+        );
+
+        if (!response.ok) {
+          const bodyText = await readErrorBody(response);
+          return errorResult<string>(
+            `kimi_datasource failed: ${response.status}${bodyText ? ` ${bodyText}` : ""}`,
+          );
+        }
+
+        const data = (await response.json()) as DatasourceToolResponse;
+        if (data.is_success === false) {
+          const errorText =
+            typeof data.error === "string"
+              ? data.error
+              : JSON.stringify(data.error ?? data, null, 2);
+          return errorResult<string>(`kimi_datasource error: ${errorText}`);
+        }
+
+        const text = extractResponseText(data);
+        return {
+          content: [{ type: "text", text }],
+          details: text,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResult<string>(`kimi_datasource failed: ${message}`);
+      } finally {
+        timeout.cleanup();
+      }
+    },
+
+    renderResult(result, renderOptions) {
+      const text = firstText(result);
+      if (!shouldCollapse(defaultCollapsed, renderOptions.expanded)) {
+        return textComponent(text);
+      }
+      const preview = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+      return textComponent(`kimi_datasource: ${text.length} chars\n${preview}`);
+    },
+  });
+}

package/src/tools/moonshot.ts

@@ -1,12 +1,19 @@
-import { AuthStorage, defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "@earendil-works/pi-ai";
 
-import { PROVIDER_ID } from "../constants.ts";
-import { getCommonHeaders } from "../device.ts";
-import { refreshKimiAuthToken } from "../oauth.ts";
-
-const MOONSHOT_BASE_V1 = "https://api.kimi.com/coding/v1";
-const MOONSHOT_TIMEOUT_MS = 180_000;
+import {
+  type BuildKimiToolOptions,
+  buildHeaders,
+  getKimiBaseV1,
+  buildKimiToolDeps,
+  buildTimeoutSignal,
+  errorResult,
+  fetchWithAuthRetry,
+  firstText,
+  readErrorBody,
+  shouldCollapse,
+  textComponent,
+} from "./common.ts";
 
 export const moonshotSearchSchema = Type.Object({
   query: Type.String({ description: "The query text to search for." }),
@@ -45,76 +52,13 @@ export interface MoonshotFetchResult {
   content: string;
 }
 
-interface MoonshotToolDeps {
-  fetch: typeof fetch;
-  getAccessToken: () => string | null;
-  refreshAccessToken: (currentToken: string) => Promise<string | null>;
-}
-
-export interface BuildMoonshotToolOptions {
-  deps?: Partial<MoonshotToolDeps>;
-  defaultCollapsed?: boolean;
-}
-
-interface MoonshotSearchResponse {
-  search_results?: unknown;
-}
-
-function defaultGetAccessToken(): string | null {
-  const credential = AuthStorage.create().get(PROVIDER_ID);
-  if (!credential || credential.type !== "oauth") return null;
-  return credential.access;
-}
-
-function buildDeps(options: BuildMoonshotToolOptions = {}): MoonshotToolDeps {
-  return {
-    fetch: options.deps?.fetch ?? fetch,
-    getAccessToken: options.deps?.getAccessToken ?? defaultGetAccessToken,
-    refreshAccessToken: options.deps?.refreshAccessToken ?? refreshKimiAuthToken,
-  };
-}
-
 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)));
 }
 
-function errorResult<T>(message: string): AgentToolResult<T> {
-  return {
-    content: [{ type: "text", text: message }],
-    details: undefined as T,
-  };
-}
-
-function buildTimeoutSignal(signal: AbortSignal | undefined): {
-  signal: AbortSignal;
-  cleanup: () => void;
-} {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), MOONSHOT_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);
-    },
-  };
-}
-
-function buildHeaders(accessToken: string, toolCallId: string): Record<string, string> {
-  return {
-    ...getCommonHeaders(),
-    Authorization: `Bearer ${accessToken}`,
-    "Content-Type": "application/json",
-    "X-Msh-Tool-Call-Id": toolCallId,
-  };
+interface MoonshotSearchResponse {
+  search_results?: unknown;
 }
 
 function stringField(record: Record<string, unknown>, key: string): string {
@@ -144,22 +88,6 @@ function searchResultsText(results: MoonshotSearchResult[]): string {
   return JSON.stringify(results, null, 2);
 }
 
-function textComponent(text: string) {
-  return {
-    render: () => text.split("\n"),
-    invalidate: () => {},
-  };
-}
-
-function firstText(result: AgentToolResult<unknown>): string {
-  const first = result.content[0];
-  return first?.type === "text" ? first.text : "";
-}
-
-function shouldCollapse(defaultCollapsed: boolean, expanded: boolean | undefined): boolean {
-  return defaultCollapsed && expanded !== true;
-}
-
 function renderSearchResult(
   result: AgentToolResult<MoonshotSearchResult[]>,
   expanded: boolean | undefined,
@@ -195,25 +123,8 @@ function renderFetchResult(
   );
 }
 
-async function readErrorBody(response: Response): Promise<string> {
-  return response.text().catch(() => "");
-}
-
-async function fetchWithAuthRetry(
-  deps: MoonshotToolDeps,
-  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 buildMoonshotSearchTool(options: BuildMoonshotToolOptions = {}) {
-  const deps = buildDeps(options);
+export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
+  const deps = buildKimiToolDeps(options);
   const defaultCollapsed = options.defaultCollapsed ?? true;
 
   return defineTool({
@@ -236,7 +147,7 @@ export function buildMoonshotSearchTool(options: BuildMoonshotToolOptions = {})
       const timeout = buildTimeoutSignal(signal);
       try {
         const response = await fetchWithAuthRetry(deps, accessToken, (token) =>
-          deps.fetch(`${MOONSHOT_BASE_V1}/search`, {
+          deps.fetch(`${getKimiBaseV1()}/search`, {
             method: "POST",
             headers: buildHeaders(token, toolCallId),
             body: JSON.stringify({
@@ -276,8 +187,8 @@ export function buildMoonshotSearchTool(options: BuildMoonshotToolOptions = {})
   });
 }
 
-export function buildMoonshotFetchTool(options: BuildMoonshotToolOptions = {}) {
-  const deps = buildDeps(options);
+export function buildMoonshotFetchTool(options: BuildKimiToolOptions = {}) {
+  const deps = buildKimiToolDeps(options);
   const defaultCollapsed = options.defaultCollapsed ?? true;
 
   return defineTool({
@@ -298,7 +209,7 @@ export function buildMoonshotFetchTool(options: BuildMoonshotToolOptions = {}) {
       const timeout = buildTimeoutSignal(signal);
       try {
         const response = await fetchWithAuthRetry(deps, accessToken, (token) =>
-          deps.fetch(`${MOONSHOT_BASE_V1}/fetch`, {
+          deps.fetch(`${getKimiBaseV1()}/fetch`, {
             method: "POST",
             headers: {
               ...buildHeaders(token, toolCallId),