koishi-plugin-disaster-warning 0.1.2 → 0.1.4

package/README.md

@@ -1,61 +1,98 @@
-# koishi-plugin-disaster-warning
-
-[![npm](https://img.shields.io/npm/v/koishi-plugin-disaster-warning?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-disaster-warning)
-
-Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）实时推送。
-本插件移植自 [astrbot_plugin_disaster_warning](https://github.com/DBJD-CR/astrbot_plugin_disaster_warning)，感谢原作者的开源贡献。
-
-## ✨ 功能特性
-
-### 🌍 多数据源支持
-插件支持多个可自由选择启用的细粒度数据源，覆盖全球主要地震监测机构：
-- **中国地震网地震预警 (FAN Studio / Wolfx)** - 实时地震预警信息。
-- **台湾中央气象署强震即时警报 (FAN Studio / Wolfx)** - 台湾地区地震预警。
-- **日本气象厅紧急地震速报 (P2P / Wolfx / FAN Studio)** - 日本紧急地震速报。
-- **中国地震台网地震测定 (FAN Studio / Wolfx)** - 正式地震测定信息。
-- **日本气象厅地震情报 (P2P / Wolfx)** - 详细地震情报。
-- **USGS地震测定 (FAN Studio)** - 美国地质调查局地震信息。
-- **Global Quake服务器** - 全球地震测站实时计算推送，精度有限。
-- **中国气象局气象预警 (FAN Studio)** - 气象灾害预警。
-- **自然资源部海啸预警中心 (FAN Studio)** - 海啸预警信息。
-- **日本气象厅海啸预报 (P2P)** - 日本海啸预报信息。
-
-### 🎯 智能推送控制
-- **阈值过滤** - 根据震级、烈度、震度设置推送阈值。
-- **频率控制** - 智能推送逻辑，避免短时间内刷屏。
-- **首报推送保证** - 确保预警信息首次下达时总是推送。
-- **最终报保证** - 确保最终报总是推送。
-
-### 🔁 事件去重功能
-插件具备基础的事件去重功能，防止同一地震被同一个数据源重复推送。
-
-## 🚀 安装与使用
-
-### 安装
-
-```bash
-npm install koishi-plugin-disaster-warning
-```
-
-或者在 Koishi 插件市场搜索 `disaster-warning` 安装。
-
-### 配置
-
-安装完成后，在 Koishi 控制台的「插件配置」页面进行配置：
-
-1. **启用插件**：确保 `enabled` 为 `true`。
-2. **目标群组**：在 `target_groups` 中添加需要推送预警消息的群号。
-3. **数据源配置**：在 `data_sources` 中按需启用或禁用各个数据源。
-4. **过滤器配置**：在 `earthquake_filters` 中设置震级和烈度阈值，避免过多打扰。
-
-## 📋 使用命令
-
-插件提供以下指令：
-
-- `disaster` - 查看插件帮助信息
-- `disaster.test` - 发送一条测试预警消息，用于验证配置是否生效
-- `disaster.history` - 查看最近的地震记录 (数据来源：CENC)
-
-## 📄 许可证
-
-本项目采用 [AGPL-3.0](./LICENSE) 许可证。
+# koishi-plugin-disaster-warning
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-disaster-warning?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-disaster-warning)
+
+Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）实时推送。
+本插件移植自 [astrbot_plugin_disaster_warning](https://github.com/DBJD-CR/astrbot_plugin_disaster_warning)，感谢原作者的开源贡献。
+
+## ✨ 功能特性
+
+### 🌍 多数据源支持
+插件支持多个可自由选择启用的细粒度数据源，覆盖全球主要地震监测机构：
+- **中国地震网地震预警 (FAN Studio / Wolfx)** - 实时地震预警信息。
+- **台湾中央气象署强震即时警报 (FAN Studio / Wolfx)** - 台湾地区地震预警。
+- **日本气象厅紧急地震速报 (P2P / Wolfx / FAN Studio)** - 日本紧急地震速报。
+- **中国地震台网地震测定 (FAN Studio / Wolfx)** - 正式地震测定信息。
+- **日本气象厅地震情报 (P2P / Wolfx)** - 详细地震情报。
+- **USGS地震测定 (FAN Studio)** - 美国地质调查局地震信息。
+- **Global Quake服务器** - 全球地震测站实时计算推送，精度有限。
+- **中国气象局气象预警 (FAN Studio)** - 气象灾害预警。
+- **自然资源部海啸预警中心 (FAN Studio)** - 海啸预警信息。
+- **日本气象厅海啸预报 (P2P)** - 日本海啸预报信息。
+
+### 🎯 智能推送控制
+- **阈值过滤** - 根据震级、烈度、震度设置推送阈值。
+- **频率控制** - 智能推送逻辑，避免短时间内刷屏。
+- **首报推送保证** - 确保预警信息首次下达时总是推送。
+- **震中地区过滤** - 地震类事件会按震中地名与经纬度过滤，关闭全球地区后，CENC 等数据源发布的海外地震不会再误推送。
+- **最终报保证** - 确保最终报总是推送。
+
+### 🔁 事件去重功能
+插件具备基础的事件去重功能，防止同一地震被同一个数据源重复推送。
+
+### 🤖 ChatLuna 工具调用
+可选注册 `disaster_warning` 工具给 ChatLuna 使用，让模型主动查询近期地震、按地点/震级/时间过滤，或查看数据源连接状态。适合回答“哪里地震了”“某地最近有没有地震”“我关心的人在某地，那里安全吗”等问题。
+
+## 🚀 安装与使用
+
+### 安装
+
+```bash
+npm install koishi-plugin-disaster-warning
+```
+
+或者在 Koishi 插件市场搜索 `disaster-warning` 安装。
+
+### 配置
+
+安装完成后，在 Koishi 控制台的「插件配置」页面进行配置：
+
+1. **启用插件**：确保 `enabled` 为 `true`。
+2. **目标群组**：在 `target_groups` 中添加需要推送预警消息的群号。
+3. **灾害类型**：在 `data_types` 中选择是否接收地震预警、地震信息、海啸预警、气象预警。
+4. **接收地区**：在 `regions` 中选择中国大陆、台湾、日本或全球。数据源连接会依据此项自动开启，地震类事件还会按震中位置再次过滤。
+5. **过滤器配置**：在 `filter` 中设置震级、烈度、震度阈值，避免过多打扰。
+
+### 地区过滤说明
+
+`regions` 同时控制数据源连接与地震震中地区过滤。例如仅开启中国大陆和台湾、关闭日本与全球时，插件仍可连接 CENC/CWA 等相关数据源，但智利、印尼等不在已开启地区内的地震会被丢弃，不会因为由 CENC 发布就被推送。
+
+当前震中识别优先使用地名关键词，其次使用经纬度范围；无法识别且带有非空地名的地震默认视为全球事件。
+
+### ChatLuna 工具设置
+
+如果安装了 `koishi-plugin-chatluna`，可以在 `chatluna` 配置项中开启工具注册：
+
+- `chatluna.enabled`：开启后注册 ChatLuna 工具，默认关闭。
+- `chatluna.name`：工具名称，默认 `disaster_warning`。
+- `chatluna.default_source`：模型未指定来源时查询 `all`、`cenc`、`jma` 或 `usgs`。
+- `chatluna.default_days`：默认查询最近多少天。
+- `chatluna.default_limit`：默认最多返回多少条记录。
+- `chatluna.min_magnitude`：默认最低震级。
+- `chatluna.include_usgs_when_all`：综合查询时是否包含 USGS 全球地震。
+
+工具输入示例：
+
+```json
+{
+  "action": "recent_earthquakes",
+  "location": "智利",
+  "min_magnitude": 5,
+  "days": 7,
+  "limit": 5
+}
+```
+
+也可以使用 `{ "action": "status" }` 查询当前数据源连接状态。
+
+## 📋 使用命令
+
+插件提供以下指令：
+
+- `disaster` - 查看插件帮助信息
+- `disaster.test` - 发送一条测试预警消息，用于验证配置是否生效
+- `disaster.history` - 查看最近的地震记录 (数据来源：CENC)
+
+## 📄 许可证
+
+本项目采用 [AGPL-3.0](./LICENSE) 许可证。

package/lib/chatluna.d.ts

@@ -0,0 +1,41 @@
+import { Context } from 'koishi';
+import { StructuredTool } from '@langchain/core/tools';
+import type { Config } from './index';
+import { DisasterWarningService } from './service';
+type ToolSource = 'all' | 'cenc' | 'jma' | 'usgs';
+type ToolInput = {
+    action?: 'recent_earthquakes' | 'status';
+    source?: ToolSource;
+    location?: string;
+    min_magnitude?: number;
+    days?: number;
+    limit?: number;
+};
+interface ChatLunaToolConfig {
+    enabled: boolean;
+    name: string;
+    description: string;
+    default_source: ToolSource;
+    default_limit: number;
+    default_days: number;
+    min_magnitude: number;
+    include_usgs_when_all: boolean;
+}
+export declare class DisasterWarningTool extends StructuredTool<any, ToolInput, ToolInput, string> {
+    private ctx;
+    private config;
+    private service;
+    name: string;
+    description: string;
+    schema: any;
+    constructor(ctx: Context, config: Config, service: DisasterWarningService);
+    _call(input: ToolInput): Promise<string>;
+    private formatStatus;
+    private queryRecentEarthquakes;
+    private fetchSource;
+    private fetchWolfxList;
+    private fetchUsgs;
+}
+export declare function applyChatLunaTools(ctx: Context, config: Config, service: DisasterWarningService): void;
+export declare function getChatLunaConfig(config: Config): ChatLunaToolConfig;
+export {};

package/lib/chatluna.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisasterWarningTool = void 0;
+exports.applyChatLunaTools = applyChatLunaTools;
+exports.getChatLunaConfig = getChatLunaConfig;
+const koishi_1 = require("koishi");
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const logger = new koishi_1.Logger('disaster-chatluna');
+const sourceSchema = zod_1.z.enum(['all', 'cenc', 'jma', 'usgs']);
+const actionSchema = zod_1.z.enum(['recent_earthquakes', 'status']);
+const toolSchema = zod_1.z.object({
+    action: actionSchema.optional().describe('操作类型：recent_earthquakes 查询近期地震，status 查询数据源连接状态。默认 recent_earthquakes。'),
+    source: sourceSchema.optional().describe('数据源：all 综合查询，cenc 中国地震台网列表，jma 日本气象厅列表，usgs USGS 全球地震。默认使用插件配置。'),
+    location: zod_1.z.string().optional().describe('可选，地点关键词、国家、地区或城市，例如“四川”“台湾”“日本”“智利”“Chile”。'),
+    min_magnitude: zod_1.z.number().min(0).max(10).optional().describe('可选，最低震级，默认使用插件配置。'),
+    days: zod_1.z.number().int().min(1).max(30).optional().describe('可选，查询最近多少天，默认使用插件配置，最多 30 天。'),
+    limit: zod_1.z.number().int().min(1).max(50).optional().describe('可选，最多返回多少条地震记录，默认使用插件配置。')
+});
+const DEFAULT_CHATLUNA_CONFIG = {
+    enabled: false,
+    name: 'disaster_warning',
+    description: '查询近期地震和灾害预警数据源状态，可按地点、震级、时间范围过滤。适合回答“哪里地震了”“某地最近有没有地震”“关心的人所在地区是否有地震”等问题。',
+    default_source: 'all',
+    default_limit: 8,
+    default_days: 7,
+    min_magnitude: 4,
+    include_usgs_when_all: true
+};
+class DisasterWarningTool extends tools_1.StructuredTool {
+    constructor(ctx, config, service) {
+        super({});
+        this.ctx = ctx;
+        this.config = config;
+        this.service = service;
+        this.schema = toolSchema;
+        const cfg = getChatLunaConfig(config);
+        this.name = normalizeToolName(cfg.name);
+        this.description = cfg.description.trim() || DEFAULT_CHATLUNA_CONFIG.description;
+    }
+    async _call(input) {
+        const action = input.action || 'recent_earthquakes';
+        try {
+            if (action === 'status') {
+                return JSON.stringify(this.formatStatus(), null, 2);
+            }
+            const cfg = getChatLunaConfig(this.config);
+            const options = {
+                source: input.source || cfg.default_source,
+                location: input.location?.trim() || undefined,
+                minMagnitude: input.min_magnitude ?? cfg.min_magnitude,
+                days: clamp(input.days ?? cfg.default_days, 1, 30),
+                limit: clamp(input.limit ?? cfg.default_limit, 1, 50)
+            };
+            const result = await this.queryRecentEarthquakes(options);
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.warn(`ChatLuna tool call failed: ${message}`);
+            return `灾害预警查询失败：${message}`;
+        }
+    }
+    formatStatus() {
+        const status = this.service.getStatus();
+        return {
+            type: 'disaster_warning_status',
+            generated_at: new Date().toISOString(),
+            sources: Object.entries(status).map(([name, item]) => ({
+                name,
+                connected: item.connected,
+                retry_count: item.retryCount,
+                url: item.url
+            }))
+        };
+    }
+    async queryRecentEarthquakes(options) {
+        const cfg = getChatLunaConfig(this.config);
+        const sources = expandSources(options.source, cfg.include_usgs_when_all);
+        const settled = await Promise.allSettled(sources.map((source) => this.fetchSource(source, options)));
+        const errors = [];
+        const records = [];
+        settled.forEach((item, index) => {
+            const source = sources[index];
+            if (item.status === 'fulfilled') {
+                records.push(...item.value);
+            }
+            else {
+                const message = item.reason instanceof Error ? item.reason.message : String(item.reason);
+                errors.push({ source, message });
+            }
+        });
+        const terms = buildSearchTerms(options.location);
+        const filtered = records
+            .filter((record) => record.magnitude === undefined || record.magnitude >= options.minMagnitude)
+            .filter((record) => isWithinDays(record.time, options.days))
+            .filter((record) => matchesLocation(record, terms))
+            .sort((a, b) => timeValue(b.time) - timeValue(a.time))
+            .slice(0, options.limit);
+        return compact({
+            type: 'recent_earthquakes',
+            generated_at: new Date().toISOString(),
+            query: {
+                source: options.source,
+                expanded_sources: sources,
+                location: options.location,
+                min_magnitude: options.minMagnitude,
+                days: options.days,
+                limit: options.limit
+            },
+            count: filtered.length,
+            earthquakes: filtered,
+            errors: errors.length ? errors : undefined,
+            note: '地震查询工具用于对话查询，不会改变群推送过滤配置。regions.global 关闭时仍可通过工具主动查询全球地震。'
+        });
+    }
+    fetchSource(source, options) {
+        if (source === 'cenc')
+            return this.fetchWolfxList('cenc');
+        if (source === 'jma')
+            return this.fetchWolfxList('jma');
+        if (source === 'usgs')
+            return this.fetchUsgs(options);
+        return Promise.resolve([]);
+    }
+    async fetchWolfxList(type) {
+        const cache = this.service.getEqListCache();
+        let data = cache[type];
+        if (!data || Object.keys(data).length === 0) {
+            const url = type === 'cenc'
+                ? 'https://api.wolfx.jp/cenc_eqlist.json'
+                : 'https://api.wolfx.jp/jma_eqlist.json';
+            data = await this.ctx.http.get(url);
+        }
+        const keys = Object.keys(data || {})
+            .filter((key) => /^No\d+$/.test(key))
+            .sort((a, b) => Number(a.slice(2)) - Number(b.slice(2)));
+        return keys
+            .map((key) => parseWolfxRecord(type, data[key]))
+            .filter((record) => Boolean(record));
+    }
+    async fetchUsgs(options) {
+        const url = new URL('https://earthquake.usgs.gov/fdsnws/event/1/query');
+        url.searchParams.set('format', 'geojson');
+        url.searchParams.set('orderby', 'time');
+        url.searchParams.set('starttime', new Date(Date.now() - options.days * 86400000).toISOString());
+        url.searchParams.set('minmagnitude', String(options.minMagnitude));
+        url.searchParams.set('limit', String(Math.min(Math.max(options.limit * 5, 50), 200)));
+        const data = await this.ctx.http.get(url.toString());
+        const features = Array.isArray(data?.features) ? data.features : [];
+        return features.map(parseUsgsFeature).filter((record) => Boolean(record));
+    }
+}
+exports.DisasterWarningTool = DisasterWarningTool;
+function applyChatLunaTools(ctx, config, service) {
+    ctx.on('ready', () => {
+        const cfg = getChatLunaConfig(config);
+        if (!cfg.enabled)
+            return;
+        const chatluna = ctx.chatluna;
+        if (!chatluna?.platform?.registerTool) {
+            logger.warn('未检测到 ChatLuna 服务，跳过注册灾害预警工具。');
+            return;
+        }
+        const toolName = normalizeToolName(cfg.name);
+        ctx.effect(() => chatluna.platform.registerTool(toolName, {
+            description: cfg.description.trim() || DEFAULT_CHATLUNA_CONFIG.description,
+            selector() {
+                return true;
+            },
+            createTool() {
+                return new DisasterWarningTool(ctx, config, service);
+            },
+            meta: {
+                source: 'extension',
+                group: 'disaster-warning',
+                tags: ['disaster', 'earthquake', 'warning'],
+                defaultAvailability: {
+                    enabled: true,
+                    main: true,
+                    chatluna: true,
+                    characterScope: 'all'
+                }
+            }
+        }));
+        logger.info(`已注册 ChatLuna 灾害预警工具：${toolName}`);
+    });
+}
+function getChatLunaConfig(config) {
+    return {
+        ...DEFAULT_CHATLUNA_CONFIG,
+        ...(config.chatluna || {})
+    };
+}
+function normalizeToolName(name) {
+    const normalized = (name || DEFAULT_CHATLUNA_CONFIG.name).trim();
+    return normalized || DEFAULT_CHATLUNA_CONFIG.name;
+}
+function expandSources(source, includeUsgsWhenAll) {
+    if (source !== 'all')
+        return [source];
+    return includeUsgsWhenAll ? ['cenc', 'jma', 'usgs'] : ['cenc', 'jma'];
+}
+function parseWolfxRecord(type, item) {
+    if (!item || typeof item !== 'object')
+        return null;
+    const magnitude = toNumber(item.magnitude);
+    return compact({
+        source: type,
+        source_name: type === 'cenc' ? 'CENC 中国地震台网' : 'JMA 日本气象厅',
+        id: item.md5 || item.id,
+        time: normalizeTime(item.time),
+        location: item.location || item.hypocenter || '',
+        magnitude,
+        depth_km: parseDepth(item.depth),
+        intensity: item.intensity ? String(item.intensity) : undefined,
+        scale: item.shindo ? String(item.shindo) : undefined,
+        latitude: toNumber(item.latitude),
+        longitude: toNumber(item.longitude)
+    });
+}
+function parseUsgsFeature(feature) {
+    const props = feature?.properties || {};
+    const coordinates = feature?.geometry?.coordinates || [];
+    if (!props.place && props.mag === undefined)
+        return null;
+    return compact({
+        source: 'usgs',
+        source_name: 'USGS',
+        id: feature.id,
+        time: props.time ? new Date(props.time).toISOString() : undefined,
+        location: props.place || '',
+        magnitude: toNumber(props.mag),
+        depth_km: toNumber(coordinates[2]),
+        latitude: toNumber(coordinates[1]),
+        longitude: toNumber(coordinates[0]),
+        url: props.url
+    });
+}
+function normalizeTime(value) {
+    if (!value)
+        return undefined;
+    const text = String(value).trim();
+    const date = new Date(text.replace(/\//g, '-'));
+    if (!Number.isFinite(date.getTime()))
+        return text;
+    return date.toISOString();
+}
+function parseDepth(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const match = String(value).match(/-?\d+(?:\.\d+)?/);
+    return match ? Number(match[0]) : undefined;
+}
+function toNumber(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const num = Number(value);
+    return Number.isFinite(num) ? num : undefined;
+}
+function isWithinDays(time, days) {
+    const value = timeValue(time);
+    if (!value)
+        return true;
+    return value >= Date.now() - days * 86400000;
+}
+function timeValue(time) {
+    if (!time)
+        return 0;
+    const value = new Date(time).getTime();
+    return Number.isFinite(value) ? value : 0;
+}
+function matchesLocation(record, terms) {
+    if (!terms.length)
+        return true;
+    const haystack = normalizeText([
+        record.location,
+        record.source_name,
+        record.latitude,
+        record.longitude
+    ].filter((item) => item !== undefined).join(' '));
+    return terms.some((term) => haystack.includes(term));
+}
+function buildSearchTerms(location) {
+    if (!location)
+        return [];
+    const base = normalizeText(location);
+    const aliases = {
+        '智利': ['chile'],
+        '印尼': ['indonesia'],
+        '印度尼西亚': ['indonesia'],
+        '菲律宾': ['philippines'],
+        '秘鲁': ['peru'],
+        '墨西哥': ['mexico'],
+        '阿根廷': ['argentina'],
+        '土耳其': ['turkey'],
+        '希腊': ['greece'],
+        '俄罗斯': ['russia'],
+        '美国': ['unitedstates', 'usa'],
+        '阿拉斯加': ['alaska'],
+        '加州': ['california'],
+        '新西兰': ['newzealand'],
+        '巴布亚': ['papua'],
+        '汤加': ['tonga'],
+        '斐济': ['fiji'],
+        '瓦努阿图': ['vanuatu'],
+        '日本': ['japan'],
+        '台湾': ['taiwan', '臺灣', '台灣'],
+        '中国': ['china'],
+        '四川': ['sichuan'],
+        '云南': ['yunnan'],
+        '西藏': ['tibet', 'xizang'],
+        '新疆': ['xinjiang'],
+        '青海': ['qinghai'],
+        '甘肃': ['gansu']
+    };
+    const terms = new Set([base]);
+    for (const [key, values] of Object.entries(aliases)) {
+        if (base.includes(normalizeText(key))) {
+            values.forEach((value) => terms.add(normalizeText(value)));
+        }
+    }
+    return Array.from(terms).filter(Boolean);
+}
+function normalizeText(value) {
+    return String(value ?? '').toLowerCase().replace(/[\s,，、()（）-]/g, '');
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function compact(value) {
+    if (Array.isArray(value))
+        return value.map((item) => compact(item));
+    if (!value || typeof value !== 'object')
+        return value;
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item === undefined || item === null || item === '')
+            continue;
+        const next = compact(item);
+        if (Array.isArray(next) && next.length === 0)
+            continue;
+        out[key] = next;
+    }
+    return out;
+}

package/lib/index.d.ts

@@ -24,6 +24,16 @@ export interface Config {
         min_intensity_for_push: number;
         min_scale_for_push: number;
     };
+    chatluna: {
+        enabled: boolean;
+        name: string;
+        description: string;
+        default_source: 'all' | 'cenc' | 'jma' | 'usgs';
+        default_limit: number;
+        default_days: number;
+        min_magnitude: number;
+        include_usgs_when_all: boolean;
+    };
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -5,10 +5,11 @@ exports.apply = apply;
 const koishi_1 = require("koishi");
 const service_1 = require("./service");
 const commands_1 = require("./commands");
+const chatluna_1 = require("./chatluna");
 exports.name = 'disaster-warning';
 exports.inject = {
     required: ['http'],
-    optional: ['database']
+    optional: ['database', 'chatluna']
 };
 exports.Config = koishi_1.Schema.object({
     target_groups: koishi_1.Schema.array(koishi_1.Schema.string())
@@ -25,17 +26,33 @@ exports.Config = koishi_1.Schema.object({
         taiwan: koishi_1.Schema.boolean().default(true).description('台湾（CWA预警与地震报告）'),
         japan: koishi_1.Schema.boolean().default(true).description('日本（JMA EEW / P2P地震情报 / 海啸）'),
         global: koishi_1.Schema.boolean().default(false).description('全球（USGS 地震信息 / GlobalQuake 实时预警）'),
-    }).description('接收的地区（数据源连接将依据此项自动开启）'),
+    }).description('接收的地区（数据源连接将依据此项自动开启，地震类事件会按震中位置过滤）'),
     filter: koishi_1.Schema.object({
         min_magnitude_absolute: koishi_1.Schema.number().default(3.0).description('绝对过滤震级：低于此震级直接丢弃（不推送）'),
         min_magnitude_for_push: koishi_1.Schema.number().default(4.0).description('推送震级门槛：震级达到此值则推送'),
         min_intensity_for_push: koishi_1.Schema.number().default(4.0).description('推送烈度门槛（中国）：最大烈度达到此值则推送'),
         min_scale_for_push: koishi_1.Schema.number().default(4.0).description('推送震度门槛（日本）：最大震度达到此值则推送（4 = 震度4）'),
     }).description('过滤阈值（地震类事件，海啸/气象不受此限制）'),
+    chatluna: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().default(false).description('开启后注册 ChatLuna 工具，供模型主动查询近期地震与数据源状态'),
+        name: koishi_1.Schema.string().default('disaster_warning').description('ChatLuna 工具名称'),
+        description: koishi_1.Schema.string().default('查询近期地震和灾害预警数据源状态，可按地点、震级、时间范围过滤。适合回答“哪里地震了”“某地最近有没有地震”“关心的人所在地区是否有地震”等问题。').description('ChatLuna 工具描述'),
+        default_source: koishi_1.Schema.union([
+            koishi_1.Schema.const('all').description('综合 CENC / JMA / USGS'),
+            koishi_1.Schema.const('cenc').description('中国地震台网 / Wolfx CENC'),
+            koishi_1.Schema.const('jma').description('日本气象厅 / Wolfx JMA'),
+            koishi_1.Schema.const('usgs').description('USGS 全球地震')
+        ]).default('all').description('模型未指定数据源时的默认查询源'),
+        default_limit: koishi_1.Schema.number().default(8).min(1).max(50).description('模型未指定 limit 时最多返回多少条'),
+        default_days: koishi_1.Schema.number().default(7).min(1).max(30).description('模型未指定 days 时查询最近多少天'),
+        min_magnitude: koishi_1.Schema.number().default(4.0).min(0).max(10).description('模型未指定 min_magnitude 时的最低震级'),
+        include_usgs_when_all: koishi_1.Schema.boolean().default(true).description('default_source/all 查询时是否包含 USGS 全球地震')
+    }).description('ChatLuna 工具调用'),
 });
 function apply(ctx, config) {
     const service = new service_1.DisasterWarningService(ctx, config);
     ctx.on('ready', () => service.start());
     ctx.on('dispose', () => service.stop());
     (0, commands_1.applyCommands)(ctx, config, service);
+    (0, chatluna_1.applyChatLunaTools)(ctx, config, service);
 }

