openclaw-glance-plugin 0.1.22 → 0.1.28

package/skills/glance-watch/references/quote-realtime.md

@@ -0,0 +1,62 @@
+# 实时行情与基金估值
+
+## 适用范围
+
+- 股票/指数/加密实时行情：`watch_query_ticker`
+- 基金当日估值：`watch_query_fund_estimates`
+- 注意：基金不支持 `watch_create` 创建盯盘策略
+
+## 1) 股票/指数/加密实时行情：`watch_query_ticker`
+
+必填参数：
+- `market`：`a` / `hk` / `crypto`（支持中文别名）
+- `symbol`
+
+可选参数：
+- `segment`：`auto` / `stock` / `index`
+
+成功判定：
+- `success === true`
+- `http_status === 200`
+- 行情在 `quote`（英文键，如 `last`、`name`、`pct_change`）
+
+失败处理：
+- 读取 `error` 与 `http_status` 直接反馈，不静默重试
+
+示例：
+
+```javascript
+await watch_query_ticker({ market: 'hk', symbol: '00700', segment: 'stock' })
+await watch_query_ticker({ market: 'A股', symbol: '600000.SH' })
+await watch_query_ticker({ market: 'crypto', symbol: 'BTCUSDT' })
+```
+
+## 2) 基金估值：`watch_query_fund_estimates`
+
+参数（二选一）：
+- `fund_codes`
+- `fundCodes`
+
+值格式：
+- 单只：`"000006.OF"`
+- 多只：`["000006.OF", "110011.OF"]`
+
+成功判定：
+- `success === true`
+- `http_status === 200`
+- `data` 为基金代码映射
+
+失败处理：
+- 读取 `error` 与 `http_status` 反馈用户
+
+示例：
+
+```javascript
+await watch_query_fund_estimates({ fund_codes: '000006.OF' })
+await watch_query_fund_estimates({ fund_codes: ['000006.OF', '110011.OF'] })
+```
+
+## 3) 硬边界
+
+- 不要用 `watch_query_ticker` 查基金当日估值
+- 不要对基金调用 `watch_create`

package/skills/glance-watch/references/symbol-search-and-calendar.md

@@ -0,0 +1,74 @@
+# 标的检索与交易日查询
+
+## 适用范围
+
+- 名称/模糊输入 -> 本地 CSV 匹配或代码：`watch_search_*_basic`
+- 是否开市/交易日：`watch_trade_calendar`
+
+## 1) 标的检索顺序（必须遵循）
+
+1. 先查本地 CSV（`skills/glance-watch/data/*.csv`）
+2. 本地未命中，再调用 `watch_search_*_basic`
+3. 多候选时必须让用户确认后再创建策略
+
+CSV 映射：
+- `stock_a.csv` -> `product_type=stock`
+- `stock_hk.csv` -> `product_type=hk_stock`
+- `index_a.csv` -> `product_type=index`
+- `index_hk.csv` -> `product_type=index`
+- 基金 `xxxxxx.OF` -> 仅估值/基础信息，不创建策略
+
+### 本地 CSV 匹配算法（执行约束）
+
+- 可使用 `rg`/`grep` 检索，不要求固定命令模板。
+- 匹配优先级：
+  1. `完整代码` 精确匹配（如 `600000.SH`、`00700.HK`）
+  2. `代码` 精确匹配（如 `600000`、`00700`）
+  3. `名称` 精确匹配
+  4. `名称` 模糊匹配
+- 命中后优先使用 `完整代码` + `市场` 来确定后续 `market/symbol`，避免仅用短代码。
+- 若出现重名/重码或返回多条候选：必须先向用户确认具体标的，再执行 `watch_query_ticker` 或 `watch_create`。
+
+## 2) 网关基础信息检索工具
+
+- `watch_search_a_stock_basic`（A股）
+- `watch_search_hk_stock_basic`（港股）
+- `watch_search_index_basic`（指数）
+- `watch_search_fund_basic`（基金基础信息）
+
+统一规则：
+- 名称检索至少给 `keyword` 或 `q`
+- 成功返回 `finance.table.result`，结果在 `data[]`
+
+示例：
+
+```javascript
+await watch_search_a_stock_basic({ keyword: '平安银行', limit: 5 })
+await watch_search_hk_stock_basic({ q: '腾讯' })
+await watch_search_index_basic({ keyword: '沪深300' })
+await watch_search_fund_basic({ ts_code: '000006.OF' })
+```
+
+## 3) 交易日查询：`watch_trade_calendar`
+
+参数：
+- `exchange`（A股常用 `SSE` 或 `SZSE`）
+- `start_date`
+- `end_date`
+
+可兼容：
+- `startDate` / `endDate`（会归一化）
+
+成功判定：
+- `success === true`
+- `data[]` 可读 `is_open` 等字段
+
+示例：
+
+```javascript
+await watch_trade_calendar({
+  exchange: 'SSE',
+  start_date: '2026-04-10',
+  end_date: '2026-04-10'
+})
+```

