@cicctencent/agent-midway 0.1.1

package/dist/tools/http-request.tool.js

@@ -0,0 +1,455 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUrlTool = exports.httpRequestTool = void 0;
+/**
+ * HTTP 请求工具
+ *
+ * 让 Agent 能够发起任意 HTTP(S) 请求，对接外部 API、Webhook、数据接口等。
+ *
+ * 工具说明：
+ * - http_request：发起通用 HTTP 请求（GET/POST/PUT/DELETE/PATCH）
+ * - parse_url：解析 URL 结构与查询参数
+ *
+ * 特性：
+ * - 支持 HTTP / HTTPS，可选忽略 TLS 证书异常（自签名证书场景）
+ * - 支持 JSON / Form / Raw / Query String 多种请求体格式
+ * - 支持 Basic Auth / Bearer Token / 自定义 Header
+ * - 超时控制（默认 15s，最大 60s）
+ * - 响应体自动截断（防止超大响应撑爆上下文）
+ *
+ * 安全机制：
+ * - 默认禁止请求内网地址（127.0.0.1、10.x、192.168.x、172.16-31.x）
+ * - 可通过环境变量 HTTP_REQUEST_ALLOW_INTERNAL=true 放开
+ */
+const axios_1 = __importDefault(require("axios"));
+const https = __importStar(require("https"));
+const url_1 = require("url");
+/** 内网 IP 正则检测 */
+const PRIVATE_IP_RE = /^(127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|0\.0\.0\.0|localhost|::1|\[::1\])/i;
+/** 校验 URL 是否安全（非内网） */
+function isUrlSafe(url) {
+    if (process.env.HTTP_REQUEST_ALLOW_INTERNAL === 'true')
+        return true;
+    try {
+        const parsed = new url_1.URL(url);
+        const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
+        return !PRIVATE_IP_RE.test(hostname);
+    }
+    catch {
+        return false;
+    }
+}
+/** 构建 axios 请求配置 */
+function buildAxiosConfig(input) {
+    const config = {
+        url: input.url,
+        method: (input.method || 'GET'),
+        timeout: Math.min(Math.max(Number(input.timeout) || 15000, 1000), 60000),
+        validateStatus: () => true, // 不抛出 HTTP 错误，让 Agent 自行判断
+        maxRedirects: 5,
+    };
+    // HTTPS 配置：忽略证书异常
+    if (input.ignoreTlsErrors) {
+        config.httpsAgent = new https.Agent({ rejectUnauthorized: false });
+    }
+    // 请求头
+    config.headers = { ...(input.headers || {}) };
+    if (!config.headers['User-Agent']) {
+        config.headers['User-Agent'] = 'OmniInsight-Agent/1.0';
+    }
+    // 认证
+    if (input.auth) {
+        if (input.auth.type === 'bearer') {
+            config.headers['Authorization'] = `Bearer ${input.auth.token}`;
+        }
+        else if (input.auth.type === 'basic') {
+            const encoded = Buffer.from(`${input.auth.username}:${input.auth.password}`).toString('base64');
+            config.headers['Authorization'] = `Basic ${encoded}`;
+        }
+        else if (input.auth.type === 'apikey') {
+            config.headers[input.auth.headerName || 'X-API-Key'] =
+                input.auth.key;
+        }
+    }
+    // 查询参数
+    if (input.queryParams) {
+        config.params = input.queryParams;
+    }
+    // 请求体
+    if (input.body &&
+        ['POST', 'PUT', 'PATCH', 'DELETE'].includes(config.method)) {
+        const bodyType = input.bodyType || 'json';
+        switch (bodyType) {
+            case 'json':
+                config.data =
+                    typeof input.body === 'string'
+                        ? JSON.parse(input.body)
+                        : input.body;
+                if (!config.headers['Content-Type']) {
+                    config.headers['Content-Type'] = 'application/json';
+                }
+                break;
+            case 'form':
+                if (typeof input.body === 'string') {
+                    config.data = new URLSearchParams(input.body).toString();
+                }
+                else {
+                    config.data = new URLSearchParams(input.body).toString();
+                }
+                if (!config.headers['Content-Type']) {
+                    config.headers['Content-Type'] =
+                        'application/x-www-form-urlencoded';
+                }
+                break;
+            case 'raw':
+                config.data = input.body;
+                if (!config.headers['Content-Type']) {
+                    config.headers['Content-Type'] = 'text/plain';
+                }
+                break;
+        }
+    }
+    // 响应类型
+    config.responseType =
+        input.responseType === 'arraybuffer' ? 'arraybuffer' : 'json';
+    return config;
+}
+// ===================== 工具定义 =====================
+/** HTTP 请求工具 */
+exports.httpRequestTool = {
+    id: 'http_request',
+    name: 'HTTP 请求',
+    description: '发起 HTTP/HTTPS 请求访问外部 API 或 Web 资源。支持 GET/POST/PUT/DELETE/PATCH 方法，JSON/Form/Raw 请求体，Bearer/Basic/APIKey 认证，自定义 Header，HTTPS 证书忽略。用于调用 REST API、Webhook、获取远程数据等场景。',
+    category: 'network',
+    parameters: {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: '请求 URL 地址（必须以 http:// 或 https:// 开头）',
+            },
+            method: {
+                type: 'string',
+                description: 'HTTP 方法',
+                enum: [
+                    'GET',
+                    'POST',
+                    'PUT',
+                    'DELETE',
+                    'PATCH',
+                    'HEAD',
+                    'OPTIONS',
+                ],
+                default: 'GET',
+            },
+            headers: {
+                type: 'string',
+                description: '自定义请求头，JSON 对象格式，如 {"Accept": "application/json"}',
+            },
+            queryParams: {
+                type: 'string',
+                description: 'URL 查询参数，JSON 对象格式，如 {"page": "1", "size": "10"}',
+            },
+            body: {
+                type: 'string',
+                description: '请求体内容。JSON 对象字符串、表单键值对或纯文本。',
+            },
+            bodyType: {
+                type: 'string',
+                description: '请求体格式：json（默认）、form（表单）、raw（纯文本）',
+                enum: ['json', 'form', 'raw'],
+                default: 'json',
+            },
+            authType: {
+                type: 'string',
+                description: '认证方式：bearer（Token）、basic（用户名密码）、apikey（自定义头）',
+                enum: ['bearer', 'basic', 'apikey', 'none'],
+                default: 'none',
+            },
+            authToken: {
+                type: 'string',
+                description: '认证凭证。bearer 时为 token，basic 时为 "user:pass"，apikey 时为 key 值',
+            },
+            authHeaderName: {
+                type: 'string',
+                description: 'apikey 认证时的自定义 Header 名称，默认 X-API-Key',
+            },
+            timeout: {
+                type: 'integer',
+                description: '请求超时时间（毫秒），默认 15000，最大 60000',
+                minimum: 1000,
+                maximum: 60000,
+                default: 15000,
+            },
+            ignoreTlsErrors: {
+                type: 'boolean',
+                description: '是否忽略 HTTPS 证书异常（自签名证书场景），默认 false',
+                default: false,
+            },
+            maxResponseLength: {
+                type: 'integer',
+                description: '响应体最大字符数（超出自动截断），默认 8000，最大 50000',
+                minimum: 100,
+                maximum: 50000,
+                default: 8000,
+            },
+        },
+        required: ['url'],
+    },
+    async execute(rawInput) {
+        const input = rawInput;
+        const url = (input.url || '').trim();
+        const method = (input.method || 'GET').toUpperCase();
+        // URL 校验
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            return {
+                url,
+                method,
+                statusCode: 0,
+                statusText: 'Invalid URL',
+                headers: {},
+                data: null,
+                truncated: false,
+                duration: 0,
+                error: '无效的 URL，必须以 http:// 或 https:// 开头',
+            };
+        }
+        // 内网安全检测
+        if (!isUrlSafe(url)) {
+            return {
+                url,
+                method,
+                statusCode: 0,
+                statusText: 'Blocked',
+                headers: {},
+                data: null,
+                truncated: false,
+                duration: 0,
+                error: '禁止请求内网地址。如需放开请设置环境变量 HTTP_REQUEST_ALLOW_INTERNAL=true',
+            };
+        }
+        // 解析嵌套 JSON 字符串参数
+        let headers;
+        let queryParams;
+        let body = input.body;
+        try {
+            headers = input.headers
+                ? typeof input.headers === 'string'
+                    ? JSON.parse(input.headers)
+                    : input.headers
+                : undefined;
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            queryParams = input.queryParams
+                ? typeof input.queryParams === 'string'
+                    ? JSON.parse(input.queryParams)
+                    : input.queryParams
+                : undefined;
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            if (body &&
+                typeof body === 'string' &&
+                (input.bodyType || 'json') === 'json')
+                body = JSON.parse(body);
+        }
+        catch {
+            /* keep as string */
+        }
+        // 构建认证对象
+        let auth;
+        if (input.authType && input.authType !== 'none' && input.authToken) {
+            if (input.authType === 'basic') {
+                const [username, password] = input.authToken.split(':');
+                auth = { type: 'basic', username, password: password || '' };
+            }
+            else if (input.authType === 'apikey') {
+                auth = {
+                    type: 'apikey',
+                    key: input.authToken,
+                    headerName: input.authHeaderName || 'X-API-Key',
+                };
+            }
+            else {
+                auth = { type: 'bearer', token: input.authToken };
+            }
+        }
+        const requestInput = {
+            url,
+            method: method,
+            headers,
+            queryParams,
+            body,
+            bodyType: input.bodyType,
+            auth,
+            timeout: input.timeout,
+            ignoreTlsErrors: input.ignoreTlsErrors,
+            maxResponseLength: input.maxResponseLength,
+        };
+        const startTime = Date.now();
+        try {
+            const config = buildAxiosConfig(requestInput);
+            const response = await axios_1.default.request(config);
+            const duration = Date.now() - startTime;
+            // 提取响应头（只保留常用头，避免噪音）
+            const respHeaders = {};
+            const keepHeaders = [
+                'content-type',
+                'content-length',
+                'x-request-id',
+                'x-ratelimit-remaining',
+                'date',
+            ];
+            for (const key of keepHeaders) {
+                if (response.headers[key])
+                    respHeaders[key] = String(response.headers[key]);
+            }
+            // 处理响应体
+            let respData = response.data;
+            const maxLen = Math.min(Math.max(Number(input.maxResponseLength) || 8000, 100), 50000);
+            let truncated = false;
+            if (typeof respData === 'string') {
+                if (respData.length > maxLen) {
+                    respData = respData.slice(0, maxLen) + '\n...[已截断]';
+                    truncated = true;
+                }
+            }
+            else if (respData && typeof respData === 'object') {
+                const str = JSON.stringify(respData);
+                if (str.length > maxLen) {
+                    respData = str.slice(0, maxLen) + '\n...[已截断]';
+                    truncated = true;
+                }
+            }
+            return {
+                url,
+                method,
+                statusCode: response.status,
+                statusText: response.statusText,
+                headers: respHeaders,
+                data: respData,
+                truncated,
+                duration,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const message = error?.code === 'ECONNREFUSED'
+                ? '连接被拒绝'
+                : error?.code === 'ENOTFOUND'
+                    ? '域名解析失败'
+                    : error?.code === 'ETIMEDOUT'
+                        ? '请求超时'
+                        : error?.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'
+                            ? 'TLS 证书验证失败，请设置 ignoreTlsErrors=true'
+                            : error?.code === 'CERT_HAS_EXPIRED'
+                                ? 'TLS 证书已过期，请设置 ignoreTlsErrors=true'
+                                : error?.response?.data?.message ||
+                                    error?.message ||
+                                    String(error);
+            return {
+                url,
+                method,
+                statusCode: error?.response?.status || 0,
+                statusText: error?.response?.statusText || error?.code || 'Error',
+                headers: {},
+                data: error?.response?.data || null,
+                truncated: false,
+                duration,
+                error: `请求失败: ${message}`,
+            };
+        }
+    },
+};
+// ===================== URL 解析工具 =====================
+/** URL 解析工具 */
+exports.parseUrlTool = {
+    id: 'parse_url',
+    name: '解析 URL',
+    description: '解析 URL 字符串，提取协议、域名、端口、路径、查询参数、Hash 等结构化信息。用于分析和构造 URL。',
+    category: 'network',
+    parameters: {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: '待解析的 URL 字符串',
+            },
+        },
+        required: ['url'],
+    },
+    async execute(input) {
+        try {
+            const parsed = new url_1.URL(input.url.trim());
+            const queryParams = {};
+            parsed.searchParams.forEach((value, key) => {
+                queryParams[key] = value;
+            });
+            return {
+                protocol: parsed.protocol.replace(':', ''),
+                hostname: parsed.hostname,
+                port: parsed.port ||
+                    (parsed.protocol === 'https:' ? '443' : '80'),
+                pathname: parsed.pathname,
+                search: parsed.search,
+                hash: parsed.hash,
+                queryParams,
+                origin: parsed.origin,
+            };
+        }
+        catch {
+            return {
+                protocol: '',
+                hostname: '',
+                port: '',
+                pathname: '',
+                search: '',
+                hash: '',
+                queryParams: {},
+                origin: '',
+                ...{ error: '无效的 URL 格式' },
+            };
+        }
+    },
+};

