mcp-ai-music 1.0.0

package/README.md

@@ -0,0 +1,256 @@
+# AI作曲 MCP 服务
+
+**版本 (Version):** 1.0.0
+
+## 描述 (Description)
+
+`mcp-ai-music` 是一个基于 Suno4.5 API 的 AI 作曲 MCP 服务，提供音乐生成、翻唱、扩展和进度查询功能。该服务支持多种音乐风格，可以生成原创音乐、对现有音乐进行翻唱转换，以及扩展音乐长度。
+
+## 功能特点
+
+- **原创音乐生成**：根据提示词和风格生成全新的音乐作品
+- **音乐翻唱**：将现有音乐转换为不同风格，保留核心旋律
+- **音乐扩展**：在保持原始风格的基础上延长音乐时长
+- **实时进度查询**：支持轮询查询任务进度，实时了解生成状态
+- **多模型支持**：支持 V3_5、V4、V4_5 多个AI模型版本
+- **纯音乐模式**：支持生成无歌词的纯音乐版本
+
+## 环境配置
+
+> **重要**：您需要拥有 Suno API 的密钥才能使用此服务。请将密钥配置为环境变量 `SUNO_API_KEY`。
+
+### 费用说明
+- 生成音乐：¥0.438/次
+- 翻唱音乐：¥0.438/次  
+- 扩展音乐：¥0.438/次
+- 查询进度：免费
+
+## 使用方法
+
+```json
+{
+  "mcpServers": {
+    "mcp-ai-music": {
+      "command": "node",
+      "args": [
+        "dist/index.js"
+      ],
+      "env": {
+        "SUNO_API_KEY": "您的Suno API密钥"
+      },
+      "autoApprove": [
+        "generate_music",
+        "cover_music", 
+        "extend_music",
+        "query_progress"
+      ]
+    }
+  }
+}
+```
+
+## 可用工具 (Available Tools)
+
+该服务提供以下4个工具：
+
+### 1. `generate_music` - 生成音乐
+
+生成原创音乐作品。
+
+**输入参数：**
+- `prompt` (必需): 音乐描述提示词，详细描述想要的音乐风格、情感、乐器等
+  - V3_5/V4 模型：最多 3000 字符
+  - V4_5 模型：最多 5000 字符
+- `style` (可选): 音乐风格，如"古典"、"流行"、"摇滚"等
+  - V3_5/V4 模型：最多 200 字符
+  - V4_5 模型：最多 1000 字符  
+- `title` (可选): 音乐标题，最多 80 字符
+- `instrumental` (可选): 是否生成纯音乐（无歌词），默认 false
+- `model` (可选): AI模型版本，可选 "V3_5"、"V4"、"V4_5"，默认 "V4_5"
+- `negativeTags` (可选): 负面标签，描述不想要的音乐元素
+
+**调用示例：**
+```json
+{
+  "name": "generate_music",
+  "arguments": {
+    "prompt": "一段平静舒缓的钢琴曲，带有柔和的旋律，适合冥想和放松",
+    "style": "古典",
+    "title": "宁静钢琴冥想",
+    "instrumental": true,
+    "model": "V4_5",
+    "negativeTags": "重金属, 强节奏鼓点"
+  }
+}
+```
+
+### 2. `cover_music` - 翻唱音乐
+
+将现有音乐转换为新的风格，保留核心旋律。
+
+**输入参数：**
+- `uploadUrl` (必需): 要翻唱的音频文件URL，音频长度不超过2分钟
+- `prompt` (必需): 翻唱风格描述
+- `style` (可选): 目标音乐风格
+- `title` (可选): 翻唱版本标题
+- `instrumental` (可选): 是否生成纯音乐版本，默认 false
+- `model` (可选): AI模型版本，默认 "V4_5"
+- `negativeTags` (可选): 负面标签
+
+**调用示例：**
+```json
+{
+  "name": "cover_music",
+  "arguments": {
+    "uploadUrl": "https://example.com/audio.mp3",
+    "prompt": "将这首歌转换为爵士风格",
+    "style": "爵士",
+    "title": "爵士翻唱版",
+    "instrumental": false
+  }
+}
+```
+
+### 3. `extend_music` - 扩展音乐
+
+在保留原始音频风格的同时扩展音轨长度。
+
+**输入参数：**
+- `uploadUrl` (必需): 要扩展的音频文件URL，音频长度不超过2分钟
+- `prompt` (必需): 扩展描述，如"用更多舒缓的音符延长音乐"
+- `continueAt` (必需): 从音频的第几秒开始扩展，必须大于0且小于音频总时长
+- `style` (可选): 保持的音乐风格
+- `title` (可选): 扩展版本标题
+- `instrumental` (可选): 是否生成纯音乐版本，默认 false
+- `model` (可选): AI模型版本，必须与源音乐保持一致，默认 "V4_5"
+- `negativeTags` (可选): 负面标签
+
+**调用示例：**
+```json
+{
+  "name": "extend_music",
+  "arguments": {
+    "uploadUrl": "https://example.com/audio.mp3",
+    "prompt": "用更多舒缓的音符延长音乐，保持原有的宁静氛围",
+    "continueAt": 60,
+    "style": "古典",
+    "title": "宁静钢琴延长版",
+    "instrumental": true
+  }
+}
+```
+
+### 4. `query_progress` - 查询进度
+
+查询音乐生成任务的进度状态。
+
+> **重要提示**：由于AI生成音乐需要时间，大模型需要轮询此接口来获取任务状态和结果。建议每10-30秒查询一次，直到状态为'complete'或'failed'。
+
+**输入参数：**
+- `taskId` (必需): 音乐生成任务的ID（从其他工具的返回结果中获取）
+
+**调用示例：**
+```json
+{
+  "name": "query_progress",
+  "arguments": {
+    "taskId": "task_12345"
+  }
+}
+```
+
+**状态说明：**
+- `pending`: 任务排队中
+- `processing`: 正在处理中
+- `text`: 文本生成完成，正在生成音频
+- `first`: 第一首音乐生成完成
+- `complete`: 任务完成
+- `failed`: 任务失败
+
+## 工作流程示例
+
+### 生成原创音乐的完整流程：
+
+1. **发起生成请求**
+```json
+{
+  "name": "generate_music",
+  "arguments": {
+    "prompt": "一首欢快的流行歌曲，适合夏天",
+    "style": "流行",
+    "title": "夏日阳光"
+  }
+}
+```
+
+2. **获取任务ID**
+```json
+{
+  "taskId": "task_abc123",
+  "status": "pending",
+  "message": "音乐生成任务已提交，请使用query_progress工具查询进度。",
+  "cost": "¥0.438"
+}
+```
+
+3. **轮询查询进度**
+```json
+{
+  "name": "query_progress",
+  "arguments": {
+    "taskId": "task_abc123"
+  }
+}
+```
+
+4. **获取最终结果**
+当状态变为'complete'时，会返回包含音乐文件信息的完整结果。
+
+## 注意事项
+
+1. **API密钥安全**：请确保 `SUNO_API_KEY` 环境变量已正确设置，不要在代码中硬编码API密钥。
+
+2. **文件大小限制**：上传的音频文件长度不得超过2分钟。
+
+3. **文件保存期限**：生成的音乐文件在服务器上保留15天后会被删除。
+
+4. **费用控制**：每次调用生成、翻唱、扩展功能都会产生¥0.438的费用，请合理使用。
+
+5. **轮询间隔**：建议查询进度的间隔为10-30秒，避免过于频繁的请求。
+
+6. **模型兼容性**：在扩展音乐时，使用的模型版本必须与源音乐的生成模型保持一致。
+
+7. **字符限制**：请注意各个参数的字符长度限制，超出限制会导致请求失败。
+
+## 错误处理
+
+服务会返回详细的错误信息，包括：
+- 参数验证错误
+- API请求失败
+- 字符长度超限
+- 任务状态异常
+
+所有错误都会在响应中通过 `isError` 字段标识，并在 `errorMessage` 字段中提供具体的错误描述。
+
+## 技术实现
+
+- 基于 Model Context Protocol (MCP) SDK 构建
+- 使用 Suno4.5 API 进行音乐生成
+- 支持 TypeScript 开发
+- 提供完整的类型定义和输入验证
+
+## 开发和构建
+
+```bash
+# 安装依赖
+npm install
+
+# 开发模式运行
+npm run dev
+
+# 构建项目
+npm run build
+
+# 启动服务
+npm start
+```

