@openfinclaw/openfinclaw-strategy 0.0.11 → 0.1.1

package/skills/strategy-fork/SKILL.md

@@ -146,10 +146,10 @@ Agent:
 
 ## 注意事项
 
-1. **API Key**: 某些操作需要配置 API Key
+1. **API Key**: Fork 操作需要配置 API Key
 
    ```bash
-   openfinclaw config set plugins.entries.openfinclaw.config.skillApiKey YOUR_KEY
+   openclaw config set plugins.entries.openfinclaw.config.apiKey YOUR_KEY
    ```
 
 2. **同名冲突**: 如果两个策略名称相同，会自动添加短 ID 后缀区分

package/skills/strategy-pack/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: strategy-pack
-description: "Create and validate Findoo Backtest (FEP v2.0) strategy packages. Use when the user wants to create a strategy pack, generate fep.yaml and strategy.py, or prepare a folder for remote backtest. Always validate with backtest_remote_validate before zipping and submitting."
-metadata: { "openclaw": { "requires": { "extensions": ["fin-backtest-remote"] } } }
+description: "Create and validate FEP v2.0 strategy packages. Use when the user wants to create a strategy pack, generate fep.yaml and strategy.py, or prepare a folder for publishing. Always validate with skill_validate before zipping and publishing."
+metadata: { "openclaw": { "requires": { "extensions": ["openfinclaw"] } } }
 ---
 
 # 策略包生成与校验 (FEP v2.0)
 
-当用户要**创建策略包**、**生成回测策略包**、**写 fep 策略**、**打包后提交回测**时，按以下结构生成目录和文件，并在**上传前必须用 `backtest_remote_validate` 校验**，通过后再打包为 ZIP 并提交。
+当用户要**创建策略包**、**生成回测策略包**、**写 fep 策略**、**打包后提交发布**时，按以下结构生成目录和文件，并在**上传前必须用 `skill_validate` 校验**，通过后再打包为 ZIP 并发布。
 
 ## 何时触发
 
@@ -261,7 +261,7 @@ def select(universe):
    - `identity`: id, name, type, version, style, visibility, summary, description, license, tags, author.name, changelog (全部必填)
    - `backtest`: symbol, defaultPeriod (startDate/endDate), initialCapital (全部必填)
 3. **strategy.py:** 定义 `compute(data)` 或 `select(universe)`；返回 dict 包含正确字段；无禁止的导入/调用。
-4. 调用 `backtest_remote_validate` 传入策略包目录路径 `dirPath`。若返回 `valid: false`，根据 `errors` 修正后再次校验。
+4. 调用 `skill_validate` 传入策略包目录路径 `dirPath`。若返回 `valid: false`，根据 `errors` 修正后再次校验。
 5. Auto-fix and re-validate up to 3 iterations；若仍失败，向用户清晰解释问题。
 
 **不要**在校验未通过时打包上传。
@@ -270,16 +270,16 @@ def select(universe):
 
 校验通过后，在策略包目录下执行 `zip -r ../<id>-<version>.zip fep.yaml scripts/`（例如 `fin-dca-basic-test-1.0.0.zip`），得到 ZIP 路径。
 
-### Step 4: 提交
+### Step 4: 发布
 
-调用 `backtest_remote_submit`，传入 ZIP 的 `filePath`（及可选 engine, budget_cap_usd）。
+调用 `skill_publish`，传入 ZIP 的 `filePath`（及可选 visibility）。
 
 ## 相关 Tools
 
-| Tool                                                | 用途                                                    |
-| --------------------------------------------------- | ------------------------------------------------------- |
-| `backtest_remote_validate`                          | 校验策略包目录格式是否符合 fep v2.0，通过后才可打包上传 |
-| `backtest_remote_submit`                            | 提交已打包的 ZIP 到远程回测服务                         |
-| `backtest_remote_status` / `backtest_remote_report` | 查询任务状态与报告                                      |
+| Tool                   | 用途                                  |
+| ---------------------- | ------------------------------------- |
+| `skill_validate`       | 校验策略包目录格式是否符合 FEP v2.0   |
+| `skill_publish`        | 提交已打包的 ZIP 到 Hub，自动触发回测 |
+| `skill_publish_verify` | 查询发布状态与回测报告                |
 