package/dist/tools/registry.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 工具注册表
+ *
+ * 参考 Mastra 的 Tool 注册机制：
+ * https://mastra.ai/docs/tools/overview
+ *
+ * 管理所有可用的 Agent 工具，支持动态注册 / 注销 / 按分类查询。
+ * 工具通过 JSON Schema 声明参数，Agent（LLM）据此生成调用参数。
+ *
+ * 工具分类约定：
+ * - data：数据源查询类工具
+ * - bi：BI 报表生成类工具
+ * - search：网络搜索类工具
+ * - compute：代码执行 / 数据计算类工具
+ * - network：HTTP 请求 / URL 解析类工具
+ * - utility：文本处理 / 编解码 / 日期时间等通用工具
+ *
+ * @example
+ * ```ts
+ * import { toolRegistry } from './tools/registry';
+ *
+ * // 注册工具
+ * toolRegistry.register(myTool);
+ *
+ * // 按分类获取
+ * const dataTools = toolRegistry.getByCategory('data');
+ *
+ * // 导出为 OpenAI function calling 格式
+ * const openaiTools = toolRegistry.toOpenAITools();
+ * ```
+ */
+import type { ToolDefinition, ToolParameterSchema } from '../types';
+/**
+ * 工具注册表类
+ * 基于 Map 实现，支持 O(1) 查找，全局单例通过 toolRegistry 导出。
+ */
+declare class ToolRegistry {
+    private tools;
+    /** 注册工具 */
+    register(tool: ToolDefinition): void;
+    /** 批量注册 */
+    registerAll(tools: ToolDefinition[]): void;
+    /** 注销工具 */
+    unregister(id: string): boolean;
+    /** 获取工具 */
+    get<TInput = any, TOutput = any>(id: string): ToolDefinition<TInput, TOutput> | undefined;
+    /** 检查工具是否存在 */
+    has(id: string): boolean;
+    /** 获取所有工具 */
+    getAll(): ToolDefinition[];
+    /** 按分类过滤工具 */
+    getByCategory(category: string): ToolDefinition[];
+    /** 获取工具 ID 列表 */
+    getIds(): string[];
+    /** 转为 OpenAI function calling tools 格式 */
+    toOpenAITools(toolIds?: string[]): Array<{
+        type: 'function';
+        function: {
+            name: string;
+            description: string;
+            parameters: ToolParameterSchema;
+        };
+    }>;
+    /** 获取工具摘要（用于系统提示词） */
+    getToolSummary(): string;
+    /** 清空所有工具 */
+    clear(): void;
+}
+/** 全局工具注册表单例 */
+export declare const toolRegistry: ToolRegistry;
+export { ToolRegistry };