package/skills/glance-watch/references/troubleshooting.md

@@ -6,13 +6,16 @@
 - 重试必须使用同一组 payload（字段和值不变）。
 - `request_id` 由插件运行时自动生成并在同 payload 上复用。
 
-## 创建策略失败（`watch.create`）
+## 创建策略失败（`watch_create`）
 
 处理规则：
 - 明确返回失败原因，不静默重试。
 - 若报“未注册的算子类型”，将 `operator_type` 修正为 `rule` 后重试。
+- 若报 `UNSUPPORTED_PRODUCT_TYPE`，说明命中了基金边界（如 `fund` 或 `000006.OF`）：
+  - 不再重试 `watch_create`
+  - 改用 `watch_query_fund_estimates` 或 `watch_search_fund_basic`
 
-## 通知失败（`notify.*`）
+## 通知失败（`notify_*`）
 
 处理规则：
 - 优先返回 `code/error/hint`。

package/skills/glance-watch/references/watch-contract.md

@@ -1,30 +1,46 @@
-# Watch 动作契约
+# 盯盘策略（watch_*）
 
-## `watch.query_ticker`
+## 适用工具
 
-参数：
-- `stockCode`（或 `productCode`）
-- `productType`
-- `market`（`crypto` 可传空字符串）
+- `watch_create`
+- `watch_list`
+- `watch_pause`
+- `watch_activate`
+- `watch_remove`
 
-成功判定：
-- `code = "000000"` 或 `success = true`
+## 0. 产品边界
 
-失败处理：
-- 返回失败原因
-- 引导用户确认代码/市场后重试
+- 支持盯盘：`stock` / `hk_stock` / `index` / `crypto`
+- 不支持盯盘：基金（`product_type=fund` 或代码形如 `xxxxxx.OF`）
+- 基金相关请改用：`watch_query_fund_estimates` / `watch_search_fund_basic`
 
-## `watch.create`
+## 1. `watch_create`
 
 最小参数：
 - `product_code`
 - `product_type`
 - `operator_type`（固定 `rule`）
-- `operator_parameters`（包含 `condition`、`variables`）
+- `operator_parameters.condition`
+- `operator_parameters.variables`
 
 建议参数：
-- `channels`（默认至少 `openclaw`）
-- `channel_configs.*`
+- `channels`（至少 1 个渠道；是否包含 `openclaw` 见下方渠道规则）
+- `channel_configs`
+
+渠道规则：
+- 用户明确“仅/只用某几个渠道”时：严格按用户指定，可不含 `openclaw`。
+- 用户只说“用某个渠道/某几个渠道”但未强调“仅限”时：默认补 `openclaw`。
+- 不得擅自附加除 `openclaw` 之外的其他渠道。
+
+OpenClaw 路由约束（当 `channels` 包含 `openclaw`）：
+- `channel_configs.openclaw` 必须能定位当前会话。
+- 常用字段：`channel`（或 `source_channel`）、`account_id`、`session_key`、`conversation_id`（或 `chat_id`）。
+- 禁止传空对象 `openclaw: {}` 充当已配置路由。
+- 若宿主提供 `context` 路由信息，优先使用宿主信息。
+
+若 `channels` 包含 `call/sms/email/dingtalk`：
+- 调用前必须读取联系人 CSV 并补齐参数
+- 不可省略对应渠道必填配置
 
 固定结构（字段名不可改）：
 