-总结：**先按本 skill 生成/补全策略包 → 用 backtest_remote_validate 校验 → 通过后再打包并 backtest_remote_submit**。
+总结：**先按本 skill 生成/补全策略包 → 用 skill_validate 校验 → 通过后再打包并 skill_publish**。

package/src/cli.ts

@@ -2,9 +2,9 @@
  * CLI commands for strategy management.
  */
 import type { Command } from "commander";
-import { forkStrategy, fetchStrategyInfo } from "./fork.js";
-import { listLocalStrategies, findLocalStrategy, removeLocalStrategy } from "./strategy-storage.js";
-import type { SkillApiConfig, LeaderboardResponse, BoardType } from "./types.js";
+import { forkStrategy, fetchStrategyInfo } from "./strategy/fork.js";
+import { listLocalStrategies, findLocalStrategy, removeLocalStrategy } from "./strategy/storage.js";
+import type { UnifiedPluginConfig, LeaderboardResponse, BoardType } from "./types.js";
 
 type Logger = {
   info: (message: string) => void;
@@ -14,7 +14,7 @@ type Logger = {
 
 export function registerStrategyCli(params: {
   program: Command;
-  config: SkillApiConfig;
+  config: UnifiedPluginConfig;
   logger: Logger;
 }) {
   const { program, config } = params;
@@ -34,7 +34,7 @@ export function registerStrategyCli(params: {
         const limit = Math.min(Math.max(Number(options.limit) || 20, 1), 100);
         const offset = Math.max(Number(options.offset) || 0, 0);
 
-        const url = new URL(`${config.baseUrl}/api/v1/skill/leaderboard/${boardType}`);
+        const url = new URL(`${config.hubApiUrl}/api/v1/skill/leaderboard/${boardType}`);
         url.searchParams.set("limit", String(limit));
         url.searchParams.set("offset", String(offset));
 

package/src/config.ts

@@ -0,0 +1,57 @@
+/**
+ * Unified configuration resolver for OpenFinClaw plugin.
+ * Supports single API key for both Hub and DataHub services.
+ */
+import type { OpenClawPluginApi } from "openfinclaw/plugin-sdk";
+import type { UnifiedPluginConfig } from "./types.js";
+
+const DEFAULT_HUB_API_URL = "https://hub.openfinclaw.ai";
+const DEFAULT_DATAHUB_GATEWAY_URL = "http://43.134.61.136:9080";
+const DEFAULT_TIMEOUT_MS = 60_000;
+
+function readEnv(keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = process.env[key]?.trim();
+    if (value) return value;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve unified plugin configuration from plugin config and environment variables.
+ * Priority: plugin config > env var > default
+ */
+export function resolvePluginConfig(api: OpenClawPluginApi): UnifiedPluginConfig {
+  const raw = api.pluginConfig as Record<string, unknown> | undefined;
+
+  const apiKey =
+    (typeof raw?.apiKey === "string" ? raw.apiKey : undefined) ??
+    (typeof raw?.skillApiKey === "string" ? raw.skillApiKey : undefined) ??
+    (typeof raw?.datahubApiKey === "string" ? raw.datahubApiKey : undefined) ??
+    readEnv(["OPENFINCLAW_API_KEY", "SKILL_API_KEY", "DATAHUB_API_KEY"]);
+
+  const hubApiUrl =
+    (typeof raw?.hubApiUrl === "string" ? raw.hubApiUrl : undefined) ??
+    (typeof raw?.skillApiUrl === "string" ? raw.skillApiUrl : undefined) ??
+    readEnv(["HUB_API_URL", "SKILL_API_URL"]) ??
+    DEFAULT_HUB_API_URL;
+
+  const datahubGatewayUrl =
+    (typeof raw?.datahubGatewayUrl === "string" ? raw.datahubGatewayUrl : undefined) ??
+    readEnv(["DATAHUB_GATEWAY_URL", "OPENFINCLAW_DATAHUB_GATEWAY_URL"]) ??
+    DEFAULT_DATAHUB_GATEWAY_URL;
+
+  const timeoutRaw =
+    raw?.requestTimeoutMs ?? readEnv(["REQUEST_TIMEOUT_MS", "SKILL_REQUEST_TIMEOUT_MS"]);
+  const requestTimeoutMs =
+    Number(timeoutRaw) >= 5000 && Number(timeoutRaw) <= 300_000
+      ? Math.floor(Number(timeoutRaw))
+      : DEFAULT_TIMEOUT_MS;
+
+  return {
+    apiKey: apiKey && apiKey.length > 0 ? apiKey : undefined,
+    hubApiUrl: hubApiUrl.replace(/\/$/, ""),
+    datahubGatewayUrl: datahubGatewayUrl.replace(/\/+$/, ""),
+    requestTimeoutMs,
+  };
+}

package/src/datahub/client.ts

@@ -0,0 +1,150 @@
+/**
+ * DataHub REST client via Gateway proxy.
+ * Uses Bearer token authentication (fch_<64-char-hex>).
+ * Gateway validates API key in Redis, then forwards to DataHub with Basic Auth.
+ */
+import type { OHLCV, Ticker, MarketType } from "../types.js";
+
+export class DataHubClient {
+  private authHeader: string;
+
+  constructor(
+    private gatewayUrl: string,
+    apiKey: string,
+    private timeoutMs: number,
+  ) {
+    this.authHeader = `Bearer ${apiKey}`;
+  }
+
+  async query(path: string, params?: Record<string, string>): Promise<unknown[]> {
+    const url = new URL(`${this.gatewayUrl}/api/v1/${path}`);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
+    }
+
+    const resp = await fetch(url.toString(), {
+      headers: { Authorization: this.authHeader },
+      signal: AbortSignal.timeout(this.timeoutMs),
+    });
+
+    if (resp.status === 204) return [];
+    const text = await resp.text();
+    if (!resp.ok) throw new Error(`Gateway error (${resp.status}): ${text.slice(0, 300)}`);
+
+    let payload: { results?: unknown[]; detail?: string };
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      throw new Error(`Gateway returned non-JSON (${resp.status}): ${text.slice(0, 200)}`);
+    }
+    if (payload.detail) throw new Error(`Gateway: ${payload.detail}`);
+    return payload.results ?? [];
+  }
+
+  crypto(endpoint: string, params?: Record<string, string>) {
+    return this.query(`crypto/${endpoint}`, params);
+  }
+
+  equity(endpoint: string, params?: Record<string, string>) {
+    return this.query(`equity/${endpoint}`, params);
+  }
+
+  async getOHLCV(params: {
+    symbol: string;
+    market: string;
+    since?: number;
+    limit?: number;
+  }): Promise<OHLCV[]> {
+    const qp: Record<string, string> = { symbol: params.symbol };
+    if (params.since) qp.start_date = new Date(params.since).toISOString().slice(0, 10);
+    const apiLimit = params.limit ? String(Math.min(params.limit * 2, 500)) : "100";
+    qp.limit = apiLimit;
+
+    const results =
+      params.market === "crypto"
+        ? await this.crypto("price/historical", { ...qp, provider: "ccxt" })
+        : await this.equity("price/historical", { ...qp, provider: detectProvider(params.symbol) });
+
+    return this.normalizeOHLCV(results, params.limit);
+  }
+
+  async getTicker(symbol: string, market: string): Promise<Ticker> {
+    if (market === "crypto") {
+      const results = await this.crypto("market/ticker", { symbol, exchange: "binance" });
+      const t = (results[0] ?? {}) as Record<string, unknown>;
+      return {
+        symbol,
+        market: "crypto",
+        last: Number(t.last ?? t.close ?? t.bid ?? 0),
+        volume24h: Number(t.baseVolume ?? t.volume ?? 0) || undefined,
+        timestamp: Date.now(),
+      };
+    }
+
+    const qp: Record<string, string> = {
+      symbol,
+      provider: detectProvider(symbol),
+      limit: "5",
+    };
+    const results = await this.equity("price/historical", qp);
+    const rows = (results as Array<Record<string, unknown>>).sort((a, b) => {
+      const da = String(a.date ?? a.trade_date ?? "");
+      const db = String(b.date ?? b.trade_date ?? "");
+      return db.localeCompare(da);
+    });
+    const last = rows[0] as Record<string, unknown> | undefined;
+    if (!last) throw new Error(`No ticker data for ${symbol}`);
+    return {
+      symbol,
+      market: "equity",
+      last: Number(last.close ?? 0),
+      volume24h: Number(last.volume ?? 0) || undefined,
+      timestamp: last.date ? new Date(String(last.date)).getTime() : Date.now(),
+    };
+  }
+
+  private normalizeOHLCV(results: unknown[], limit?: number): OHLCV[] {
+    const rows = (results as Array<Record<string, unknown>>)
+      .map((r) => {
+        const ts = r.date ?? r.trade_date ?? r.timestamp;
+        if (!ts) return null;
+        return {
+          timestamp: typeof ts === "number" ? ts : new Date(String(ts)).getTime(),
+          open: Number(r.open) || 0,
+          high: Number(r.high) || 0,
+          low: Number(r.low) || 0,
+          close: Number(r.close) || 0,
+          volume: Number(r.volume ?? r.vol) || 0,
+        };
+      })
+      .filter((r): r is OHLCV => r !== null)
+      .sort((a, b) => a.timestamp - b.timestamp);
+    return limit ? rows.slice(-limit) : rows;
+  }
+}
+
+function detectProvider(symbol: string): string {
+  const u = symbol.toUpperCase();
+  if (
+    u.endsWith(".SH") ||
+    u.endsWith(".SZ") ||
+    u.endsWith(".BJ") ||
+    u.endsWith(".HK") ||
+    /^\d{6}/.test(u)
+  )
+    return "tushare";
+  return "massive";
+}
+
+/**
+ * Guess market type from symbol format.
+ */
+export function guessMarket(symbol: string): MarketType {
+  if (symbol.includes("/")) return "crypto";
+  const u = symbol.toUpperCase();
+  if (u.endsWith(".SH") || u.endsWith(".SZ") || u.endsWith(".BJ") || u.endsWith(".HK"))
+    return "equity";
+  if (/^\d{5,6}/.test(u)) return "equity";
+  if (/^[A-Z]{1,5}$/.test(u)) return "equity";
+  return "crypto";
+}

package/src/datahub/tools.ts

@@ -0,0 +1,349 @@
+/**
+ * DataHub market data tools registration.
+ * Tools: fin_price, fin_kline, fin_crypto, fin_compare, fin_slim_search
+ */
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openfinclaw/plugin-sdk";
+import { DataHubClient, guessMarket } from "./client.js";
+import type { UnifiedPluginConfig, MarketType } from "../types.js";
+
+/** JSON tool result helper. */
+function json(payload: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
+    details: payload,
+  };
+}
+
+/** Helper to pick params. */
+function pick(params: Record<string, unknown>, ...keys: string[]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const k of keys) {
+    if (params[k] != null) out[k] = String(params[k]);
+  }
+  return out;
+}
+
+const NO_KEY = "API key not configured. Set apiKey in plugin config or OPENFINCLAW_API_KEY env var.";
+
+/**
+ * Register DataHub market data tools.
+ */
+export function registerDatahubTools(
+  api: OpenClawPluginApi,
+  config: UnifiedPluginConfig,
+): void {
+  const datahubClient = config.apiKey
+    ? new DataHubClient(config.datahubGatewayUrl, config.apiKey, config.requestTimeoutMs)
+    : null;
+
+  // Register fin-data-provider service for other plugins
+  if (datahubClient) {
+    api.registerService({
+      id: "fin-data-provider",
+      start: () => {},
+      instance: {
+        async getOHLCV(params: {
+          symbol: string;
+          market?: string;
+          timeframe?: string;
+          limit?: number;
+        }) {
+          const market = (params.market as MarketType) ?? guessMarket(params.symbol);
+          return datahubClient.getOHLCV({
+            symbol: params.symbol,
+            market,
+            limit: params.limit ?? 300,
+          });
+        },
+        async getTicker(symbol: string, market?: string) {
+          const m = (market as MarketType) ?? guessMarket(symbol);
+          return datahubClient.getTicker(symbol, m);
+        },
+      },
+    } as Parameters<typeof api.registerService>[0]);
+  }
+
+  // ── fin_price — Price Lookup ──
+  api.registerTool(
+    {
+      name: "fin_price",
+      label: "Price Lookup",
+      description:
+        "Get the current/latest price for any asset — stocks (A/HK/US), crypto, index. " +
+        "Returns latest close, volume, and date. The simplest way to answer 'XX 现在什么价格'.",
+      parameters: Type.Object({
+        symbol: Type.String({
+          description:
+            "Asset symbol. Crypto: BTC/USDT, ETH/USDT; A-share: 600519.SH; HK: 00700.HK; US: AAPL; Index: 000300.SH",
+        }),
+        market: Type.Optional(
+          Type.Unsafe<"crypto" | "equity">({
+            type: "string",
+            enum: ["crypto", "equity"],
+            description:
+              "Market type. Auto-detected if omitted: symbols with .SH/.SZ/.HK or pure letters → equity; contains '/' → crypto.",
+          }),
+        ),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const symbol = String(params.symbol);
+          const market = (params.market as MarketType) ?? guessMarket(symbol);
+          const ticker = await datahubClient.getTicker(symbol, market);
+          return json({
+            symbol: ticker.symbol,
+            market: ticker.market,
+            price: ticker.last,
+            volume24h: ticker.volume24h,
+            timestamp: new Date(ticker.timestamp).toISOString(),
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_price"] },
+  );
+
+  // ── fin_kline — K-Line / OHLCV ──
+  api.registerTool(
+    {
+      name: "fin_kline",
+      label: "K-Line / OHLCV",
+      description:
+        "Fetch historical OHLCV (candlestick) data for any asset. " +
+        "Use for price history, charting, and trend analysis.",
+      parameters: Type.Object({
+        symbol: Type.String({
+          description: "Asset symbol (BTC/USDT, 600519.SH, AAPL, etc.)",
+        }),
+        market: Type.Optional(
+          Type.Unsafe<"crypto" | "equity">({
+            type: "string",
+            enum: ["crypto", "equity"],
+            description: "Market type (auto-detected if omitted)",
+          }),
+        ),
+        limit: Type.Optional(
+          Type.Number({ description: "Number of bars to return (default: 30)" }),
+        ),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const symbol = String(params.symbol);
+          const market = (params.market as MarketType) ?? guessMarket(symbol);
+          const limit = (params.limit as number) ?? 30;
+          const ohlcv = await datahubClient.getOHLCV({ symbol, market, limit });
+          return json({
+            symbol,
+            market,
+            count: ohlcv.length,
+            bars: ohlcv.map((b) => ({
+              date: new Date(b.timestamp).toISOString().slice(0, 10),
+              open: b.open,
+              high: b.high,
+              low: b.low,
+              close: b.close,
+              volume: b.volume,
+            })),
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_kline"] },
+  );
+
+  // ── fin_crypto — Crypto & DeFi ──
+  api.registerTool(
+    {
+      name: "fin_crypto",
+      label: "Crypto & DeFi",
+      description:
+        "Crypto market data (ticker/orderbook/trades/funding_rate) via CEX, " +
+        "DeFi (protocols/TVL/yields/stablecoins/fees/dex_volumes) via DefiLlama, " +
+        "market metrics (coin/market/info/categories/trending/global_stats) via CoinGecko.",
+      parameters: Type.Object({
+        endpoint: Type.Unsafe<string>({
+          type: "string",
+          enum: [
+            "market/ticker",
+            "market/tickers",
+            "market/orderbook",
+            "market/trades",
+            "market/funding_rate",
+            "coin/market",
+            "coin/historical",
+            "coin/info",
+            "coin/categories",
+            "coin/trending",
+            "coin/global_stats",
+            "defi/protocols",
+            "defi/tvl_historical",
+            "defi/protocol_tvl",
+            "defi/chains",
+            "defi/yields",
+            "defi/stablecoins",
+            "defi/fees",
+            "defi/dex_volumes",
+            "defi/bridges",
+            "defi/coin_prices",
+            "price/historical",
+            "search",
+          ],
+          description: "DataHub crypto endpoint path",
+        }),
+        symbol: Type.Optional(
+          Type.String({ description: "Coin ID, trading pair, or protocol slug" }),
+        ),
+        start_date: Type.Optional(Type.String({ description: "Start date (YYYY-MM-DD)" })),
+        end_date: Type.Optional(Type.String({ description: "End date (YYYY-MM-DD)" })),
+        limit: Type.Optional(Type.Number({ description: "Max results (default: 20)" })),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const endpoint = String(params.endpoint ?? "coin/market");
+          const qp = pick(params, "symbol", "start_date", "end_date", "limit");
+          if (!qp.limit) qp.limit = "20";
+          if (qp.symbol) {
+            const coinIdEndpoints = ["coin/historical", "coin/info"];
+            if (coinIdEndpoints.includes(endpoint)) {
+              qp.coin_id = qp.symbol;
+              delete qp.symbol;
+            } else if (endpoint === "defi/protocol_tvl") {
+              qp.protocol = qp.symbol;
+              delete qp.symbol;
+            } else if (endpoint === "defi/coin_prices") {
+              qp.coins = qp.symbol;
+              delete qp.symbol;
+            }
+          }
+          const results = await datahubClient.crypto(endpoint, qp);
+          return json({
+            success: true,
+            endpoint: `crypto/${endpoint}`,
+            count: results.length,
+            results,
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_crypto"] },
+  );
+
+  // ── fin_compare — Price Compare ──
+  api.registerTool(
+    {
+      name: "fin_compare",
+      label: "Price Compare",
+      description:
+        "Compare prices of 2-5 assets side by side. Returns latest price and recent change for each. " +
+        "Use for cross-asset comparison questions like 'BTC vs ETH vs 黄金'.",
+      parameters: Type.Object({
+        symbols: Type.String({
+          description: "Comma-separated symbols (2-5). Example: BTC/USDT,ETH/USDT,600519.SH",
+        }),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const raw = String(params.symbols);
+          const symbols = raw
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+            .slice(0, 5);
+          if (symbols.length < 2)
+            return json({ error: "Need at least 2 symbols, comma-separated" });
+
+          const results = await Promise.allSettled(
+            symbols.map(async (sym) => {
+              const market = guessMarket(sym);
+              const ticker = await datahubClient!.getTicker(sym, market);
+              const bars = await datahubClient!.getOHLCV({ symbol: sym, market, limit: 7 });
+              const weekAgo = bars.length > 0 ? bars[0]!.close : ticker.last;
+              const weekChange = weekAgo > 0 ? ((ticker.last - weekAgo) / weekAgo) * 100 : 0;
+              return {
+                symbol: sym,
+                market,
+                price: ticker.last,
+                weekChange: Math.round(weekChange * 100) / 100,
+              };
+            }),
+          );
+
+          return json({
+            comparison: results.map((r, i) =>
+              r.status === "fulfilled"
+                ? r.value
+                : { symbol: symbols[i], error: (r.reason as Error).message },
+            ),
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_compare"] },
+  );
+
+  // ── fin_slim_search — Symbol Search ──
+  api.registerTool(
+    {
+      name: "fin_slim_search",
+      label: "Symbol Search",
+      description:
+        "Search for stock/crypto symbols by name or keyword. " +
+        "Use when user mentions a company/coin name but not the exact symbol.",
+      parameters: Type.Object({
+        query: Type.String({ description: "Search keyword (e.g. '茅台', 'bitcoin', 'Tesla')" }),
+        market: Type.Optional(
+          Type.Unsafe<"crypto" | "equity">({
+            type: "string",
+            enum: ["crypto", "equity"],
+            description: "Limit search to market type",
+          }),
+        ),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const q = String(params.query);
+          const market = params.market as string | undefined;
+
+          const results: unknown[] = [];
+
+          if (!market || market === "crypto") {
+            try {
+              const crypto = await datahubClient!.crypto("search", { query: q, limit: "5" });
+              results.push(...crypto.map((r) => ({ ...(r as object), market: "crypto" })));
+            } catch {
+              /* ignore */
+            }
+          }
+
+          if (!market || market === "equity") {
+            try {
+              const equity = await datahubClient!.equity("search", { query: q, limit: "5" });
+              results.push(...equity.map((r) => ({ ...(r as object), market: "equity" })));
+            } catch {
+              /* ignore */
+            }
+          }
+
+          return json({ query: q, count: results.length, results });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_slim_search"] },
+  );
+}