pi-provider-kimi-code 0.6.8 → 0.6.10

package/src/stream.ts

@@ -58,9 +58,13 @@ import {
   type KimiResolvedModelConfig,
 } from "./config.ts";
 
-import { ENV_KIMI_CODE_PROTOCOL, getApiProtocol, getBaseUrl } from "./constants.ts";
+import { ENV_KIMI_CODE_PROTOCOL, PROVIDER_ID, getApiProtocol, getBaseUrl } from "./constants.ts";
 import { getKimiProviderHeaders } from "./device.ts";
-import { isKimiAuthErrorMessage, refreshKimiAuthToken } from "./oauth.ts";
+import {
+  isKimiAuthErrorMessage,
+  readStoredOAuthCredential,
+  refreshKimiAuthToken,
+} from "./oauth.ts";
 import {
   type Uploader,
   applyKimiPayloadMutations,
@@ -190,11 +194,21 @@ export async function* filterEmptyResponseStream(
 
 const KIMI_API_KEY_ENV_REFERENCES = new Set(["$KIMI_API_KEY", "${KIMI_API_KEY}"]);
 
+// On the normal request path pi resolves the provider credential through its
+// ModelRuntime and hands it to us. Callers that arrive through pi-ai's global
+// api registry (a bare agentLoop() with no streamFn) have no ModelRuntime
+// behind them and pass nothing, so read the same credential store pi itself
+// would have read instead of sending an unauthenticated request. Kept last so
+// an explicit key and the environment override keep their existing precedence.
+function getStoredKimiAccessToken(): string {
+  return readStoredOAuthCredential(PROVIDER_ID)?.access?.trim() || "";
+}
+
 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 process.env.KIMI_API_KEY?.trim() || getStoredKimiAccessToken();
   }
-  return apiKey || process.env.KIMI_API_KEY || "";
+  return apiKey || process.env.KIMI_API_KEY || getStoredKimiAccessToken();
 }
 
 // SimpleStreamOptions.headers is Record<string, string> on pi <=0.79 and
@@ -285,6 +299,7 @@ export function streamSimpleKimi(
           await applyKimiPayloadMutations(nextPayload, {
             api: apiProtocol,
             upload,
+            uploadCacheScope: apiKey ? `${getBaseUrl(wireProtocol)}:${apiKey}` : undefined,
             cacheKey,
             cacheRetention,
             reasoning: options?.reasoning,
@@ -323,6 +338,19 @@ export function streamSimpleKimi(
         ...model,
         api: apiProtocol,
         baseUrl: getBaseUrl(wireProtocol),
+        // Kimi's anthropic-protocol endpoint speaks adaptive thinking and
+        // rejects/ignores the interleaved-thinking beta header; pi-ai >=0.82
+        // keys both behaviors off these compat flags (its own built-in
+        // kimi-coding models carry them in generated metadata).
+        ...(wireProtocol === "anthropic"
+          ? {
+              compat: {
+                ...(model as { compat?: Record<string, unknown> }).compat,
+                forceAdaptiveThinking: true,
+                allowEmptySignature: true,
+              },
+            }
+          : {}),
       } as Model<Api>;
       const upstream =
         wireProtocol === "openai"

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,
+  );
+}