@@ -63,70 +79,90 @@
 }
 ```
 
+成功判定：
+- `success === true`
+
+失败处理：
+- 返回失败原因，不静默重试
+- 网络波动可重试，但 payload 字段和值保持一致
+- 不手动传 `request_id`
+
 禁止项：
 - `operator_type` 非 `rule`
-- 顶层 `condition`
-- `channel_configs` 渠道配置是字符串
-- 用户未要求渠道却默认附加
+- 顶层放 `condition`
+- `channel_configs.*` 传 JSON 字符串
+- 用户明确“仅/只用某几个渠道”时仍强行附加渠道
+- 基金标的调用 `watch_create`
 
-成功判定：
-- `success = true`
+## 联系人 CSV（创建策略场景必遵守）
 
-失败处理：
-- 明确返回失败原因，不静默重试
-- 超时/网络波动重试时，使用同一 payload（字段和值不变）
-- `request_id` 由插件运行时自动生成并复用，大模型不手动传
+联系人真源：`~/.openclaw/workspace/memory/watch-notify-contacts.csv`
 
-## `watch.pause` / `watch.activate` / `watch.remove`
+规则：
+1. `watch_create` 涉及 `call/sms/email/dingtalk` 时，调用前必须先查 CSV。
+2. 补值优先级：用户本轮输入 > CSV 历史值 > 追问。
+3. 调用成功后，如联系方式有新增或变化，必须回写 CSV。
+4. 只认该 CSV，不读取其他联系人文件。
 
-参数：
-- `strategyId`（或 `strategy_id`）
+建议表头：
 
-成功判定：
-- `success = true`
+```text
+channel,sender_id,sender_name,phone,email,dingtalk_cas_id,customer_name,updated_at,notes
+```
 
-失败处理：
-- 返回失败原因并提示用户确认策略 ID
+查询示例：
+
+```bash
+rg -n '^sms,jinguo\.xie,' ~/.openclaw/workspace/memory/watch-notify-contacts.csv
+```
+
+回写要求：
+
+- 已有同一 `(channel, sender_id)`：更新该行，不重复追加
+- 不存在：按表头顺序追加
+- `updated_at`：写 ISO-8601 时间
 
-## `watch.list`
+## 2. `watch_list`
 
 可选参数：
-- `status`: `active/paused/completed/failed/expired`
+- `status`：`active/paused/completed/failed/expired`
 - `product_code`（或 `productCode`）
 
 成功判定：
-- `success = true`
-- `data.total` 为命中数量
-- `data.strategies` 为策略列表
+- `success === true`
+- `data.total` 与 `data.strategies` 可读
 
-失败处理：
-- 返回失败原因，不静默重试
-- 空结果明确告知“当前条件下没有策略”
+空结果文案：
+- 当 `data.total === 0` 时，明确告知“当前条件下没有策略”。
 
 安全约束：
-- 仅可查询当前连接用户自己的策略
-- 不通过 `user_id/use_id` 越权查询
+- 仅查询当前连接用户策略
+- 禁止通过 `user_id/use_id` 越权查询
+
+## 3. `watch_pause` / `watch_activate` / `watch_remove`
+
+参数：
+- `strategy_id`（或 `strategyId`）
+
+成功判定：
+- `success === true`
 
-## 调用前最终检查
+## 调用前最终检查（`watch_create`）
 
-1. `watch.create` 使用 snake_case：`product_code/product_type/operator_type/operator_parameters/channel_configs`
-2. `operator_type` 固定 `rule`
-3. `operator_parameters.condition` 与 `variables` 同时存在
-4. `channels` 与 `channel_configs` 一一对应
-5. 渠道配置是对象，不是 JSON 字符串
-6. 默认不手动传 `request_id`
+1. 字段名使用 snake_case：`product_code/product_type/operator_type/operator_parameters/channels/channel_configs`
+2. `operator_type` 固定为 `rule`
+3. `operator_parameters.condition` 与 `operator_parameters.variables` 同时存在
+4. `channels` 至少一个，且与 `channel_configs` 对应
+5. 渠道配置必须是对象，不能是 JSON 字符串
+6. 不手动传 `request_id`
 
-## 买卖意图与条件方向
+## 4. 买卖意图与条件方向
 
 | 用户意图 | 条件方向 |
-|---------|---------|
+|---|---|
 | 买入（逢低） | `price <= threshold` |
 | 卖出（止盈/止损） | `price >= threshold` |
 
-判断规则：
-1. 用户明确说“涨到/跌到”时，按方向直接生成条件。
-2. 用户只说“到了 XX 提醒我”时，必须追问“买还是卖”。
-3. 常见映射：
-- `涨到/涨过/突破/冲到` -> `price >= threshold`
-- `跌到/跌破/回调到/回到` -> `price <= threshold`
-- `到了/到达/价格到` -> 方向不明确，需追问
+规则：
+1. 用户明确“涨到/跌到”时按方向生成。
+2. 用户只说“到了XX提醒我”时先追问买卖方向。

package/src/OpenClawBridgeClient.js

@@ -3,6 +3,12 @@ import WebSocket from 'ws';
 
 const DEFAULT_BASE_WS_URL = 'wss://glanceup-pre.100credit.cn';
 
+/** 基金估值网关可能较慢，应大于 bridge 侧 OPENCLAW_FUND_ESTIMATES_TIMEOUT_SECONDS（默认 90s） */
+const FUND_ESTIMATES_REQUEST_TIMEOUT_MS = 120_000;
+
+/** 白名单表接口（含 fin_news）可能较慢 */
+const FINANCE_TABLE_REQUEST_TIMEOUT_MS = 90_000;
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -180,6 +186,18 @@ export class OpenClawBridgeClient extends EventEmitter {
     return this._request('ticker.query', payload || {});
   }
 
+  async queryFundEstimates(payload) {
+    return this._request('fund.estimates', payload || {}, {
+      requestTimeoutMs: FUND_ESTIMATES_REQUEST_TIMEOUT_MS
+    });
+  }
+
+  async queryFinanceTable(payload) {
+    return this._request('finance.table', payload || {}, {
+      requestTimeoutMs: FINANCE_TABLE_REQUEST_TIMEOUT_MS
+    });
+  }
+
   async waitUntilConnected(timeoutMs = this.waitConnectTimeoutMs) {
     if (this.connected && this.ws && this.ws.readyState === WebSocket.OPEN) {
       return true;
@@ -216,6 +234,7 @@ export class OpenClawBridgeClient extends EventEmitter {
     if (!requestId) {
       requestId = makeRequestId();
     }
+    const timeoutMs = options.requestTimeoutMs ?? this.requestTimeoutMs;
     const msg = { type, request_id: requestId, payload: normalizedPayload };
     const { promise, resolve, reject } = this._buildWaiter(type, requestId);
 
@@ -228,12 +247,12 @@ export class OpenClawBridgeClient extends EventEmitter {
         reject(new Error(`request queue overflow (max=${this.maxQueueSize})`));
         return promise;
       }
-      this.requestQueue.push({ msg, requestId, type, resolve, reject });
+      this.requestQueue.push({ msg, requestId, type, resolve, reject, timeoutMs });
       this.emit('queued', { type, requestId, queueSize: this.requestQueue.length });
       return promise;
     }
 
-    this._sendWithTimeout({ msg, requestId, type, resolve, reject });
+    this._sendWithTimeout({ msg, requestId, type, resolve, reject, timeoutMs });
     return promise;
   }
 
@@ -247,11 +266,12 @@ export class OpenClawBridgeClient extends EventEmitter {
     return { promise, resolve, reject, type, requestId };
   }
 
-  _sendWithTimeout({ msg, requestId, type, resolve, reject }) {
+  _sendWithTimeout({ msg, requestId, type, resolve, reject, timeoutMs }) {
+    const ms = timeoutMs ?? this.requestTimeoutMs;
     const timer = setTimeout(() => {
       this.pending.delete(requestId);
       reject(new Error(`request timeout: ${type} (${requestId})`));
-    }, this.requestTimeoutMs);
+    }, ms);
 
     this.pending.set(requestId, { resolve, reject, timer, type });
     this.ws.send(JSON.stringify(msg));

package/src/OpenClawPluginAdapter.js

@@ -1,3 +1,9 @@
+import {
+  normalizeFundBasicTableQuery,
+  normalizeKeywordTableQuery,
+  normalizeTickerQuery,
+  normalizeTradeCalendarQuery
+} from './agentQueryNormalize.js';
 import { OpenClawBridgeClient } from './OpenClawBridgeClient.js';
 import { extractOpenclawRoutingFromRecord } from './openclawRouting.js';
 
@@ -134,21 +140,81 @@ export class OpenClawPluginAdapter {
   }
 
   /**
-   * 查询标的实时行情（透传到 bridge 的 ticker.query）。
+   * 查询标的实时行情；参数为 market / symbol / segment，与网关 quote 接口一致；应答为 ticker.query.result。
    */
   async queryTickerData(query) {
-    const stockCode = query?.stockCode || query?.productCode || query?.stock_code || '';
-    const productType = query?.productType || query?.product_type || '';
-    let market = query?.market;
+    const payload = normalizeTickerQuery(query || {});
+    if (!payload.market || !payload.symbol) {
+      throw new Error(
+        'queryTickerData requires market and symbol. If user gave a name only, use search*Basic first.'
+      );
+    }
+    return this.client.queryTickerData(payload);
+  }
 
-    if (market == null && String(productType).toLowerCase() === 'crypto') {
-      market = '';
+  /**
+   * 基金实时估值；payload.fund_codes 与网关 POST /v1/realtime/fund/estimates 一致；应答为 fund.estimates.result。
+   */
+  async queryFundEstimates(query) {
+    let fundCodes = query?.fund_codes ?? query?.fundCodes;
+    if (fundCodes == null) {
+      throw new Error('queryFundEstimates requires fund_codes (or fundCodes)');
+    }
+    if (typeof fundCodes === 'string') {
+      fundCodes = fundCodes.trim();
+    } else if (Array.isArray(fundCodes)) {
+      fundCodes = fundCodes.map((x) => String(x).trim()).filter(Boolean);
+    } else {
+      throw new Error('fund_codes must be a string or string[]');
     }
+    return this.client.queryFundEstimates({ fund_codes: fundCodes });
+  }
+
+  async searchAStockBasic(query) {
+    const q = normalizeKeywordTableQuery(query, 'searchAStockBasic');
+    return this.client.queryFinanceTable({
+      path: '/v1/a-stock/basic/search',
+      query: q
+    });
+  }
+
+  async searchHkStockBasic(query) {
+    const q = normalizeKeywordTableQuery(query, 'searchHkStockBasic');
+    return this.client.queryFinanceTable({
+      path: '/v1/hk-stock/basic/search',
+      query: q
+    });
+  }
+
+  async searchIndexBasic(query) {
+    const q = normalizeKeywordTableQuery(query, 'searchIndexBasic');
+    return this.client.queryFinanceTable({
+      path: '/v1/index/basic/search',
+      query: q
+    });
+  }
+
+  async searchFundBasic(query) {
+    const q = normalizeFundBasicTableQuery(query);
+    return this.client.queryFinanceTable({
+      path: '/v1/fund/basic',
+      query: q
+    });
+  }
+
+  async queryFinNews(query) {
+    const q = normalizeKeywordTableQuery(query, 'queryFinNews');
+    return this.client.queryFinanceTable({
+      path: '/v1/news',
+      query: q
+    });
+  }
 
-    return this.client.queryTickerData({
-      stock_code: stockCode,
-      market: market == null ? '' : String(market),
-      product_type: productType
+  async queryTradeCalendar(query) {
+    const q = normalizeTradeCalendarQuery(query);
+    return this.client.queryFinanceTable({
+      path: '/v1/trade-calendar',
+      query: q
     });
   }
 

package/src/agentQueryNormalize.js

@@ -0,0 +1,84 @@
+/**
+ * OpenClaw / Agent 侧查询参数归一化，与 buildControlApi 行为一致。
+ */
+
+export function trimQuery(v) {
+  if (v == null) return '';
+  return String(v).trim();
+}
+
+/** 中文/别名 → 网关 market；symbol 去空格 */
+export function normalizeTickerQuery(query = {}) {
+  const raw = trimQuery(query.market);
+  const lower = raw.toLowerCase();
+  const cn = {
+    A股: 'a',
+    a股: 'a',
+    沪深: 'a',
+    上证: 'a',
+    深市: 'a',
+    港股: 'hk',
+    港交所: 'hk',
+    加密: 'crypto',
+    数字货币: 'crypto',
+    虚拟货币: 'crypto',
+    比特币: 'crypto'
+  };
+  let market = cn[raw] || lower;
+  if (market === 'hongkong' || market === 'hong kong') market = 'hk';
+  if (market === 'btc' || market === 'crypto-currency') market = 'crypto';
+  const symbol = trimQuery(query.symbol);
+  const out = { market, symbol };
+  const seg = query.segment != null ? trimQuery(query.segment) : '';
+  if (seg) out.segment = seg;
+  return out;
+}
+
+export function normalizeKeywordTableQuery(query = {}, label) {
+  const q = { ...(query || {}) };
+  const k = trimQuery(q.keyword);
+  const qq = trimQuery(q.q);
+  const text = k || qq;
+  if (!text) {
+    throw new Error(
+      `${label} requires keyword or q (search text). If user only gave a name, put it in keyword.`
+    );
+  }
+  q.keyword = text;
+  delete q.q;
+  return q;
+}
+
+export function normalizeFundBasicTableQuery(query = {}) {
+  const q = { ...(query || {}) };
+  const tc = trimQuery(q.ts_code ?? q.tsCode);
+  if (tc) {
+    const out = { ...q, ts_code: tc };
+    delete out.tsCode;
+    delete out.keyword;
+    delete out.q;
+    return out;
+  }
+  return normalizeKeywordTableQuery(q, 'searchFundBasic');
+}
+
+export function normalizeTradeCalendarQuery(query = {}) {
+  const q = { ...(query || {}) };
+  const start = trimQuery(q.start_date ?? q.startDate);
+  const end = trimQuery(q.end_date ?? q.endDate);
+  const ex = trimQuery(q.exchange);
+  if (!ex) {
+    throw new Error(
+      'queryTradeCalendar requires exchange (SSE=上交所, SZSE=深交所, 等，与网关一致)'
+    );
+  }
+  if (!start || !end) {
+    throw new Error(
+      'queryTradeCalendar requires start_date and end_date as YYYY-MM-DD (or startDate/endDate)'
+    );
+  }
+  const out = { ...q, exchange: ex, start_date: start, end_date: end };
+  delete out.startDate;
+  delete out.endDate;
+  return out;
+}