pi-provider-kimi-code 0.6.13 → 0.6.14

package/src/tools/datasource.ts

@@ -1,5 +1,12 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "@earendil-works/pi-ai";
+import { map, obj, opt, str, unknown, type Static } from "@earendil-works/pi-schema";
+
+import {
+  ensureDatasourceCatalog,
+  peekDatasourceCatalog,
+  readCatalogCacheSync,
+  refreshDatasourceCatalogInBackground,
+} from "./datasource-catalog.ts";
 
 import {
   type BuildKimiToolOptions,
@@ -15,72 +22,21 @@ import {
   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.",
-  },
-  {
-    name: "wind",
+// Source names are validated at call time against the synced catalog
+// (datasource-catalog.ts) instead of a static enum, so sources added
+// server-side never get rejected by a stale client schema.
+export const kimiDatasourceSchema = obj({
+  data_source_name: str({
     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);
-
-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; 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(
-    Type.String({
+      "Data source name. The set of available sources is synced from the official kimi-datasource plugin and cached for 24h; if a call fails with an unknown-source error, pick one of the names listed in that error.",
+  }),
+  api_name: opt(
+    str({
       description: "API name from the datasource docs. Omit to get docs first.",
     }),
   ),
-  params: Type.Optional(
-    Type.Record(Type.String(), Type.Unknown(), {
+  params: opt(
+    map(unknown(), {
       description: "Parameters matching the selected datasource API docs.",
     }),
   ),
@@ -164,6 +120,16 @@ function buildTraceLine(toolCallId: string, requestId: string | undefined): stri
   return `\n\n[kimi-datasource] ${parts.join(" · ")}`;
 }
 
+function buildDescription(): string {
+  const base =
+    "Call Kimi datasource APIs: finance/quotes, macro & government data, papers, Chinese law, chemistry/bio/materials, and more. First omit api_name to get docs, then call api_name with documented params.";
+  // Registration-time snapshot: embed the cached catalog so the model sees the
+  // current source list without any network I/O. Refreshed lazily on use.
+  const cached = readCatalogCacheSync();
+  if (!cached) return base;
+  return `${base} Known sources (kimi-datasource v${cached.version}): ${cached.capabilities}`;
+}
+
 export function buildKimiDatasourceTool(options: BuildKimiToolOptions = {}) {
   const deps = buildKimiToolDeps(options);
   const defaultCollapsed = options.defaultCollapsed ?? true;
@@ -171,12 +137,11 @@ export function buildKimiDatasourceTool(options: BuildKimiToolOptions = {}) {
   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.",
+    description: buildDescription(),
     promptSnippet: "Query Kimi datasource APIs; get docs first, then call documented api_name",
     parameters: kimiDatasourceSchema,
 
-    async execute(toolCallId, params, signal) {
+    async execute(toolCallId, params: KimiDatasourceParams, signal) {
       const accessToken = deps.getAccessToken();
       if (!accessToken) {
         return errorResult<string>(
@@ -186,19 +151,40 @@ export function buildKimiDatasourceTool(options: BuildKimiToolOptions = {}) {
 
       const timeout = buildTimeoutSignal(signal);
       try {
+        const sourceName = params.data_source_name.trim();
+
+        // Lazy catalog sync: validate against the best-known catalog without
+        // blocking, and refresh in the background when it is stale. Unknown
+        // names get one forced refresh before we reject them, so newly added
+        // server-side sources work even when the local cache is old.
+        let catalog = peekDatasourceCatalog();
+        if (!catalog.sources.includes(sourceName)) {
+          catalog = await ensureDatasourceCatalog({
+            fetchImpl: deps.fetch,
+            forceRefresh: true,
+          });
+          if (!catalog.sources.includes(sourceName)) {
+            return errorResult<string>(
+              `Unknown data source "${sourceName}". Available sources (kimi-datasource v${catalog.version}): ${catalog.sources.join(", ")}`,
+            );
+          }
+        } else {
+          refreshDatasourceCatalogInBackground(deps.fetch);
+        }
+
         const apiName = params.api_name?.trim();
         const body = apiName
           ? {
               method: "call_data_source_tool",
               params: {
-                data_source_name: params.data_source_name,
+                data_source_name: sourceName,
                 api_name: apiName,
                 params: params.params ?? {},
               },
             }
           : {
               method: "get_data_source_desc",
-              params: { name: params.data_source_name },
+              params: { name: sourceName },
             };
 
         const response = await fetchWithAuthRetry(deps, accessToken, (token) =>

package/src/tools/moonshot.ts

@@ -1,5 +1,5 @@
 import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "@earendil-works/pi-ai";
+import { obj, str, type Static } from "@earendil-works/pi-schema";
 
 import {
   type BuildKimiToolOptions,
@@ -15,12 +15,12 @@ import {
   textComponent,
 } from "./common.ts";
 
-export const moonshotSearchSchema = Type.Object({
-  query: Type.String({ description: "The query text to search for." }),
+export const moonshotSearchSchema = obj({
+  query: str({ description: "The query text to search for." }),
 });
 
-export const moonshotFetchSchema = Type.Object({
-  url: Type.String({ description: "The URL to fetch content from." }),
+export const moonshotFetchSchema = obj({
+  url: str({ description: "The URL to fetch content from." }),
 });
 
 export type MoonshotSearchParams = Static<typeof moonshotSearchSchema>;
@@ -119,7 +119,7 @@ export function buildMoonshotSearchTool(options: BuildKimiToolOptions = {}) {
       "Search the web with Kimi Coding, then fetch the few relevant result URLs before answering",
     parameters: moonshotSearchSchema,
 
-    async execute(toolCallId, params, signal) {
+    async execute(toolCallId, params: MoonshotSearchParams, signal) {
       const accessToken = deps.getAccessToken();
       if (!accessToken) {
         return errorResult<MoonshotSearchResult[]>(
@@ -176,7 +176,7 @@ export function buildMoonshotFetchTool(options: BuildKimiToolOptions = {}) {
     promptSnippet: "Fetch a web page with Kimi Coding's Moonshot fetch service",
     parameters: moonshotFetchSchema,
 
-    async execute(toolCallId, params, signal) {
+    async execute(toolCallId, params: MoonshotFetchParams, signal) {
       const accessToken = deps.getAccessToken();
       if (!accessToken) {
         return errorResult<MoonshotFetchResult>(