multi-modal-mcp 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 橘子
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# @juzi/multi-modal-mcp
+
+基于智谱 AI 的多模态 MCP 服务器，提供文本生成、图片生成、视频生成和多模态理解等功能。
+
+## 功能特性
+
+- **文本生成**: 基于 GLM-4.5-Flash 模型，支持对话、写作、翻译、代码生成等多种文本生成任务
+- **多模态理解**: 基于 GLM-4.6V-Flash 模型，支持图片、视频、文档等多种媒体类型的智能分析与理解
+- **图片生成**: 基于 Cogview-3-Flash 模型，根据文本描述生成高质量图片
+- **视频生成**: 基于 CogVideoX-Flash 模型，根据文本描述生成高质量视频
+
+## 安装
+
+```bash
+npm install -g @juzi/multi-modal-mcp
+```
+
+或使用 npx 直接运行：
+
+```bash
+npx @juzi/multi-modal-mcp@latest
+```
+
+## 配置
+
+在使用前，需要设置智谱 AI 的 API 密钥：
+
+```bash
+export KEY="your-api-key"
+```
+
+或在 MCP Inspector 中配置环境变量。
+
+## 使用方法
+
+### 直接运行
+
+```bash
+npx @juzi/multi-modal-mcp@latest
+```
+
+### 使用 MCP Inspector 调试
+
+```bash
+npx @modelcontextprotocol/inspector npx @juzi/multi-modal-mcp@latest
+```
+
+### 在 MCP 客户端中配置
+
+在 Claude Desktop 或其他 MCP 客户端的配置文件中添加：
+
+```json
+{
+  "mcpServers": {
+    "multi-modal": {
+      "command": "npx",
+      "args": ["-y", "@juzi/multi-modal-mcp@latest"],
+      "env": {
+        "KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+## 工具列表
+
+### 1. text_generation
+
+基于 GLM-4.5-Flash 模型的文本生成工具，支持对话、写作、翻译、代码生成等多种文本生成任务。支持思考模式，可展示模型思考过程。通过温度参数控制生成文本的随机性和创造性。
+
+**参数**:
+
+- `messages`: 消息文本，必传参数
+- `thinking`: 是否启用思考模式，可选值：enabled/disabled，默认 disabled
+- `temperature`: 温度参数，控制生成文本的随机性，范围 0-1，默认 1
+
+### 2. multi_modal_understanding
+
+基于 GLM-4.6V-Flash 模型的多模态理解工具，支持图片、视频、文档等多种媒体类型的智能分析与理解。可执行 OCR 文字识别、表格解析、内容分析、缺陷检测、图像转提示词、视频标签提取、关键帧提取、时间线生成、脚本生成、视频问答、文档问答、文档对比等多种任务。支持同时处理多种媒体类型。
+
+**参数**:
+
+- `content`: 媒体内容列表，支持图片、视频、文档
+- `question`: 关于媒体内容的问题，必传参数
+- `thinking`: 是否启用思考模式，可选值：enabled/disabled，默认 disabled
+- `temperature`: 温度参数，控制生成文本的随机性，范围 0-1，默认 1
+
+### 3. image_generation
+
+基于 Cogview-3-Flash 模型的图片生成工具，根据文本描述生成高质量图片。支持多种尺寸选择，包括横屏、竖屏和方形等多种比例。可选择是否添加水印。适用于插画、设计素材、场景生成等多种应用场景。
+
+**参数**:
+
+- `prompt`: 图片的文本描述，必传参数
+- `size`: 图片尺寸，可选值：1024x1024/768x1344/864x1152/1344x768/1152x864/1440x720/720x1440，默认 1024x1024
+- `watermark_enabled`: 是否添加水印，默认 false
+
+### 4. video_generation
+
+基于 CogVideoX-Flash 模型的视频生成工具，根据文本描述生成高质量视频。支持多种分辨率选择，包括 720p、1080p、2K、4K 等多种规格。支持质量优先和速度优先两种输出模式。可选择是否生成 AI 音效和添加水印。采用异步处理机制，自动轮询任务状态直至完成。
+
+**参数**:
+
+- `prompt`: 视频的文本描述，最大输入长度为 512 个字符，必传参数
+- `quality`: 输出模式，可选值：quality/speed，默认 speed
+- `withAudio`: 是否生成 AI 音效，默认 false
+- `watermarkEnabled`: 是否添加水印，默认 false
+- `size`: 视频分辨率，支持多种规格，默认 1024x1024
+- `fps`: 视频帧率，可选值：30/60，默认 30
+
+## API 密钥获取
+
+1. 访问 [智谱 AI 开放平台](https://open.bigmodel.cn/)
+2. 注册并登录账号
+3. 在控制台创建 API 密钥
+
+## 许可证
+
+MIT License
+
+## 作者
+
+橘子
+
+## 相关链接
+
+- [智谱 AI 开放平台](https://open.bigmodel.cn/)
+- [Model Context Protocol](https://modelcontextprotocol.io/)

package/dist/config.js

@@ -0,0 +1,24 @@
+/*
+ * @Author: 橘子
+ * @Project_description: 配置文件
+ * @Description: 代码是我抄的，不会也是真的
+ */
+'use strict';
+export const config = {
+    /** API 基础地址 */
+    baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+    /** 请求超时时间（毫秒） */
+    timeout: 10 * 60 * 1000,
+    /** 文本生成模型 */
+    textModel: 'GLM-4.5-Flash',
+    /** 图像生成模型 */
+    imageModel: 'Cogview-3-Flash',
+    /** 视觉理解模型 */
+    visualModel: 'GLM-4.6V-Flash',
+    /** 视频生成模型 */
+    videoModel: 'CogVideoX-Flash',
+    /** MCP 服务器名称 */
+    serverName: 'multi-modal-mcp',
+    /** MCP 服务器版本 */
+    serverVersion: '1.0.0',
+};

package/dist/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/*
+ * @Author: 橘子
+ * @Project_description: MCP 多模态服务器主文件
+ * @Description: 代码是我抄的，不会也是真的
+ */
+import { logger, MCPServer } from 'mcp-framework';
+import { config } from './config.js';
+/**
+ * MyMCPServer 类
+ * 封装 MCP 服务器的启动、运行和关闭逻辑
+ */
+class MyMCPServer {
+    /** MCP 服务器实例 */
+    server;
+    /** 服务器名称 */
+    name = config.serverName;
+    /** 服务器版本 */
+    version = config.serverVersion;
+    /**
+     * 构造函数
+     * 初始化 MCP 服务器并注册信号处理
+     */
+    constructor() {
+        // 创建 MCP 服务器实例，配置名称、版本和传输方式
+        this.server = new MCPServer({
+            name: this.name,
+            version: this.version,
+            transport: { type: 'stdio' },
+        });
+        // 注册进程信号监听器，用于优雅关闭
+        process.on('SIGINT', () => this.shutdown()); // Ctrl+C 信号
+        process.on('SIGTERM', () => this.shutdown()); // 终止信号
+    }
+    /**
+     * 启动服务器
+     * 异步启动 MCP 服务器，处理启动过程中的错误
+     */
+    async start() {
+        try {
+            // 启动 MCP 服务器
+            await this.server.start();
+            logger.info('启动成功');
+        }
+        catch (error) {
+            // 启动失败时记录错误并退出
+            logger.error(`启动失败 ${String(error)}`);
+            process.exit(1);
+        }
+    }
+    /**
+     * 关闭服务器
+     * 优雅地关闭 MCP 服务器，处理关闭过程中的错误
+     */
+    async shutdown() {
+        logger.info('正在关闭服务器...');
+        try {
+            // 停止 MCP 服务器
+            await this.server.stop();
+            // 正常退出
+            process.exit(0);
+        }
+        catch (error) {
+            // 关闭失败时记录错误并退出
+            logger.error(`关闭失败 ${String(error)}`);
+            process.exit(1);
+        }
+    }
+}
+// 创建服务器实例并启动，捕获任何未处理的错误
+new MyMCPServer().start().catch(logger.error);

package/dist/tools/ImageGenerationTool.js

@@ -0,0 +1,58 @@
+/*
+ * @Author: 橘子
+ * @Project_description: 智谱AI图片生成工具
+ * @Description: 代码是我抄的，不会也是真的
+ */
+import { MCPTool, logger } from 'mcp-framework';
+import { z } from 'zod';
+import { http } from '../utils/http.js';
+import { config } from '../config.js';
+/**
+ * 智谱AI图片生成工具
+ */
+class ImageGenerationTool extends MCPTool {
+    /** 工具名称 */
+    name = 'image_generation';
+    /** 工具描述 */
+    description = '基于Cogview-3-Flash模型的图片生成工具，根据文本描述生成高质量图片。支持多种尺寸选择，包括横屏、竖屏和方形等多种比例。可选择是否添加水印。适用于插画、设计素材、场景生成等多种应用场景。';
+    /** 参数模式定义 */
+    schema = z.object({
+        prompt: z.string().describe('所需图像的文本描述'),
+        size: z
+            .string()
+            .optional()
+            .default('1024x1024')
+            .describe('图片尺寸，推荐：1024x1024(默认), 768x1344, 864x1152, 1344x768, 1152x864, 1440x720, 720x1440。自定义尺寸需满足512px-2048px之间，被16整除，最大像素数不超过2^21px'),
+        watermark_enabled: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('是否添加水印，默认false'),
+    });
+    /**
+     * 执行图片生成
+     */
+    async execute(input) {
+        logger.info(`开始执行图片生成，描述: ${input.prompt}，尺寸: ${input.size || '1024x1024'}`);
+        try {
+            const requestData = {
+                model: config.imageModel,
+                prompt: input.prompt,
+                size: input.size || '1024x1024',
+                watermark_enabled: input.watermark_enabled ?? false,
+            };
+            logger.info('调用智谱AI图片生成API');
+            const apiResponse = (await http.post('/images/generations', requestData));
+            const imageUrl = apiResponse.data?.[0]?.url;
+            if (!imageUrl)
+                throw new Error('生成图片失败，未返回图片URL');
+            logger.info('图片生成成功');
+            return imageUrl;
+        }
+        catch (error) {
+            logger.error(`图片生成失败: ${error}`);
+            throw new Error(`生成图片时发生错误: ${error}`);
+        }
+    }
+}
+export default ImageGenerationTool;

package/dist/tools/MultiModalUnderstandingTool.js

@@ -0,0 +1,135 @@
+/*
+ * @Author: 橘子
+ * @Project_description: 智谱AI多模态理解工具
+ * @Description: 代码是我抄的，不会也是真的
+ */
+import { MCPTool, logger } from 'mcp-framework';
+import { z } from 'zod';
+import { http } from '../utils/http.js';
+import { config } from '../config.js';
+/**
+ * 智谱AI多模态理解工具
+ */
+class MultiModalUnderstandingTool extends MCPTool {
+    /** 工具名称 */
+    name = 'multi_modal_understanding';
+    /** 工具描述 */
+    description = '基于GLM-4.6V-Flash模型的多模态理解工具，支持图片、视频、文档等多种媒体类型的智能分析与理解。可执行OCR文字识别、表格解析、内容分析、缺陷检测、图像转提示词、视频标签提取、关键帧提取、时间线生成、脚本生成、视频问答、文档问答、文档对比等多种任务。支持同时处理多种媒体类型。';
+    /** 参数模式定义 */
+    schema = z.object({
+        content: z
+            .array(z.object({
+            type: z
+                .enum(['image_url', 'video_url', 'file_url'])
+                .describe('媒体类型：image_url-图片，video_url-视频，file_url-文档'),
+            image_url: z
+                .object({
+                url: z.string().describe('图片的URL地址或Base64编码'),
+            })
+                .optional()
+                .describe('图片URL对象，当type为image_url时必填'),
+            video_url: z
+                .object({
+                url: z.string().describe('视频的URL地址'),
+            })
+                .optional()
+                .describe('视频URL对象，当type为video_url时必填'),
+            file_url: z
+                .object({
+                url: z.string().describe('文件的URL地址'),
+            })
+                .optional()
+                .describe('文件URL对象，当type为file_url时必填'),
+        }))
+            .describe('媒体内容列表，支持混合图片、视频、文档'),
+        question: z
+            .string()
+            .describe('用自然语言描述您的需求，例如："识别图片中的文字"、"提取表格数据"、"分析视频内容"、"回答关于文档的问题"等'),
+        thinking: z
+            .enum(['enabled', 'disabled'])
+            .default('disabled')
+            .describe('是否启用思考模式，启用后模型会展示思考过程，默认disabled'),
+        temperature: z
+            .number()
+            .default(1)
+            .describe('温度参数，控制生成文本的随机性，范围0-1，默认1'),
+    });
+    /**
+     * 执行多模态理解
+     */
+    async execute(input) {
+        logger.info(`开始执行多模态理解，问题: ${input.question}，媒体数量: ${input.content.length}`);
+        try {
+            const messageContent = this.buildMessageContent(input.content, input.question);
+            const requestData = {
+                model: config.visualModel,
+                messages: [
+                    {
+                        role: 'user',
+                        content: messageContent,
+                    },
+                ],
+                thinking: {
+                    type: input.thinking,
+                },
+                temperature: input.temperature,
+                stream: false,
+            };
+            logger.info('调用智谱AI多模态理解API');
+            const apiResponse = (await http.post('/chat/completions', requestData));
+            const messageContentResult = apiResponse.choices?.[0]?.message?.content;
+            let generatedText = '';
+            if (typeof messageContentResult === 'string') {
+                generatedText = messageContentResult;
+            }
+            else if (Array.isArray(messageContentResult)) {
+                const textItem = messageContentResult.find((item) => item.type === 'text');
+                generatedText = textItem?.text || '';
+            }
+            logger.info('多模态理解成功');
+            return generatedText;
+        }
+        catch (error) {
+            logger.error(`多模态理解失败: ${error}`);
+            throw new Error(`多模态理解时发生错误: ${error}`);
+        }
+    }
+    /**
+     * 构建消息内容
+     */
+    buildMessageContent(content, question) {
+        const result = [];
+        for (const item of content) {
+            if (item.type === 'image_url' && item.image_url) {
+                result.push({
+                    type: 'image_url',
+                    image_url: {
+                        url: item.image_url.url,
+                    },
+                });
+            }
+            else if (item.type === 'video_url' && item.video_url) {
+                result.push({
+                    type: 'video_url',
+                    video_url: {
+                        url: item.video_url.url,
+                    },
+                });
+            }
+            else if (item.type === 'file_url' && item.file_url) {
+                result.push({
+                    type: 'file_url',
+                    file_url: {
+                        url: item.file_url.url,
+                    },
+                });
+            }
+        }
+        result.push({
+            type: 'text',
+            text: question,
+        });
+        return result;
+    }
+}
+export default MultiModalUnderstandingTool;

package/dist/tools/TextGenerationTool.js

@@ -0,0 +1,75 @@
+/*
+ * @Author: 橘子
+ * @Project_description: 智谱AI文本生成工具
+ * @Description: 代码是我抄的，不会也是真的
+ */
+import { MCPTool, logger } from 'mcp-framework';
+import { z } from 'zod';
+import { http } from '../utils/http.js';
+import { config } from '../config.js';
+/**
+ * 智谱AI文本生成工具
+ */
+class TextGenerationTool extends MCPTool {
+    /** 工具名称 */
+    name = 'text_generation';
+    /** 工具描述 */
+    description = '基于GLM-4.5-Flash模型的文本生成工具，支持对话、写作、翻译、代码生成等多种文本生成任务。支持思考模式，可展示模型思考过程。通过温度参数控制生成文本的随机性和创造性。';
+    /** 参数模式定义 */
+    schema = z.object({
+        messages: z.string().describe('消息文本，必传参数'),
+        thinking: z
+            .enum(['enabled', 'disabled'])
+            .default('disabled')
+            .describe('是否启用思考模式，启用后模型会展示思考过程，默认disabled'),
+        temperature: z
+            .number()
+            .default(1)
+            .describe('温度参数，控制生成文本的随机性，范围0-1，默认1'),
+    });
+    /**
+     * 执行文本生成
+     */
+    async execute(input) {
+        logger.info(`开始执行文本生成，输入: ${input.messages}`);
+        try {
+            // 构建请求参数
+            const requestData = {
+                model: config.textModel,
+                messages: [
+                    {
+                        role: 'user',
+                        content: input.messages,
+                    },
+                ],
+                thinking: {
+                    type: input.thinking,
+                },
+                temperature: input.temperature,
+                stream: false, // 确保非流式返回
+            };
+            logger.info('调用智谱AI文本生成API');
+            // 调用智谱AI API
+            const apiResponse = (await http.post('/chat/completions', requestData));
+            // 提取生成的文本
+            const messageContent = apiResponse.choices?.[0]?.message?.content;
+            // 处理 content 可能是字符串或数组的情况
+            let generatedText = '';
+            if (typeof messageContent === 'string') {
+                generatedText = messageContent;
+            }
+            else if (Array.isArray(messageContent)) {
+                // 如果是数组，提取 type 为 'text' 的内容
+                const textItem = messageContent.find((item) => item.type === 'text');
+                generatedText = textItem?.text || '';
+            }
+            logger.info('文本生成成功');
+            return generatedText;
+        }
+        catch (error) {
+            logger.error(`文本生成失败: ${error}`);
+            throw new Error(`生成文本时发生错误: ${error}`);
+        }
+    }
+}
+export default TextGenerationTool;

package/dist/tools/VideoGenerationTool.js

@@ -0,0 +1,122 @@
+/*
+ * @Author: 橘子
+ * @Project_description: 智谱AI视频生成工具
+ * @Description: 代码是我抄的，不会也是真的
+ */
+import { MCPTool, logger } from 'mcp-framework';
+import { z } from 'zod';
+import { http } from '../utils/http.js';
+import { config } from '../config.js';
+/**
+ * 智谱AI视频生成工具
+ */
+class VideoGenerationTool extends MCPTool {
+    /** 工具名称 */
+    name = 'video_generation';
+    /** 工具描述 */
+    description = '基于CogVideoX-Flash模型的视频生成工具，根据文本描述生成高质量视频。支持多种分辨率选择，包括720p、1080p、2K、4K等多种规格。支持质量优先和速度优先两种输出模式。可选择是否生成AI音效和添加水印。采用异步处理机制，自动轮询任务状态直至完成。';
+    /** 参数模式定义 */
+    schema = z.object({
+        prompt: z
+            .string()
+            .describe('视频的文本描述，最大输入长度为 512 个字符，必传参数'),
+        quality: z
+            .enum(['quality', 'speed'])
+            .optional()
+            .default('speed')
+            .describe('输出模式，quality-质量优先，speed-速度优先，默认speed'),
+        withAudio: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('是否生成 AI 音效，默认false'),
+        watermarkEnabled: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('控制是否添加水印，默认false'),
+        // imageUrl: z
+        //   .string()
+        //   .optional()
+        //   .describe('用于内容生成的基础图像，支持 URL 或 Base64 编码图像'),
+        size: z
+            .enum([
+            '720x480',
+            '1024x1024',
+            '1280x960',
+            '960x1280',
+            '1920x1080',
+            '1080x1920',
+            '2048x1080',
+            '3840x2160',
+        ])
+            .optional()
+            .default('1024x1024')
+            .describe('视频分辨率，默认1024x1024'),
+        fps: z
+            .union([z.literal(30), z.literal(60)])
+            .optional()
+            .default(30)
+            .describe('视频帧率（FPS），可选值为 30 或 60，默认30'),
+    });
+    /**
+     * 执行视频生成
+     */
+    async execute(input) {
+        logger.info(`开始执行视频生成，描述: ${input.prompt}，尺寸: ${input.size || '1024x1024'}，帧率: ${input.fps || 30}`);
+        try {
+            const requestData = {
+                model: config.videoModel,
+                prompt: input.prompt,
+                quality: input.quality || 'speed',
+                with_audio: input.withAudio ?? false,
+                watermark_enabled: input.watermarkEnabled ?? true,
+                image_url: input.imageUrl,
+                size: input.size,
+                fps: input.fps || 30,
+            };
+            logger.info('调用智谱AI视频生成API，创建任务');
+            const apiResponse = (await http.post('/videos/generations', requestData));
+            const taskId = apiResponse.id;
+            if (!taskId)
+                throw new Error('视频生成任务创建失败，未返回任务ID');
+            logger.info(`视频生成任务创建成功，任务ID: ${taskId}，开始轮询任务状态`);
+            const videoUrl = await this.pollTaskStatus(taskId);
+            logger.info('视频生成成功');
+            return videoUrl;
+        }
+        catch (error) {
+            logger.error(`视频生成失败: ${error}`);
+            throw new Error(`视频生成时发生错误: ${error}`);
+        }
+    }
+    /**
+     * 轮询任务状态
+     */
+    async pollTaskStatus(taskId) {
+        const startTime = Date.now();
+        const timeout = 60000;
+        logger.info(`开始轮询任务状态，任务ID: ${taskId}`);
+        while (true) {
+            const elapsedTime = Date.now() - startTime;
+            if (elapsedTime >= timeout) {
+                logger.error(`视频生成超时，超过60秒未完成，任务ID: ${taskId}`);
+                throw new Error('视频生成超时，超过60秒未完成');
+            }
+            const apiResponse = (await http.get(`/async-result/${taskId}`));
+            const taskData = apiResponse;
+            if (taskData.task_status === 'SUCCESS' &&
+                taskData.video_result?.[0]?.url) {
+                logger.info(`任务完成，任务ID: ${taskId}，状态: ${taskData.task_status}`);
+                return taskData.video_result[0].url;
+            }
+            if (taskData.task_status === 'FAILED') {
+                logger.error(`任务失败，任务ID: ${taskId}，状态: ${taskData.task_status}`);
+                throw new Error('视频生成失败');
+            }
+            logger.debug(`任务进行中，任务ID: ${taskId}，状态: ${taskData.task_status}，已等待: ${Math.floor(elapsedTime / 1000)}秒`);
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    }
+}
+export default VideoGenerationTool;

package/dist/utils/http.js

@@ -0,0 +1,137 @@
+/*
+ * @Author: 橘子
+ * @Project_description: API HTTP 封装
+ * @Description: 代码是我抄的，不会也是真的
+ */
+import axios from 'axios';
+import { config } from '../config.js';
+/**
+ * 智谱AI业务错误码定义
+ */
+var ZhipuErrorCode;
+(function (ZhipuErrorCode) {
+    // 身份验证错误
+    ZhipuErrorCode["AUTH_FAILED"] = "1000";
+    ZhipuErrorCode["AUTH_MISSING"] = "1001";
+    ZhipuErrorCode["AUTH_INVALID"] = "1002";
+    ZhipuErrorCode["AUTH_EXPIRED"] = "1003";
+    ZhipuErrorCode["AUTH_VERIFY_FAILED"] = "1004";
+    // 账户错误
+    ZhipuErrorCode["ACCOUNT_INACTIVE"] = "1110";
+    ZhipuErrorCode["ACCOUNT_NOT_EXIST"] = "1111";
+    ZhipuErrorCode["ACCOUNT_LOCKED"] = "1112";
+    ZhipuErrorCode["ACCOUNT_ARREARS"] = "1113";
+    // API调用错误
+    ZhipuErrorCode["API_PARAM_ERROR"] = "1210";
+    ZhipuErrorCode["API_MODEL_NOT_EXIST"] = "1211";
+    ZhipuErrorCode["API_METHOD_NOT_SUPPORTED"] = "1212";
+    ZhipuErrorCode["API_PARAM_MISSING"] = "1213";
+    ZhipuErrorCode["API_PARAM_INVALID"] = "1214";
+    ZhipuErrorCode["API_NO_PERMISSION"] = "1220";
+    ZhipuErrorCode["API_OFFLINE"] = "1221";
+    ZhipuErrorCode["API_NOT_EXIST"] = "1222";
+    // 策略阻止错误
+    ZhipuErrorCode["POLICY_BLOCKED"] = "1301";
+    ZhipuErrorCode["CONCURRENCY_LIMIT"] = "1302";
+    ZhipuErrorCode["RATE_LIMIT"] = "1303";
+    ZhipuErrorCode["DAILY_LIMIT"] = "1304";
+    ZhipuErrorCode["TRAFFIC_LIMIT"] = "1305";
+})(ZhipuErrorCode || (ZhipuErrorCode = {}));
+/**
+ * 错误信息映射
+ */
+const ERROR_MESSAGES = {
+    [ZhipuErrorCode.AUTH_FAILED]: '身份验证失败',
+    [ZhipuErrorCode.AUTH_MISSING]: 'Header中未收到Authentication参数',
+    [ZhipuErrorCode.AUTH_INVALID]: 'Authorization Token非法',
+    [ZhipuErrorCode.AUTH_EXPIRED]: 'Authorization Token已过期',
+    [ZhipuErrorCode.AUTH_VERIFY_FAILED]: 'Token验证失败',
+    [ZhipuErrorCode.ACCOUNT_INACTIVE]: '账户处于非活动状态',
+    [ZhipuErrorCode.ACCOUNT_NOT_EXIST]: '账户不存在',
+    [ZhipuErrorCode.ACCOUNT_LOCKED]: '账户已被锁定',
+    [ZhipuErrorCode.ACCOUNT_ARREARS]: '账户已欠费',
+    [ZhipuErrorCode.API_PARAM_ERROR]: 'API调用参数有误',
+    [ZhipuErrorCode.API_MODEL_NOT_EXIST]: '模型不存在',
+    [ZhipuErrorCode.API_METHOD_NOT_SUPPORTED]: '当前模型不支持此调用方式',
+    [ZhipuErrorCode.API_PARAM_MISSING]: '未正常接收到必需参数',
+    [ZhipuErrorCode.API_PARAM_INVALID]: '参数非法',
+    [ZhipuErrorCode.API_NO_PERMISSION]: '无权访问此API',
+    [ZhipuErrorCode.API_OFFLINE]: 'API已下线',
+    [ZhipuErrorCode.API_NOT_EXIST]: 'API不存在',
+    [ZhipuErrorCode.POLICY_BLOCKED]: '输入或生成内容可能包含不安全或敏感内容',
+    [ZhipuErrorCode.CONCURRENCY_LIMIT]: '并发数过高，请降低并发',
+    [ZhipuErrorCode.RATE_LIMIT]: '请求频率过高，请降低频率',
+    [ZhipuErrorCode.DAILY_LIMIT]: '已达今日调用次数限额',
+    [ZhipuErrorCode.TRAFFIC_LIMIT]: '已触发流量限制',
+};
+/**
+ * HTTP错误类
+ */
+export class HttpError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'HttpError';
+    }
+}
+/**
+ * 创建axios实例
+ */
+const http = axios.create({
+    baseURL: config.baseUrl,
+    timeout: config.timeout,
+    headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${process.env.KEY || ''}`,
+    },
+});
+/**
+ * 请求拦截器
+ */
+http.interceptors.request.use((requestConfig) => {
+    // 可以在这里添加请求日志
+    return requestConfig;
+}, (error) => {
+    return Promise.reject(error);
+});
+/**
+ * 响应拦截器
+ */
+http.interceptors.response.use((response) => {
+    return response.data;
+}, (error) => {
+    const statusCode = error.response?.status;
+    const responseData = error.response?.data;
+    // 处理HTTP状态码错误
+    if (statusCode) {
+        switch (statusCode) {
+            case 400:
+                return Promise.reject(new HttpError('参数错误', responseData?.error?.code, statusCode));
+            case 401:
+                return Promise.reject(new HttpError('鉴权失败或Token超时', responseData?.error?.code, statusCode));
+            case 404:
+                return Promise.reject(new HttpError('功能未开放或任务不存在', responseData?.error?.code, statusCode));
+            case 429:
+                return Promise.reject(new HttpError('请求频率过高或并发超额', responseData?.error?.code, statusCode));
+            case 500:
+                return Promise.reject(new HttpError('服务器内部错误', responseData?.error?.code, statusCode));
+            default:
+                return Promise.reject(new HttpError(`HTTP错误: ${statusCode}`, responseData?.error?.code, statusCode));
+        }
+    }
+    // 处理业务错误码
+    if (responseData?.error?.code) {
+        const errorCode = responseData.error.code;
+        const errorMessage = ERROR_MESSAGES[errorCode] || responseData.error.message || '未知错误';
+        return Promise.reject(new HttpError(errorMessage, errorCode, statusCode));
+    }
+    // 网络错误
+    if (error.code === 'ECONNABORTED') {
+        return Promise.reject(new HttpError('请求超时', undefined, undefined));
+    }
+    return Promise.reject(new HttpError(error.message || '网络错误', undefined, undefined));
+});
+export { http };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "multi-modal-mcp",
+  "version": "0.0.1",
+  "description": "multi-modal MCP server",
+  "type": "module",
+  "bin": {
+    "multi-modal-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && mcp-build",
+    "watch": "tsc --watch",
+    "start": "node dist/index.js",
+    "debug": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "publish": "npx tsx scripts/publish.ts"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "mcp-framework": "^0.2.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/inspector": "^0.18.0",
+    "@types/node": "^20.11.24",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.19.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "multi-modal",
+    "ai",
+    "glm",
+    "cogview",
+    "cogvideo",
+    "text-generation",
+    "image-generation",
+    "video-generation",
+    "model-context-protocol"
+  ],
+  "author": "橘子",
+  "license": "MIT"
+}