pi-provider-kimi-code 0.6.9 → 0.6.11

package/README.md

@@ -3,16 +3,10 @@
 [![npm](https://img.shields.io/npm/v/pi-provider-kimi-code)](https://www.npmjs.com/package/pi-provider-kimi-code)
 [![license](https://img.shields.io/npm/l/pi-provider-kimi-code)](./LICENSE)
 
-> **Kimi Code harness extension for Pi.** Pi v0.82.0 ships a built-in `kimi-coding` provider that handles the LLM layer — K3, adaptive thinking, and a generated model catalog — plus native OAuth sign-in via `/login`. This extension brings the rest of the Kimi Code surface into Pi: shared login state with the official `kimi-code` CLI, Kimi Files API uploads, and Kimi-native tools such as `moonshot_search`, `moonshot_fetch`, and `kimi_datasource`.
-
-Pi's built-in `kimi-coding` provider handles the LLM. This extension covers the rest: shared login state with the official CLI, file uploads through Kimi's Files API, and Kimi-native tools. It also keeps a legacy provider registration so existing model sessions still load. New users should use Pi's built-in model provider.
-
-> **Live model catalog (legacy).** For backward compatibility, the extension still reads Kimi's live `/v1/models` catalog when it has credentials. New Pi users should rely on the built-in provider's generated catalog instead.
+> **Kimi Code extension for Pi — use K3, K2.7 Code, and HighSpeed models with your Kimi Code Plan.** This extension brings the full Kimi Code surface into Pi: shared OAuth login state with the official `kimi-code` CLI, Kimi Files API uploads, and Kimi-native tools such as `moonshot_search`, `moonshot_fetch`, and `kimi_datasource`. (Pi v0.82.0+ ships a built-in `kimi-coding` provider for the LLM layer; this extension covers everything around it.)
 
 ## Why this exists
 
-Pi is a small harness you adapt to your own workflow. Kimi Code is Moonshot's official coding agent. Pi now ships a built-in `kimi-coding` provider that covers the LLM, including OAuth login. This extension is for the parts of Kimi Code that Pi's built-in provider does not cover: the account session, file uploads, and Kimi's own tools/datasource APIs.
-
 Use the built-in provider if you only want to chat with Kimi models. Install this extension when you also want the full Kimi Code surface inside Pi:
 
 - **Share a session with the official `kimi-code` CLI.** Reuse an existing `kimi-code` login, or sync Pi's OAuth login back to `kimi-code` so both CLIs stay authenticated.
@@ -90,11 +84,11 @@ KIMI_API_KEY=sk-... pi
 
 When this extension does register models, the official catalog determines what it publishes. The following IDs are the fallback set when catalog discovery is unavailable:
 
-| Pi model ID                             | Default name             | Availability and context |
-| --------------------------------------- | ------------------------ | ------------------------ |
-| `kimi-coding/kimi-for-coding`           | Kimi K2.7 Code           | Official catalog         |
-| `kimi-coding/kimi-for-coding-highspeed` | Kimi K2.7 Code HighSpeed | Official catalog         |
-| `kimi-coding/k3`                        | Kimi K3                  | Official catalog         |
+| Pi model ID                             | Default name               | Source           |
+| --------------------------------------- | -------------------------- | ---------------- |
+| `kimi-coding/kimi-for-coding`           | Kimi for Coding            | Official catalog |
+| `kimi-coding/kimi-for-coding-highspeed` | Kimi for Coding High Speed | Official catalog |
+| `kimi-coding/k3`                        | Kimi K3                    | Official catalog |
 
 Kimi's official catalog at `https://api.kimi.com/coding/v1/models` is authoritative for model availability and context windows. When discovery is unavailable, the extension uses the fallback models and defaults below.
 
@@ -119,7 +113,7 @@ Inside Pi, run:
 /kimi-settings
 ```
 
-That command shows the current server-side model name (e.g. "K2.7 Code High Speed"), your Kimi quota and Extra Usage balance, and lets you edit the home or project config. Changes apply to the active session tool set.
+That command shows your signed-in account (via Kimi's `/me` endpoint), the current server-side model name (e.g. "K2.7 Code High Speed"), your Kimi quota and Extra Usage balance, and lets you edit the home or project config. Changes apply to the active session tool set.
 
 Configurable settings include protocol mode, upload threshold, and per-tool enable/collapse.
 
@@ -170,6 +164,11 @@ Supported datasource names:
 | `arxiv`                | Academic paper search and metadata    |
 | `scholar`              | Academic literature search            |
 | `yuandian_law`         | Chinese legal database and case law   |
+| `wind`                 | A-share intraday series, funds, bonds |
+| `imf`                  | IMF FX, CPI, and GDP forecasts        |
+| `gildata`              | Natural-language stock/fund screening |
+| `sec_edgar`            | US SEC filings (10-K/10-Q, 13F, 8-K)  |
+| `sp_data`              | S&P fundamentals and transcripts      |
 
 ### Common notes
 

package/index.ts

@@ -77,7 +77,11 @@ import {
   parseByteSizeInput,
 } from "./src/settings-ui.ts";
 import { setStoreResolvedKimiConfig, streamSimpleKimi } from "./src/stream.ts";
-import { fetchKimiUsageSnapshot, getKimiUsageToken } from "./src/usage.ts";
+import {
+  fetchKimiUsageSnapshot,
+  fetchKimiUserInfoSnapshot,
+  getKimiUsageToken,
+} from "./src/usage.ts";
 import { buildMoonshotFetchTool, buildMoonshotSearchTool } from "./src/tools/moonshot.ts";
 import { buildKimiDatasourceTool } from "./src/tools/datasource.ts";
 interface KimiRuntimeState {
@@ -186,8 +190,9 @@ async function openSettingsMenu(
   state: KimiRuntimeState,
 ): Promise<void> {
   const modelDiscoveryToken = getKimiUsageToken();
-  const [usageSnapshot, initialModelsRefreshed] = await Promise.all([
+  const [usageSnapshot, userInfoSnapshot, initialModelsRefreshed] = await Promise.all([
     fetchKimiUsageSnapshot(),
+    fetchKimiUserInfoSnapshot(),
     refreshModelExtras(state),
   ]);
   let modelsRefreshed = initialModelsRefreshed;
@@ -197,6 +202,7 @@ async function openSettingsMenu(
   }
   if (modelsRefreshed) await registerKimiProvider(pi, state);
   const usage = usageSnapshot.summary;
+  const account = userInfoSnapshot.summary;
 
   const projectTrusted = await isKimiProjectConfigApproved(ctx, ctx.cwd);
   const homeDraft = loadHomeKimiCodeConfig(os.homedir());
@@ -373,6 +379,9 @@ async function openSettingsMenu(
             width,
           ),
           "",
+          truncateToWidth(theme.fg("accent", theme.bold("Kimi account")), width),
+          truncateToWidth(`  ${account}`, width),
+          "",
           truncateToWidth(theme.fg("accent", theme.bold("Kimi usage")), width),
           ...usageLines,
           "",
@@ -433,10 +442,20 @@ function buildKimiCatalogModels(state: KimiRuntimeState) {
 }
 
 // Node reports a missing subpath export (pi-ai <=0.79) and a missing package
-// with these codes. Both mean "this pi-ai has no compat layer", which is an
+// with these codes. All mean "this pi-ai has no compat layer", which is an
 // expected configuration rather than a failure worth reporting: the fallback
 // simply does not exist there.
-const MODULE_UNAVAILABLE_CODES = new Set(["ERR_MODULE_NOT_FOUND", "ERR_PACKAGE_PATH_NOT_EXPORTED"]);
+//
+// MODULE_NOT_FOUND (the CJS code, without the ERR_ prefix) covers pi's jiti
+// extension loader on old pi versions: it aliases the bare "@earendil-works/pi-ai"
+// specifier straight to dist/index.js, so the "/compat" subpath degrades into
+// the bogus file path "dist/index.js/compat" and fails legacy CJS resolution
+// instead of exports-map resolution.
+const MODULE_UNAVAILABLE_CODES = new Set([
+  "ERR_MODULE_NOT_FOUND",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  "MODULE_NOT_FOUND",
+]);
 
 // Every api id this extension can hand out, not only the one for the currently
 // configured protocol: sessions persist the api id that was current when the
@@ -590,7 +609,7 @@ async function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState):
 
 // What pi throws from any `pi` method once the extension runtime behind it has
 // been retired, which is what a /reload does. Same wording on every version
-// this extension supports (0.78.1 through 0.82.0); if it ever changes, the
+// this extension supports (0.78.1 through 0.83.0); if it ever changes, the
 // worst case is that a reload race gets logged instead of ignored.
 const STALE_EXTENSION_RUNTIME_PREFIX = "This extension ctx is stale";
 

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.9",
-  "description": "Kimi Code harness extension for Pi: shared login state, file uploads, and Kimi-native tools",
+  "version": "0.6.11",
+  "description": "Kimi Code models (K3, K2.7, HighSpeed) in Pi: OAuth shared login with kimi-code CLI, file uploads, and Kimi-native tools",
   "keywords": [
     "ai-provider",
     "coding-agent",
+    "highspeed",
+    "k3",
     "kimi",
     "kimi-code",
+    "kimi-code-plan",
     "kimi-for-coding",
     "kimi-k2",
     "kimi-k2.5",
     "kimi-k2.6",
     "kimi-k2.7",
+    "kimi-k3",
     "llm",
     "llm-provider",
     "moonshot",
@@ -53,9 +57,9 @@
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.82.0",
-    "@earendil-works/pi-coding-agent": "^0.82.0",
-    "@earendil-works/pi-tui": "^0.82.0",
+    "@earendil-works/pi-ai": "^0.83.0",
+    "@earendil-works/pi-coding-agent": "^0.83.0",
+    "@earendil-works/pi-tui": "^0.83.0",
     "@j178/prek": "^0.4.4",
     "@types/node": "^24.0.0",
     "@types/proper-lockfile": "^4.1.4",

package/src/constants.ts

@@ -41,14 +41,10 @@ export function getDefaultBaseUrl(protocol: KimiWireProtocol): string {
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const PROVIDER_VERSION = "0.6.9";
-
-// Upstream kimi-code CLI version — used in User-Agent and X-Msh-Version
-// headers to match the official client's identity. Update this when
-// syncing with https://github.com/MoonshotAI/kimi-code.
-export const KIMI_UPSTREAM_VERSION = "0.29.1";
-export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_UPSTREAM_VERSION}`;
-export const KIMI_PLATFORM = "kimi_code_cli";
+export const PROVIDER_VERSION = "0.6.11";
+
+export const KIMI_CODE_USER_AGENT = `pi-provider-kimi-code/${PROVIDER_VERSION}`;
+export const KIMI_PLATFORM = "pi";
 
 export function getKimiCodeHome(): string {
   const value = process.env.KIMI_CODE_HOME?.trim();

package/src/device.ts

@@ -8,12 +8,12 @@ import { readFile } from "node:fs/promises";
 import os from "node:os";
 import { dirname } from "node:path";
 
-import {
-  DEVICE_ID_PATH,
-  KIMI_CODE_USER_AGENT,
-  KIMI_UPSTREAM_VERSION,
-  KIMI_PLATFORM,
-} from "./constants.ts";
+// Namespace import (not a named import of VERSION) so a missing export on old
+// pi versions degrades to undefined rather than a module-link error that kills
+// the whole extension load.
+import * as piAgent from "@earendil-works/pi-coding-agent";
+
+import { DEVICE_ID_PATH, KIMI_CODE_USER_AGENT, KIMI_PLATFORM } from "./constants.ts";
 
 function createDeviceId(): string {
   return randomBytes(16).toString("hex");
@@ -165,6 +165,13 @@ export function getOsVersion(): string {
   return os.release();
 }
 
+// The running pi TUI's version, read off pi-coding-agent's VERSION export (it
+// reads its own package.json at module load).
+export function getPiVersion(): string {
+  const version = (piAgent as { VERSION?: unknown }).VERSION;
+  return typeof version === "string" && version ? version : "unknown";
+}
+
 export function asciiHeaderValue(value: string, fallback = "unknown"): string {
   const trimmed = value.trim();
   /* oxlint-disable-next-line no-control-regex */
@@ -214,7 +221,7 @@ export function getCommonHeaders(): Record<string, string> {
   const headers = {
     "User-Agent": KIMI_CODE_USER_AGENT,
     "X-Msh-Platform": KIMI_PLATFORM,
-    "X-Msh-Version": KIMI_UPSTREAM_VERSION,
+    "X-Msh-Version": getPiVersion(),
     "X-Msh-Device-Name": os.hostname(),
     "X-Msh-Device-Model": getDeviceModel(),
     "X-Msh-Os-Version": getOsVersion(),

package/src/tools/datasource.ts

@@ -41,6 +41,27 @@ const DATASOURCE_DEFINITIONS = [
     name: "yuandian_law",
     description: "Chinese laws, regulations, judicial cases; labor contracts and legal clauses.",
   },
+  {
+    name: "wind",
+    description:
+      "A-share intraday minute series, funds, bonds; map PE/PB/ROE-style field names via wind_search_fields first.",
+  },
+  {
+    name: "imf",
+    description: "IMF macro data: FX rates, CPI, GDP forecasts, balance of payments.",
+  },
+  {
+    name: "gildata",
+    description: "Natural-language stock/fund screening.",
+  },
+  {
+    name: "sec_edgar",
+    description: "US SEC filings: 10-K/10-Q, S-1, Form 4, 13F, 8-K.",
+  },
+  {
+    name: "sp_data",
+    description: "S&P fundamentals: consensus estimates, valuation ratios, transcripts.",
+  },
 ] as const;
 
 const DATASOURCE_NAMES = DATASOURCE_DEFINITIONS.map((source) => source.name);
@@ -50,7 +71,7 @@ export const kimiDatasourceSchema = Type.Object({
     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.",
+        "Source: stock_finance_data stocks/reports; yahoo_finance quotes/options; world_bank_open_data GDP/population; imf FX/CPI/GDP forecasts; tianyancha Chinese company registry/legal rep; arxiv preprints; scholar citations; yuandian_law Chinese laws/cases/contracts; wind A-share intraday minute series/funds/bonds (map field names via wind_search_fields first); gildata natural-language stock/fund screening; sec_edgar US filings (10-K/10-Q, S-1, Form 4, 13F, 8-K); sp_data S&P fundamentals (estimates, valuation, transcripts).",
     },
   ),
   api_name: Type.Optional(

package/src/usage.ts

@@ -217,6 +217,8 @@ function formatWindowLabel(value: unknown, fallbackLabel: string): string {
     : unit.includes("MINUTE")
       ? duration
       : undefined;
+  if (unit.includes("WEEK")) return `Current ${duration}w window`;
+  if (unit.includes("DAY")) return `Current ${duration}d window`;
   if (!minutes) return fallbackLabel;
   if (minutes % 60 === 0) return `Current ${minutes / 60}h window`;
   return `Current ${minutes}m window`;
@@ -320,35 +322,123 @@ function fetchKimiUsage(token: string, signal: AbortSignal): Promise<Response> {
   });
 }
 
-export async function fetchKimiUsageSnapshot(
-  options: { timeoutMs?: number; token?: string; refreshOnUnauthorized?: boolean } = {},
+interface KimiSnapshotOptions {
+  timeoutMs?: number;
+  token?: string;
+  refreshOnUnauthorized?: boolean;
+}
+
+interface KimiSnapshotEndpoint {
+  prefix: string;
+  request: (token: string, signal: AbortSignal) => Promise<Response>;
+  summarize: (payload: unknown) => string;
+}
+
+async function fetchKimiSnapshot(
+  endpoint: KimiSnapshotEndpoint,
+  options: KimiSnapshotOptions = {},
 ): Promise<KimiUsageSnapshot> {
   const token = options.token ?? getKimiUsageToken();
   if (!token) {
-    return { summary: "Usage: missing credentials. Run /login kimi-coding." };
+    return { summary: `${endpoint.prefix}: missing credentials. Run /login kimi-coding.` };
   }
 
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 15_000);
   try {
-    let response = await fetchKimiUsage(token, controller.signal);
+    let response = await endpoint.request(token, controller.signal);
     if (response.status === 401 && options.refreshOnUnauthorized !== false) {
       const refreshed = await refreshKimiAuthToken(token, { signal: controller.signal });
-      if (refreshed) response = await fetchKimiUsage(refreshed, controller.signal);
+      if (refreshed) response = await endpoint.request(refreshed, controller.signal);
     }
     if (!response.ok) {
-      return { summary: `Usage: fetch failed (${response.status})` };
+      return { summary: `${endpoint.prefix}: fetch failed (${response.status})` };
     }
     const payload = (await response.json()) as unknown;
-    return { summary: parseUsageSummary(payload) };
+    return { summary: endpoint.summarize(payload) };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    return { summary: `Usage: fetch failed (${message})` };
+    return { summary: `${endpoint.prefix}: fetch failed (${message})` };
   } finally {
     clearTimeout(timeout);
   }
 }
 
+export async function fetchKimiUsageSnapshot(
+  options: KimiSnapshotOptions = {},
+): Promise<KimiUsageSnapshot> {
+  return fetchKimiSnapshot(
+    { prefix: "Usage", request: fetchKimiUsage, summarize: parseUsageSummary },
+    options,
+  );
+}
+
 export async function fetchKimiUsageSummary(): Promise<string> {
   return (await fetchKimiUsageSnapshot()).summary;
 }
+
+export interface KimiUserInfo {
+  userId: string;
+  nickname: string;
+  userLevel: number;
+  userLevelName: string;
+  email?: string;
+}
+
+export function parseKimiUserInfo(payload: unknown): KimiUserInfo | null {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return null;
+  const record = payload as Record<string, unknown>;
+  const userId = toStringValue(record.user_id);
+  if (!userId) return null;
+  const email = toStringValue(record.email);
+  return {
+    userId,
+    nickname: toStringValue(record.nickname) ?? "",
+    userLevel: toNumber(record.user_level) ?? 0,
+    userLevelName: toStringValue(record.user_level_name) ?? "",
+    ...(email ? { email } : {}),
+  };
+}
+
+export function formatKimiUserInfo(info: KimiUserInfo): string {
+  const parts = [info.nickname || info.userId];
+  if (info.userLevelName) {
+    parts.push(
+      info.userLevel > 0 ? `${info.userLevelName} (Lv ${info.userLevel})` : info.userLevelName,
+    );
+  }
+  if (info.email) parts.push(info.email);
+  return parts.join(" · ");
+}
+
+export function buildKimiUserInfoUrl(baseUrl = getBaseUrl("openai")): string {
+  const normalized = baseUrl.replace(/\/+$/, "");
+  return normalized.endsWith("/v1") ? `${normalized}/me` : `${normalized}/v1/me`;
+}
+
+function fetchKimiUserInfo(token: string, signal: AbortSignal): Promise<Response> {
+  return fetch(buildKimiUserInfoUrl(), {
+    method: "GET",
+    headers: {
+      ...getKimiProviderHeaders(),
+      Authorization: `Bearer ${token}`,
+    },
+    signal,
+  });
+}
+
+export async function fetchKimiUserInfoSnapshot(
+  options: KimiSnapshotOptions = {},
+): Promise<KimiUsageSnapshot> {
+  return fetchKimiSnapshot(
+    {
+      prefix: "Account",
+      request: fetchKimiUserInfo,
+      summarize: (payload) => {
+        const info = parseKimiUserInfo(payload);
+        return info ? formatKimiUserInfo(info) : "Account: malformed response";
+      },
+    },
+    options,
+  );
+}