package/dist/index.js

@@ -0,0 +1,836 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+// API 基础配置
+const API_BASE_URL = "https://api.sunoapi.org/api/v1";
+// 获取API密钥的函数
+function getApiKey() {
+    const apiKey = process.env.SUNO_API_KEY;
+    if (!apiKey) {
+        throw new Error("请设置 SUNO_API_KEY 环境变量");
+    }
+    return apiKey;
+}
+// 统一的服务端基地址：回调与查询都从此派生（向后兼容旧变量）
+function getServiceBase() {
+    return (process.env.SUNO_SERVICE_BASE ||
+        process.env.SUNO_API_BASE ||
+        process.env.SUNO_CALLBACK_BASE ||
+        process.env.SUNO_QUERY_BASE_URL ||
+        process.env.SUNO_CALLBACK_URL);
+}
+// 构造回调地址
+function buildCallbackUrl(kind) {
+    const base = getServiceBase();
+    if (!base) {
+        throw new Error("未配置 SUNO_SERVICE_BASE（或兼容变量），用于设置服务端基地址");
+    }
+    const pathMap = {
+        "generate": "/suno/callback/generate",
+        "upload-cover": "/suno/callback/upload-cover",
+        "upload-extend": "/suno/callback/upload-extend",
+    };
+    return `${base.replace(/\/$/, "")}${pathMap[kind]}`;
+}
+// 查询同样使用统一基地址
+function getQueryBase() {
+    return getServiceBase();
+}
+// 工具输出模式定义
+const MUSIC_GENERATION_OUTPUT_SCHEMA = {
+    type: "object",
+    description: "音乐生成结果的结构",
+    properties: {
+        content: {
+            type: "array",
+            description: "结果数组。成功时包含任务信息，失败时为空。",
+            items: {
+                type: "object",
+                properties: {
+                    type: { type: "string", description: "内容类型" },
+                    text: { type: "string", description: "JSON格式的任务信息" },
+                },
+            },
+        },
+        isError: { type: "boolean", description: "请求是否发生错误" },
+        errorMessage: { type: "string", description: "错误信息（如果 isError 为 true 时提供）" },
+    },
+};
+const PROGRESS_QUERY_OUTPUT_SCHEMA = {
+    type: "object",
+    description: "进度查询结果的结构",
+    properties: {
+        content: {
+            type: "array",
+            description: "结果数组。成功时包含进度信息，失败时为空。",
+            items: {
+                type: "object",
+                properties: {
+                    type: { type: "string", description: "内容类型" },
+                    text: { type: "string", description: "JSON格式的进度信息" },
+                },
+            },
+        },
+        isError: { type: "boolean", description: "请求是否发生错误" },
+        errorMessage: { type: "string", description: "错误信息（如果 isError 为 true 时提供）" },
+    },
+};
+// 工具定义
+const GENERATE_MUSIC_TOOL = {
+    name: "generate_music",
+    description: "生成音乐。根据提示词和风格生成原创音乐，支持自定义模式和纯音乐模式。\n\n注意：生成需要时间，请使用query_progress工具查询进度。\n\n返回字段说明：\n- taskId: 任务ID，用于查询进度\n- status: 任务状态 (pending)\n- message: 状态描述",
+    inputSchema: {
+        type: "object",
+        properties: {
+            prompt: {
+                type: "string",
+                description: "音乐描述提示词，详细描述想要的音乐风格、情感、乐器等。长度限制：V3_5和V4模型3000字符，V4_5模型5000字符。",
+            },
+            style: {
+                type: "string",
+                description: "音乐风格，如'古典'、'流行'、'摇滚'等。长度限制：V3_5和V4模型200字符，V4_5模型1000字符。",
+                default: "",
+            },
+            title: {
+                type: "string",
+                description: "音乐标题，最多80字符。",
+                default: "",
+            },
+            instrumental: {
+                type: "boolean",
+                description: "是否生成纯音乐（无歌词）。",
+                default: false,
+            },
+            model: {
+                type: "string",
+                enum: ["V3_5", "V4", "V4_5"],
+                description: "使用的AI模型版本。",
+                default: "V4_5",
+            },
+            negativeTags: {
+                type: "string",
+                description: "负面标签，描述不想要的音乐元素。",
+                default: "",
+            },
+        },
+        required: ["prompt"],
+    },
+    // outputSchema: MUSIC_GENERATION_OUTPUT_SCHEMA,
+};
+const COVER_MUSIC_TOOL = {
+    name: "cover_music",
+    description: "翻唱音乐。上传音频文件并转换为新的风格，保留核心旋律。\n\n注意：生成需要时间，请使用query_progress工具查询进度。\n\n返回字段说明：\n- taskId: 任务ID，用于查询进度\n- status: 任务状态 (pending)\n- message: 状态描述",
+    inputSchema: {
+        type: "object",
+        properties: {
+            uploadUrl: {
+                type: "string",
+                description: "要翻唱的音频文件URL，音频长度不超过2分钟。",
+            },
+            prompt: {
+                type: "string",
+                description: "翻唱风格描述。",
+            },
+            style: {
+                type: "string",
+                description: "目标音乐风格。",
+                default: "",
+            },
+            title: {
+                type: "string",
+                description: "翻唱版本标题。",
+                default: "",
+            },
+            instrumental: {
+                type: "boolean",
+                description: "是否生成纯音乐版本。",
+                default: false,
+            },
+            model: {
+                type: "string",
+                enum: ["V3_5", "V4", "V4_5"],
+                description: "使用的AI模型版本。",
+                default: "V4_5",
+            },
+            negativeTags: {
+                type: "string",
+                description: "负面标签。",
+                default: "",
+            },
+        },
+        required: ["uploadUrl", "prompt"],
+    },
+    outputSchema: MUSIC_GENERATION_OUTPUT_SCHEMA,
+};
+const EXTEND_MUSIC_TOOL = {
+    name: "extend_music",
+    description: "扩展音乐。在保留原始音频风格的同时扩展音轨长度。\n\n注意：生成需要时间，请使用query_progress工具查询进度。\n\n返回字段说明：\n- taskId: 任务ID，用于查询进度\n- status: 任务状态 (pending)\n- message: 状态描述",
+    inputSchema: {
+        type: "object",
+        properties: {
+            uploadUrl: {
+                type: "string",
+                description: "要扩展的音频文件URL，音频长度不超过2分钟。",
+            },
+            prompt: {
+                type: "string",
+                description: "扩展描述，如'用更多舒缓的音符延长音乐'。",
+            },
+            style: {
+                type: "string",
+                description: "保持的音乐风格。",
+                default: "",
+            },
+            title: {
+                type: "string",
+                description: "扩展版本标题。",
+                default: "",
+            },
+            continueAt: {
+                type: "number",
+                description: "从音频的第几秒开始扩展，必须大于0且小于音频总时长。",
+                minimum: 1,
+            },
+            instrumental: {
+                type: "boolean",
+                description: "是否生成纯音乐版本。",
+                default: false,
+            },
+            model: {
+                type: "string",
+                enum: ["V3_5", "V4", "V4_5"],
+                description: "使用的AI模型版本，必须与源音乐保持一致。",
+                default: "V4_5",
+            },
+            negativeTags: {
+                type: "string",
+                description: "负面标签。",
+                default: "",
+            },
+        },
+        required: ["uploadUrl", "prompt", "continueAt"],
+    },
+    // outputSchema: MUSIC_GENERATION_OUTPUT_SCHEMA,
+};
+const QUERY_PROGRESS_TOOL = {
+    name: "query_progress",
+    description: "查询音乐生成进度。由于AI生成音乐需要时间，大模型需要轮询此接口来获取任务状态和结果。建议每10-30秒查询一次，直到状态为'complete'或'failed'。\n\n返回字段说明：\n- taskId: 任务ID\n- status: 任务状态 (pending/processing/complete/failed)\n- progress: 进度百分比\n- message: 状态描述\n- result: 完成时的详细结果，包含：\n  • 基本信息：prompt(提示词)、modelName(模型)、title(标题)、tags(标签)、duration(时长秒数)\n  • 音频链接：audioUrl(MP3下载)、streamAudioUrl(流媒体)、sourceAudioUrl(原始音频)\n  • 图片链接：imageUrl(封面图)、sourceImageUrl(原始封面)\n  • 其他：musicId(音乐ID)、taskCreateTime(创建时间)、callbackType(回调类型)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            taskId: {
+                type: "string",
+                description: "音乐生成任务的ID。",
+            },
+        },
+        required: ["taskId"],
+    },
+    // outputSchema: PROGRESS_QUERY_OUTPUT_SCHEMA,
+};
+const TOOLS = [
+    GENERATE_MUSIC_TOOL,
+    COVER_MUSIC_TOOL,
+    EXTEND_MUSIC_TOOL,
+    QUERY_PROGRESS_TOOL,
+];
+// 通用API请求函数
+async function makeApiRequest(endpoint, method, body, retries = 3) {
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        let timeoutId;
+        try {
+            const controller = new AbortController();
+            timeoutId = setTimeout(() => controller.abort(), 60000); // 60秒超时
+            const config = {
+                method,
+                headers: {
+                    'Authorization': `Bearer ${getApiKey()}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: controller.signal,
+            };
+            if (body && method !== 'GET') {
+                config.body = JSON.stringify(body);
+            }
+            console.error(`尝试第 ${attempt} 次请求: ${method} ${API_BASE_URL}${endpoint}`);
+            const response = await (0, node_fetch_1.default)(`${API_BASE_URL}${endpoint}`, config);
+            clearTimeout(timeoutId);
+            const result = await response.json();
+            console.error(`请求成功，响应数据:`, JSON.stringify(result, null, 2));
+            // 检查API返回的业务错误码
+            if (result.code && result.code !== 200) {
+                throw new Error(`API业务错误: ${result.code} - ${result.msg || '未知错误'}`);
+            }
+            return result;
+        }
+        catch (error) {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            if (attempt === retries) {
+                // 最后一次重试失败
+                if (error instanceof Error && error.name === 'AbortError') {
+                    throw new Error(`API请求超时: 请求在60秒内未完成`);
+                }
+                throw new Error(`API请求错误 (${attempt}/${retries}次重试后失败): ${error instanceof Error ? error.message : String(error)}`);
+            }
+            // 等待后重试，递增延迟时间
+            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000); // 指数退避，最大5秒
+            console.error(`第 ${attempt} 次请求失败，${delay / 1000}秒后重试: ${error instanceof Error ? error.message : String(error)}`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+}
+// 直接请求完整URL（用于自有查询服务）
+async function makeApiRequestRaw(url, method, body, retries = 3) {
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        let timeoutId;
+        try {
+            const controller = new AbortController();
+            timeoutId = setTimeout(() => controller.abort(), 60000);
+            const config = {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                signal: controller.signal,
+            };
+            if (body && method !== 'GET')
+                config.body = JSON.stringify(body);
+            console.error(`尝试第 ${attempt} 次请求: ${method} ${url}`);
+            const response = await (0, node_fetch_1.default)(url, config);
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API请求失败: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+            const result = await response.json();
+            console.error(`请求成功，响应数据:`, JSON.stringify(result, null, 2));
+            return result;
+        }
+        catch (error) {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (attempt === retries) {
+                if (error instanceof Error && error.name === 'AbortError') {
+                    throw new Error(`API请求超时: 请求在60秒内未完成`);
+                }
+                throw new Error(`API请求错误 (${attempt}/${retries}次重试后失败): ${error instanceof Error ? error.message : String(error)}`);
+            }
+            // 等待后重试，递增延迟时间
+            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000); // 指数退避，最大5秒
+            console.error(`第 ${attempt} 次请求失败，${delay / 1000}秒后重试: ${error instanceof Error ? error.message : String(error)}`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+}
+// 生成音乐处理函数
+async function handleGenerateMusic(input) {
+    try {
+        if (!input || typeof input !== 'object') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "输入参数格式错误，预期为包含prompt字段的对象。",
+            };
+        }
+        const { prompt, style = "", title = "", instrumental = false, model = "V4_5", negativeTags = "" } = input;
+        if (!prompt || typeof prompt !== 'string') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "prompt字段是必需的，且必须为字符串类型。",
+            };
+        }
+        // 验证prompt长度
+        const maxPromptLength = model === "V4_5" ? 5000 : 3000;
+        if (prompt.length > maxPromptLength) {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: `prompt长度超过限制。${model}模型最大允许${maxPromptLength}字符。`,
+            };
+        }
+        // 验证style长度
+        const maxStyleLength = model === "V4_5" ? 1000 : 200;
+        if (style.length > maxStyleLength) {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: `style长度超过限制。${model}模型最大允许${maxStyleLength}字符。`,
+            };
+        }
+        // 验证title长度
+        if (title.length > 80) {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "title长度超过限制，最大允许80字符。",
+            };
+        }
+        const callbackUrl = buildCallbackUrl("generate");
+        console.error(`使用回调地址: ${callbackUrl}`);
+        const requestBody = {
+            prompt,
+            style,
+            title,
+            customMode: true,
+            instrumental,
+            model,
+            negativeTags,
+            callBackUrl: callbackUrl, // 必需的参数
+        };
+        const result = await makeApiRequest('/generate', 'POST', requestBody);
+        const taskData = {
+            taskId: result.data?.taskId || result.taskId || result.id || result.task_id || "unknown",
+            status: "pending",
+            message: "音乐生成任务已提交，请使用query_progress工具查询进度。",
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify([taskData])
+                },
+            ],
+            isError: false,
+            errorMessage: "",
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("生成音乐时发生错误:", errorMessage);
+        return {
+            content: [],
+            isError: true,
+            errorMessage: `生成音乐失败: ${errorMessage}`,
+        };
+    }
+}
+// 翻唱音乐处理函数
+async function handleCoverMusic(input) {
+    try {
+        if (!input || typeof input !== 'object') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "输入参数格式错误，预期为包含uploadUrl和prompt字段的对象。",
+            };
+        }
+        const { uploadUrl, prompt, style = "", title = "", instrumental = false, model = "V4_5", negativeTags = "" } = input;
+        if (!uploadUrl || typeof uploadUrl !== 'string') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "uploadUrl字段是必需的，且必须为字符串类型。",
+            };
+        }
+        if (!prompt || typeof prompt !== 'string') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "prompt字段是必需的，且必须为字符串类型。",
+            };
+        }
+        const requestBody = {
+            uploadUrl,
+            prompt,
+            style,
+            title,
+            customMode: true,
+            instrumental,
+            model,
+            negativeTags,
+            callBackUrl: buildCallbackUrl("upload-cover"), // 必需的参数
+        };
+        const result = await makeApiRequest('/generate/upload-cover', 'POST', requestBody);
+        const taskData = {
+            taskId: result.data?.taskId || result.taskId || result.id || result.task_id || "unknown",
+            status: "pending",
+            message: "音乐翻唱任务已提交，请使用query_progress工具查询进度。",
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify([taskData])
+                },
+            ],
+            isError: false,
+            errorMessage: "",
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("翻唱音乐时发生错误:", errorMessage);
+        return {
+            content: [],
+            isError: true,
+            errorMessage: `翻唱音乐失败: ${errorMessage}`,
+        };
+    }
+}
+// 扩展音乐处理函数
+async function handleExtendMusic(input) {
+    try {
+        if (!input || typeof input !== 'object') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "输入参数格式错误，预期为包含uploadUrl、prompt和continueAt字段的对象。",
+            };
+        }
+        const { uploadUrl, prompt, style = "", title = "", continueAt, instrumental = false, model = "V4_5", negativeTags = "" } = input;
+        if (!uploadUrl || typeof uploadUrl !== 'string') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "uploadUrl字段是必需的，且必须为字符串类型。",
+            };
+        }
+        if (!prompt || typeof prompt !== 'string') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "prompt字段是必需的，且必须为字符串类型。",
+            };
+        }
+        if (typeof continueAt !== 'number' || continueAt <= 0) {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "continueAt字段是必需的，且必须为大于0的数字。",
+            };
+        }
+        const requestBody = {
+            uploadUrl,
+            defaultParamFlag: true,
+            instrumental,
+            prompt,
+            style,
+            title,
+            continueAt,
+            model,
+            negativeTags,
+            callBackUrl: buildCallbackUrl("upload-extend"), // 必需的参数
+        };
+        const result = await makeApiRequest('/generate/upload-extend', 'POST', requestBody);
+        const taskData = {
+            taskId: result.data?.taskId || result.taskId || result.id || result.task_id || "unknown",
+            status: "pending",
+            message: "音乐扩展任务已提交，请使用query_progress工具查询进度。",
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify([taskData])
+                },
+            ],
+            isError: false,
+            errorMessage: "",
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("扩展音乐时发生错误:", errorMessage);
+        return {
+            content: [],
+            isError: true,
+            errorMessage: `扩展音乐失败: ${errorMessage}`,
+        };
+    }
+}
+// 查询进度处理函数
+async function handleQueryProgress(input) {
+    try {
+        if (!input || typeof input !== 'object') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "输入参数格式错误，预期为包含taskId字段的对象。",
+            };
+        }
+        const { taskId } = input;
+        if (!taskId || typeof taskId !== 'string') {
+            return {
+                content: [],
+                isError: true,
+                errorMessage: "taskId字段是必需的，且必须为字符串类型。",
+            };
+        }
+        // 优先查询自有服务端，其次回退官方端点
+        const customBase = getQueryBase();
+        const endpoints = [
+            customBase ? `${customBase.replace(/\/$/, "")}/suno/task/${taskId}` : "",
+            `/generate/${taskId}`,
+            `/generate/details/${taskId}`,
+            `/task/${taskId}`,
+        ].filter(Boolean);
+        let result = null;
+        let lastError = null;
+        for (const ep of endpoints) {
+            try {
+                // 自有服务端点是完整URL，需要直接请求；官方端点仍走 API_BASE_URL
+                if (ep.startsWith('http')) {
+                    // 直接 fetch（沿用超时与头部设置）
+                    result = await makeApiRequestRaw(ep, 'GET');
+                }
+                else {
+                    result = await makeApiRequest(ep, 'GET');
+                }
+                if (result)
+                    break;
+            }
+            catch (e) {
+                lastError = e;
+                continue;
+            }
+        }
+        if (!result) {
+            throw new Error(`无法通过任何端点获取任务详情，taskId=${taskId}。${lastError instanceof Error ? lastError.message : String(lastError)}`);
+        }
+        // 使用自定义服务端的数据
+        if (result.code !== undefined && result.code === 0 && result.data) {
+            result = result.data;
+        }
+        // 解析任务状态，兼容自定义服务端的状态值
+        let status = result.status || 'unknown';
+        const progress = result.progress || 0;
+        // 状态值映射，兼容自定义服务端
+        if (status === 'completed')
+            status = 'complete';
+        if (status === 'running')
+            status = 'processing';
+        let statusMessage = "";
+        switch (status) {
+            case 'pending':
+                statusMessage = "任务排队中...";
+                break;
+            case 'processing':
+                statusMessage = "正在处理中...";
+                break;
+            case 'text':
+                statusMessage = "文本生成完成，正在生成音频...";
+                break;
+            case 'first':
+                statusMessage = "第一首音乐生成完成...";
+                break;
+            case 'complete':
+                statusMessage = "任务完成！";
+                break;
+            case 'failed':
+                statusMessage = "任务失败";
+                break;
+            default:
+                statusMessage = `状态: ${status}`;
+        }
+        const responseData = {
+            taskId,
+            status,
+            progress,
+            message: statusMessage,
+            result: status === 'complete' ? {
+                // 基本信息
+                taskId: result.taskId,
+                status: result.status,
+                prompt: result.prompt,
+                modelName: result.modelName,
+                title: result.title,
+                tags: result.tags,
+                duration: result.duration,
+                callbackType: result.callbackType,
+                taskCreateTime: result.taskCreateTime,
+                // 音频链接
+                audioUrl: result.audioUrl,
+                sourceAudioUrl: result.sourceAudioUrl,
+                streamAudioUrl: result.streamAudioUrl,
+                sourceStreamAudioUrl: result.sourceStreamAudioUrl,
+                // 图片链接
+                imageUrl: result.imageUrl,
+                sourceImageUrl: result.sourceImageUrl,
+                // 其他信息
+                musicId: result.musicId,
+                userUuid: result.userUuid,
+                errorMessage: result.errorMessage,
+                // 原始完整数据
+                rawData: result
+            } : null,
+        };
+        // 检查是否来自自定义服务端且返回错误
+        if (result.code !== undefined) {
+            // 自定义服务端格式：code 0=成功，其他=失败
+            if (result.code !== 0) {
+                // 如果是404错误，返回转换中状态而不是错误
+                if (result.data && result.data.status === 404) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify([{
+                                        taskId,
+                                        status: "pending",
+                                        progress: 0,
+                                        message: "任务正在处理中，请稍后再查询...",
+                                        result: null,
+                                    }])
+                            },
+                        ],
+                        isError: false,
+                        errorMessage: "",
+                    };
+                }
+                return {
+                    content: [],
+                    isError: true,
+                    errorMessage: `查询失败: ${result.msg || '未知错误'}`,
+                };
+            }
+            // 如果成功但data中有错误信息，也要处理
+            if (result.data && result.data.error) {
+                // 如果是404错误，返回转换中状态
+                if (result.data.status === 404) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify([{
+                                        taskId,
+                                        status: "pending",
+                                        progress: 0,
+                                        message: "任务正在处理中，请稍后再查询...",
+                                        result: null,
+                                    }])
+                            },
+                        ],
+                        isError: false,
+                        errorMessage: "",
+                    };
+                }
+                return {
+                    content: [],
+                    isError: true,
+                    errorMessage: `查询失败: ${result.data.error} - ${result.data.message || ''}`,
+                };
+            }
+            // 如果自定义服务端返回成功但没有实际数据，说明任务不存在或还在处理中
+            if (!result.data || Object.keys(result.data).length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify([{
+                                    taskId,
+                                    status: "pending",
+                                    progress: 0,
+                                    message: "任务正在处理中，请稍后再查询...",
+                                    result: null,
+                                }])
+                        },
+                    ],
+                    isError: false,
+                    errorMessage: "",
+                };
+            }
+            // 使用自定义服务端的数据
+            result = result.data || result;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify([responseData])
+                },
+            ],
+            isError: false,
+            errorMessage: "",
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("查询进度时发生错误:", errorMessage);
+        return {
+            content: [],
+            isError: true,
+            errorMessage: `查询进度失败: ${errorMessage}`,
+        };
+    }
+}
+// MCP 服务器配置与启动
+const server = new index_js_1.Server({
+    name: "mcp-ai-music",
+    version: "1.0.0",
+    description: "AI作曲MCP服务 - 基于Suno4.5 API的音乐生成、翻唱、扩展和进度查询工具"
+}, {
+    capabilities: {
+        tools: TOOLS.reduce((acc, tool) => {
+            acc[tool.name] = tool;
+            return acc;
+        }, {}),
+    },
+});
+// 注册请求处理器
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    try {
+        const toolName = request.params.name;
+        const toolInput = request.params.arguments;
+        console.error(`收到工具调用请求: ${toolName}, 输入: ${JSON.stringify(toolInput)}`);
+        switch (toolName) {
+            case GENERATE_MUSIC_TOOL.name:
+                return await handleGenerateMusic(toolInput);
+            case COVER_MUSIC_TOOL.name:
+                return await handleCoverMusic(toolInput);
+            case EXTEND_MUSIC_TOOL.name:
+                return await handleExtendMusic(toolInput);
+            case QUERY_PROGRESS_TOOL.name:
+                return await handleQueryProgress(toolInput);
+            default:
+                console.error(`未知的工具名称: ${toolName}`);
+                return {
+                    content: [],
+                    isError: true,
+                    errorMessage: `未找到名为 '${toolName}' 的工具。`,
+                };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("处理工具调用请求时发生严重错误:", errorMessage);
+        return {
+            content: [],
+            isError: true,
+            errorMessage: `处理请求时发生系统内部错误: ${errorMessage}`,
+        };
+    }
+});
+// 启动服务器
+async function runServer() {
+    try {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
+        console.error("MCP AI作曲服务已启动");
+        console.error(`已注册 ${TOOLS.length} 个工具: ${TOOLS.map((t) => t.name).join(", ")}`);
+        try {
+            getApiKey();
+            console.error("环境变量 SUNO_API_KEY: 已设置");
+        }
+        catch (error) {
+            console.error("环境变量 SUNO_API_KEY: 未设置");
+        }
+        console.error(`服务端基地址 SUNO_SERVICE_BASE(或兼容变量): ${getQueryBase() || "未设置(回调将报错/查询走官方)"}`);
+    }
+    catch (error) {
+        console.error("MCP 服务启动失败:", error);
+        process.exit(1);
+    }
+}
+runServer();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "mcp-ai-music",
+  "version": "1.0.0",
+  "description": "AI作曲MCP服务 - 基于Suno4.5 API的音乐生成、翻唱、扩展和进度查询工具",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "AI",
+    "music",
+    "composition",
+    "suno",
+    "mcp",
+    "audio",
+    "generation"
+  ],
+  "author": "",
+  "license": "ISC",
+  "bin": {
+    "mcp-ai-music": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.10.0",
+    "node-fetch": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "@types/node-fetch": "^2.6.12",
+    "typescript": "^5.8.3",
+    "ts-node": "^10.9.2"
+  }
+}