package/dist/tools/registry.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = exports.toolRegistry = void 0;
+/**
+ * 工具注册表类
+ * 基于 Map 实现，支持 O(1) 查找，全局单例通过 toolRegistry 导出。
+ */
+class ToolRegistry {
+    constructor() {
+        this.tools = new Map();
+    }
+    /** 注册工具 */
+    register(tool) {
+        if (this.tools.has(tool.id)) {
+            console.warn(`[ToolRegistry] 工具 "${tool.id}" 已存在，将被覆盖`);
+        }
+        this.tools.set(tool.id, tool);
+    }
+    /** 批量注册 */
+    registerAll(tools) {
+        tools.forEach(t => this.register(t));
+    }
+    /** 注销工具 */
+    unregister(id) {
+        return this.tools.delete(id);
+    }
+    /** 获取工具 */
+    get(id) {
+        return this.tools.get(id);
+    }
+    /** 检查工具是否存在 */
+    has(id) {
+        return this.tools.has(id);
+    }
+    /** 获取所有工具 */
+    getAll() {
+        return Array.from(this.tools.values());
+    }
+    /** 按分类过滤工具 */
+    getByCategory(category) {
+        return this.getAll().filter(t => t.category === category);
+    }
+    /** 获取工具 ID 列表 */
+    getIds() {
+        return Array.from(this.tools.keys());
+    }
+    /** 转为 OpenAI function calling tools 格式 */
+    toOpenAITools(toolIds) {
+        const tools = toolIds
+            ? toolIds
+                .map(id => this.tools.get(id))
+                .filter(Boolean)
+            : this.getAll();
+        return tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.id,
+                description: tool.description,
+                parameters: tool.parameters,
+            },
+        }));
+    }
+    /** 获取工具摘要（用于系统提示词） */
+    getToolSummary() {
+        const tools = this.getAll();
+        if (!tools.length)
+            return '当前无可用工具。';
+        return tools.map(t => `- **${t.id}**: ${t.description}`).join('\n');
+    }
+    /** 清空所有工具 */
+    clear() {
+        this.tools.clear();
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+/** 全局工具注册表单例 */
+exports.toolRegistry = new ToolRegistry();

package/dist/tools/text-process.tool.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDefinition } from '../types';
+/** 文本处理工具 */
+export declare const textProcessTool: ToolDefinition;
+/** 编解码工具 */
+export declare const encodeDecodeTool: ToolDefinition;
+/** Hash 计算工具 */
+export declare const computeHashTool: ToolDefinition;