package/lib/service.d.ts

@@ -19,6 +19,20 @@ export declare class DisasterWarningService {
     private startWolfxHttpPoller;
     private handleEvent;
     private shouldPushEvent;
+    private shouldPushEarthquakeByLocation;
+    private detectEarthquakeRegion;
+    private detectRegionByPlace;
+    private includesAny;
+    private validLatitude;
+    private validLongitude;
+    private isTaiwanCoordinate;
+    private isJapanCoordinate;
+    private isMainlandChinaCoordinate;
+    private pointInPolygon;
+    private fallbackRegionForMissingCoordinates;
+    private shouldAllowUnknownEarthquakeRegion;
+    private fallbackRegionBySource;
+    private isRegionEnabled;
     getStatus(): Record<string, {
         connected: boolean;
         retryCount: number;

package/lib/service.js

@@ -210,8 +210,192 @@ class DisasterWarningService {
             return false;
         if (globalSources.includes(src) && !regions.global)
             return false;
+        if ((isEarthquakeWarning || isEarthquakeInfo) && !this.shouldPushEarthquakeByLocation(event)) {
+            const data = event.data;
+            logger.debug(`[region] Skipping earthquake outside enabled regions: ${data.place_name || event.id}`);
+            return false;
+        }
         return true;
     }
+    shouldPushEarthquakeByLocation(event) {
+        const region = this.detectEarthquakeRegion(event.data, event.source);
+        switch (region) {
+            case 'china':
+                return this.config.regions.china;
+            case 'taiwan':
+                return this.config.regions.taiwan;
+            case 'japan':
+                return this.config.regions.japan;
+            case 'global':
+                return this.config.regions.global;
+            case 'unknown':
+                return this.shouldAllowUnknownEarthquakeRegion(event.source);
+        }
+    }
+    detectEarthquakeRegion(data, source) {
+        const place = data.place_name?.replace(/\s+/g, '').toLowerCase() || '';
+        const placeRegion = this.detectRegionByPlace(place);
+        if (placeRegion)
+            return placeRegion;
+        const lat = this.validLatitude(data.latitude);
+        const lon = this.validLongitude(data.longitude);
+        if (lat === undefined || lon === undefined)
+            return this.fallbackRegionForMissingCoordinates(data, source, place);
+        // Many upstream cancellation packets use 0,0 when coordinates are unavailable.
+        if (lat === 0 && lon === 0)
+            return this.fallbackRegionForMissingCoordinates(data, source, place);
+        if (this.isTaiwanCoordinate(lat, lon))
+            return 'taiwan';
+        if (this.isJapanCoordinate(lat, lon))
+            return 'japan';
+        if (this.isMainlandChinaCoordinate(lat, lon))
+            return 'china';
+        return 'global';
+    }
+    detectRegionByPlace(place) {
+        if (!place)
+            return null;
+        if (this.includesAny(place, [
+            '台湾', '臺灣', '台灣', 'taiwan', '花莲', '花蓮', '宜兰', '宜蘭', '台东', '臺東', '台東',
+            '台北', '臺北', '新北', '桃园', '桃園', '台中', '臺中', '台南', '臺南', '高雄', '嘉义', '嘉義',
+            '屏东', '屏東', '南投', '澎湖'
+        ]))
+            return 'taiwan';
+        if (this.includesAny(place, [
+            '日本', 'japan', '北海道', '本州', '四国', '四國', '九州', '沖縄', '冲绳', '琉球', '小笠原',
+            '伊豆', '鳥島', '鸟岛', '青森', '岩手', '宮城', '宫城', '秋田', '山形', '福島', '福岛',
+            '茨城', '栃木', '群馬', '群马', '埼玉', '千葉', '千叶', '東京', '东京', '神奈川', '新潟',
+            '富山', '石川', '福井', '山梨', '長野', '长野', '岐阜', '静岡', '静冈', '愛知', '爱知',
+            '三重', '滋賀', '滋贺', '京都', '大阪', '兵庫', '兵库', '奈良', '和歌山', '鳥取', '鸟取',
+            '島根', '岛根', '岡山', '冈山', '広島', '广岛', '山口', '徳島', '德岛', '香川', '愛媛',
+            '爱媛', '高知', '福岡', '福冈', '佐賀', '佐贺', '長崎', '长崎', '熊本', '大分', '宮崎',
+            '宫崎', '鹿児島', '鹿儿岛'
+        ]))
+            return 'japan';
+        if (this.includesAny(place, [
+            '中国', 'china', '北京', '天津', '河北', '山西', '内蒙古', '辽宁', '遼寧', '吉林', '黑龙江',
+            '黑龍江', '上海', '江苏', '江蘇', '浙江', '安徽', '福建', '江西', '山东', '山東', '河南',
+            '湖北', '湖南', '广东', '廣東', '广西', '廣西', '海南', '重庆', '重慶', '四川', '贵州',
+            '貴州', '云南', '雲南', '西藏', '陕西', '陝西', '甘肃', '甘肅', '青海', '宁夏', '寧夏',
+            '新疆', '香港', '澳门', '澳門'
+        ]))
+            return 'china';
+        return null;
+    }
+    includesAny(text, keywords) {
+        return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+    }
+    validLatitude(value) {
+        return Number.isFinite(value) && value >= -90 && value <= 90 ? value : undefined;
+    }
+    validLongitude(value) {
+        return Number.isFinite(value) && value >= -180 && value <= 180 ? value : undefined;
+    }
+    isTaiwanCoordinate(lat, lon) {
+        return lat >= 21.5 && lat <= 26.5 && lon >= 119 && lon <= 123.8;
+    }
+    isJapanCoordinate(lat, lon) {
+        const mainIslands = lat >= 30 && lat <= 46.5 && lon >= 129 && lon <= 146.5;
+        const ryukyu = lat >= 24 && lat < 30 && lon >= 122 && lon <= 131.5;
+        const izuOgasawara = lat >= 20 && lat <= 34 && lon >= 139 && lon <= 154.5;
+        return mainIslands || ryukyu || izuOgasawara;
+    }
+    isMainlandChinaCoordinate(lat, lon) {
+        if (lat >= 18 && lat <= 20.5 && lon >= 108 && lon <= 111.5)
+            return true;
+        // Rough mainland China outline. Place-name detection runs first, this is only a coordinate fallback.
+        return this.pointInPolygon(lon, lat, [
+            [73.5, 39.5],
+            [74.9, 37.2],
+            [75.5, 35.4],
+            [78.4, 32.5],
+            [78.7, 30.2],
+            [80.5, 30.0],
+            [81.8, 28.5],
+            [85.2, 28.3],
+            [88.9, 27.3],
+            [91.0, 27.8],
+            [93.3, 28.7],
+            [95.5, 28.2],
+            [97.3, 23.8],
+            [98.9, 24.1],
+            [100.1, 21.4],
+            [101.8, 21.2],
+            [103.8, 22.5],
+            [106.8, 20.0],
+            [108.7, 18.2],
+            [111.3, 18.0],
+            [113.7, 21.8],
+            [116.7, 22.7],
+            [118.5, 24.5],
+            [121.8, 29.0],
+            [122.2, 31.8],
+            [121.5, 35.0],
+            [124.0, 39.8],
+            [126.8, 41.9],
+            [130.0, 42.3],
+            [134.7, 48.2],
+            [131.0, 47.7],
+            [128.0, 49.6],
+            [123.3, 53.5],
+            [119.5, 50.0],
+            [117.0, 49.6],
+            [111.0, 49.2],
+            [105.0, 45.0],
+            [97.0, 42.8],
+            [91.0, 45.2],
+            [87.0, 49.0],
+            [82.0, 47.2],
+            [79.0, 43.0],
+        ]);
+    }
+    pointInPolygon(lon, lat, polygon) {
+        let inside = false;
+        for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+            const xi = polygon[i][0];
+            const yi = polygon[i][1];
+            const xj = polygon[j][0];
+            const yj = polygon[j][1];
+            const intersects = ((yi > lat) !== (yj > lat)) &&
+                (lon < (xj - xi) * (lat - yi) / (yj - yi) + xi);
+            if (intersects)
+                inside = !inside;
+        }
+        return inside;
+    }
+    fallbackRegionForMissingCoordinates(data, source, place) {
+        if (place && !data.is_cancel)
+            return 'global';
+        return this.fallbackRegionBySource(source);
+    }
+    shouldAllowUnknownEarthquakeRegion(source) {
+        const fallback = this.fallbackRegionBySource(source);
+        if (fallback === 'unknown')
+            return this.config.regions.global;
+        return this.isRegionEnabled(fallback);
+    }
+    fallbackRegionBySource(source) {
+        if ([models_1.DataSource.FAN_STUDIO_CEA, models_1.DataSource.FAN_STUDIO_CENC, models_1.DataSource.WOLFX_CENC_EEW, models_1.DataSource.WOLFX_CENC_EQ].includes(source))
+            return 'china';
+        if ([models_1.DataSource.FAN_STUDIO_CWA, models_1.DataSource.WOLFX_CWA_EEW].includes(source))
+            return 'taiwan';
+        if ([models_1.DataSource.FAN_STUDIO_JMA, models_1.DataSource.P2P_EEW, models_1.DataSource.P2P_EARTHQUAKE, models_1.DataSource.WOLFX_JMA_EEW, models_1.DataSource.WOLFX_JMA_EQ].includes(source))
+            return 'japan';
+        if ([models_1.DataSource.FAN_STUDIO_USGS, models_1.DataSource.GLOBAL_QUAKE].includes(source))
+            return 'global';
+        return 'unknown';
+    }
+    isRegionEnabled(region) {
+        if (region === 'china')
+            return this.config.regions.china;
+        if (region === 'taiwan')
+            return this.config.regions.taiwan;
+        if (region === 'japan')
+            return this.config.regions.japan;
+        if (region === 'global')
+            return this.config.regions.global;
+        return false;
+    }
     // ---- 状态查询（供 commands 使用）------------------------------------
     getStatus() {
         const result = {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koishi-plugin-disaster-warning",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "description": "Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）",
     "contributors": [
         "lumia.wang <fenglian19980510@gmail.com>"
@@ -27,19 +27,20 @@
         "chatbot",
         "koishi",
         "plugin",
+        "chatluna",
         "disaster",
         "earthquake",
         "warning"
     ],
     "peerDependencies": {
-        "koishi": "^4.18.0"
+        "koishi": "^4.18.0",
+        "koishi-plugin-chatluna": "^1.3.0 || ^1.4.0-alpha.0"
     },
     "devDependencies": {
         "@types/node": "^20.0.0",
         "@types/ws": "^8.5.10",
         "koishi": "^4.18.0",
-        "typescript": "^5.0.0",
-        "ws": "^8.18.0"
+        "typescript": "^5.0.0"
     },
     "koishi": {
         "description": {
@@ -51,8 +52,19 @@
                 "http"
             ],
             "optional": [
-                "database"
+                "database",
+                "chatluna"
             ]
         }
+    },
+    "dependencies": {
+        "@langchain/core": "^0.3.80",
+        "ws": "^8.18.0",
+        "zod": "^3.25.76"
+    },
+    "peerDependenciesMeta": {
+        "koishi-plugin-chatluna": {
+            "optional": true
+        }
     }
 }