wwise-waapi-mcp 1.0.0

package/dist/src/core/transport.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStdioTransport = createStdioTransport;
+exports.startHttpSseServer = startHttpSseServer;
+const node_http_1 = __importDefault(require("node:http"));
+const node_crypto_1 = require("node:crypto");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+/**
+ * 创建基于标准输入输出的 MCP 传输层。
+ * 运行时通过 stdin/stdout 与 MCP 客户端通信。
+ */
+function createStdioTransport() {
+    return new stdio_js_1.StdioServerTransport();
+}
+/**
+ * 启动基于 Streamable HTTP（支持 SSE 流）的 MCP HTTP 服务器。
+ * 每个新会话会创建独立的服务器实例和传输层实例。
+ *
+ * 端点：POST/GET/DELETE http://<host>:<port>/mcp
+ *
+ * @param serverFactory  每次新会话时调用，返回已配置的 McpServer。
+ * @param port           监听端口，默认 3000。
+ * @param host           监听地址，默认 127.0.0.1。
+ */
+async function startHttpSseServer(serverFactory, port = 3000, host = "127.0.0.1") {
+    // session ID → transport；每个已初始化的会话在此映射中保留。
+    const sessions = new Map();
+    const httpServer = node_http_1.default.createServer(async (req, res) => {
+        const url = req.url ?? "/";
+        if (!url.startsWith("/mcp")) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Not found. Use /mcp endpoint." }));
+            return;
+        }
+        const sessionId = req.headers["mcp-session-id"];
+        try {
+            if (req.method === "POST") {
+                if (sessionId && sessions.has(sessionId)) {
+                    // 已有会话 — 转发给对应传输层
+                    await sessions.get(sessionId).handleRequest(req, res);
+                }
+                else if (!sessionId) {
+                    // 新会话 — 初始化请求（无 session ID）
+                    const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+                        onsessioninitialized: (id) => {
+                            sessions.set(id, transport);
+                        },
+                        onsessionclosed: (id) => {
+                            sessions.delete(id);
+                        },
+                    });
+                    const server = serverFactory();
+                    await server.connect(transport);
+                    await transport.handleRequest(req, res);
+                }
+                else {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Session not found." }));
+                }
+            }
+            else if (req.method === "GET" || req.method === "DELETE") {
+                if (!sessionId || !sessions.has(sessionId)) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Valid mcp-session-id header required." }));
+                    return;
+                }
+                await sessions.get(sessionId).handleRequest(req, res);
+            }
+            else {
+                res.writeHead(405, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Method not allowed." }));
+            }
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Internal server error." }));
+            }
+            console.error("HTTP/SSE request error:", err);
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(port, host, resolve);
+    });
+    console.error(`Wwise MCP server is running on HTTP/SSE at http://${host}:${port}/mcp`);
+}

package/dist/src/domains/audio/tools.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioTools = getAudioTools;
+const v4_1 = require("zod/v4");
+const toolFactory_js_1 = require("../../lib/toolFactory.js");
+/**
+ * 音频文件和采样展示工具（ak.wwise.core.audio.*）。
+ * 包括音频导入、映射模笓及静音控制，均需要 WAAPI 连接。
+ * 导入和静音操作为高风险，展示已导入音频的操作为中风险。
+ */
+function getAudioTools() {
+    return [
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audio.import",
+            title: "Import Audio",
+            description: "Import one or more audio files into the Wwise project.",
+            domain: "audio",
+            risk: "high",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "audio", "import", "stub"],
+            examples: [{ title: "Import one wav file", input: { imports: [{ audioFile: "C:/audio/footstep.wav", objectPath: "\\Actor-Mixer Hierarchy\\Default Work Unit\\Footsteps<Sound SFX>" }] } }],
+            inputSchema: {
+                imports: v4_1.z.array(v4_1.z.unknown()).min(1),
+                importOperation: v4_1.z.string().optional(),
+                default: v4_1.z.unknown().optional(),
+                autoAddToSourceControl: v4_1.z.boolean().optional(),
+                autoCheckOutToSourceControl: v4_1.z.boolean().optional(),
+                options: v4_1.z.unknown().optional()
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    importOperation: { type: "string" },
+                    imports: { type: "array", minItems: 1, items: {} },
+                    default: {},
+                    autoAddToSourceControl: { type: "boolean" },
+                    autoCheckOutToSourceControl: { type: "boolean" },
+                    options: {}
+                },
+                required: ["imports"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audio.mute",
+            title: "Mute Object",
+            description: "Mute one or more Wwise audio objects in the authoring tool.",
+            domain: "audio",
+            risk: "medium",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "audio", "mute", "stub"],
+            examples: [{ title: "Mute selected objects", input: { objects: ["{GUID}"] } }],
+            inputSchema: {
+                objects: v4_1.z.array(v4_1.z.union([v4_1.z.string(), v4_1.z.number().int()])).min(1),
+                options: v4_1.z.unknown().optional()
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    objects: { type: "array", minItems: 1, items: { oneOf: [{ type: "string" }, { type: "integer" }] } },
+                    options: {}
+                },
+                required: ["objects"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audioSourcePeaks.getMinMaxPeaksInRegion",
+            title: "Get Source Peaks",
+            description: "Fetch peak values for a source region.",
+            domain: "audio",
+            risk: "low",
+            permissions: ["waapi:authoring:read"],
+            tags: ["waapi", "audio", "analysis", "stub"],
+            examples: [{ title: "Inspect a source region", input: { audioSource: "{GUID}", start: 0, end: 1000 } }],
+            inputSchema: {
+                audioSource: v4_1.z.string().min(1),
+                start: v4_1.z.number().nonnegative(),
+                end: v4_1.z.number().positive(),
+                options: v4_1.z.unknown().optional()
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    audioSource: { type: "string", minLength: 1 },
+                    start: { type: "number", minimum: 0 },
+                    end: { type: "number", exclusiveMinimum: 0 },
+                    options: {}
+                },
+                required: ["audioSource", "start", "end"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audio.resetMute",
+            title: "Reset Mute",
+            description: "Unmute all objects that were muted via WAAPI.",
+            domain: "audio",
+            risk: "medium",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "audio", "mute"],
+            examples: [{ title: "Reset all mutes" }],
+            inputSchemaJson: { type: "object", properties: {}, additionalProperties: false }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audio.resetSolo",
+            title: "Reset Solo",
+            description: "Unsolo all objects that were soloed via WAAPI.",
+            domain: "audio",
+            risk: "medium",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "audio", "solo"],
+            examples: [{ title: "Reset all solos" }],
+            inputSchemaJson: { type: "object", properties: {}, additionalProperties: false }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audio.solo",
+            title: "Solo Objects",
+            description: "Solo or unsolo one or more Wwise objects.",
+            domain: "audio",
+            risk: "medium",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "audio", "solo"],
+            examples: [{ title: "Solo a sound", input: { objects: ["{GUID}"], value: true } }],
+            inputSchema: { objects: v4_1.z.array(v4_1.z.string().min(1)).min(1), value: v4_1.z.boolean() },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    objects: { type: "array", minItems: 1, items: { type: "string", minLength: 1 } },
+                    value: { type: "boolean" }, options: {}
+                },
+                required: ["objects", "value"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audio.importTabDelimited",
+            title: "Import Tab-Delimited",
+            description: "Import audio files using a tab-delimited import file.",
+            domain: "audio",
+            risk: "high",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "audio", "import"],
+            examples: [{ title: "Import tab file", input: { importLanguage: "SFX", importOperation: "createNew", importFile: "C:/audio/batch.txt" } }],
+            inputSchema: {
+                importLanguage: v4_1.z.string().min(1),
+                importOperation: v4_1.z.enum(["createNew", "useExisting", "replaceExisting"]),
+                importFile: v4_1.z.string().min(1),
+                importLocation: v4_1.z.string().optional(),
+                autoAddToSourceControl: v4_1.z.boolean().optional(),
+                autoCheckOutToSourceControl: v4_1.z.boolean().optional()
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    importLanguage: { type: "string", minLength: 1 },
+                    importOperation: { type: "string", enum: ["createNew", "useExisting", "replaceExisting"] },
+                    importFile: { type: "string", minLength: 1 },
+                    importLocation: { type: "string" },
+                    autoAddToSourceControl: { type: "boolean" },
+                    autoCheckOutToSourceControl: { type: "boolean" }, options: {}
+                },
+                required: ["importLanguage", "importOperation", "importFile"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.audioSourcePeaks.getMinMaxPeaksInTrimmedRegion",
+            title: "Get Min/Max Peaks in Trimmed Region",
+            description: "Get the min/max peak pairs within the trimmed active region of an audio source.",
+            domain: "audio",
+            risk: "low",
+            permissions: ["waapi:authoring:read"],
+            tags: ["waapi", "audio", "peaks", "waveform"],
+            examples: [{ title: "Sample 100 peaks in trim region", input: { object: "{GUID}", numPeaks: 100 } }],
+            inputSchema: {
+                object: v4_1.z.string().min(1),
+                numPeaks: v4_1.z.number().int().min(1),
+                getCrossChannelPeaks: v4_1.z.boolean().optional()
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    object: { type: "string", minLength: 1 },
+                    numPeaks: { type: "integer", minimum: 1 },
+                    getCrossChannelPeaks: { type: "boolean" }, options: {}
+                },
+                required: ["object", "numPeaks"],
+                additionalProperties: false
+            }
+        })
+    ];
+}

package/dist/src/domains/catalog/tools.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCatalogTools = getCatalogTools;
+const v4_1 = require("zod/v4");
+const response_js_1 = require("../../lib/response.js");
+const referenceCatalog_js_1 = require("../../lib/referenceCatalog.js");
+const errors_js_1 = require("../../lib/errors.js");
+/**
+ * 返回进展式揭露工具列表。
+ * 这些工具不需要 WAAPI 连接，内部直接操作注册表和参考目录。
+ *
+ * 发现工具（暴露到 MCP）：
+ * - catalog.listDomains: 提供领域摘要
+ * - catalog.listTools: 提供指定领域下的工具列表
+ * - catalog.getToolSchema: 按需加载并返回单个工具的完整 schema 详情
+ * - catalog.executeTool: 动态执行任何已注册的工具（实现渐进式执行）
+ */
+function getCatalogTools(registry) {
+    return [
+        {
+            name: "catalog.listDomains",
+            title: "List Domains",
+            description: "Return domain-level discovery summaries for progressive tool disclosure.",
+            domain: "catalog",
+            risk: "low",
+            permissions: [],
+            tags: ["catalog", "discovery"],
+            examples: [
+                {
+                    title: "List all available domains"
+                }
+            ],
+            implementationStatus: "implemented",
+            callable: true,
+            isDiscoveryTool: true,
+            outputSchemaJson: response_js_1.standardResponseJsonSchema,
+            handler: async () => {
+                return (0, response_js_1.ok)({
+                    domains: registry.listDomains()
+                });
+            }
+        },
+        {
+            name: "catalog.listTools",
+            title: "List Tools",
+            description: "Return implemented and reference-discovered tools for a specific domain.",
+            domain: "catalog",
+            risk: "low",
+            permissions: [],
+            tags: ["catalog", "discovery"],
+            examples: [
+                {
+                    title: "List object-domain tools",
+                    input: {
+                        domain: "object",
+                        includePlanned: true
+                    }
+                }
+            ],
+            implementationStatus: "implemented",
+            callable: true,
+            isDiscoveryTool: true,
+            inputSchema: {
+                domain: v4_1.z.string().min(1).describe("Domain name, for example object or soundengine."),
+                includePlanned: v4_1.z.boolean().optional().describe("Whether reference-only tools should be included.")
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    domain: { type: "string", minLength: 1 },
+                    includePlanned: { type: "boolean" }
+                },
+                required: ["domain"],
+                additionalProperties: false
+            },
+            outputSchemaJson: response_js_1.standardResponseJsonSchema,
+            handler: async (rawArgs) => {
+                const args = rawArgs;
+                const domain = registry.getDomain(args.domain);
+                if (!domain) {
+                    return (0, response_js_1.fail)("domain_not_found", `Unknown domain: ${args.domain}`);
+                }
+                return (0, response_js_1.ok)({
+                    domain,
+                    tools: registry.listTools(args.domain, undefined, args.includePlanned ?? true)
+                });
+            }
+        },
+        {
+            name: "catalog.getToolSchema",
+            title: "Get Tool Schema",
+            description: "Return schema and reference help for one implemented or planned tool.",
+            domain: "catalog",
+            risk: "low",
+            permissions: [],
+            tags: ["catalog", "discovery", "schema"],
+            examples: [
+                {
+                    title: "Inspect a registered WAAPI scaffold",
+                    input: {
+                        toolName: "ak.soundengine.postEvent"
+                    }
+                }
+            ],
+            implementationStatus: "implemented",
+            callable: true,
+            isDiscoveryTool: true,
+            inputSchema: {
+                toolName: v4_1.z.string().min(1).describe("Exact tool name.")
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    toolName: { type: "string", minLength: 1 }
+                },
+                required: ["toolName"],
+                additionalProperties: false
+            },
+            outputSchemaJson: response_js_1.standardResponseJsonSchema,
+            handler: async (rawArgs) => {
+                const args = rawArgs;
+                const tool = registry.getCallableTool(args.toolName);
+                const discovery = registry.getToolDiscovery(args.toolName);
+                if (!discovery) {
+                    return (0, response_js_1.fail)("tool_not_found", `Unknown tool: ${args.toolName}`);
+                }
+                const referenceDocument = (0, referenceCatalog_js_1.loadReferenceDocument)(args.toolName);
+                return (0, response_js_1.ok)({
+                    tool: discovery,
+                    schemas: {
+                        input: tool?.inputSchemaJson,
+                        output: tool?.outputSchemaJson,
+                        reference: referenceDocument ? (0, referenceCatalog_js_1.extractReferenceSummary)(referenceDocument) : null
+                    }
+                });
+            }
+        },
+        {
+            name: "catalog.executeTool",
+            title: "Execute Tool",
+            description: "Dynamically execute any registered tool by name with the provided arguments. This is the unified execution interface for progressive tool disclosure.",
+            domain: "catalog",
+            risk: "medium",
+            permissions: [],
+            tags: ["catalog", "execution"],
+            examples: [
+                {
+                    title: "Execute a tool discovered via catalog.listTools",
+                    input: {
+                        toolName: "ak.soundengine.postEvent",
+                        arguments: {
+                            gameObject: "Player",
+                            eventName: "Play_Music"
+                        }
+                    }
+                }
+            ],
+            implementationStatus: "implemented",
+            callable: true,
+            isDiscoveryTool: true,
+            inputSchema: {
+                toolName: v4_1.z.string().min(1).describe("The exact name of the tool to execute."),
+                arguments: v4_1.z.record(v4_1.z.string(), v4_1.z.unknown()).optional().describe("Arguments to pass to the tool. Must match the tool's inputSchema.")
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    toolName: { type: "string", minLength: 1 },
+                    arguments: { type: "object", additionalProperties: true }
+                },
+                required: ["toolName"],
+                additionalProperties: false
+            },
+            outputSchemaJson: response_js_1.standardResponseJsonSchema,
+            handler: async (rawArgs) => {
+                const args = rawArgs;
+                const tool = registry.getCallableTool(args.toolName);
+                if (!tool) {
+                    return (0, response_js_1.fail)("tool_not_found", `Tool not found: ${args.toolName}. Use catalog.listTools to discover available tools.`);
+                }
+                if (!tool.handler) {
+                    return (0, response_js_1.fail)("tool_not_executable", `Tool ${args.toolName} is not executable. It may be in planned status.`);
+                }
+                if (!tool.callable) {
+                    return (0, response_js_1.fail)("tool_not_callable", `Tool ${args.toolName} is not callable.`);
+                }
+                try {
+                    const result = await tool.handler(args.arguments, undefined);
+                    return result;
+                }
+                catch (error) {
+                    // Delegate to toFailureResponse which properly handles AppError with preserved codes
+                    return (0, errors_js_1.toFailureResponse)(error);
+                }
+            }
+        }
+    ];
+}

package/dist/src/domains/debug/tools.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDebugTools = getDebugTools;
+const v4_1 = require("zod/v4");
+const toolFactory_js_1 = require("../../lib/toolFactory.js");
+/**
+ * Wwise 调试工具（ak.wwise.debug.*）。
+ * 支持读取 WAL 树结构和清除持久化内存，均需要 WAAPI 连接。
+ */
+function getDebugTools() {
+    return [
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.debug.getWalTree",
+            title: "Get WAL Tree",
+            description: "Read the debug WAL tree structure.",
+            domain: "debug",
+            risk: "medium",
+            permissions: ["waapi:debug"],
+            tags: ["waapi", "debug", "stub"],
+            examples: [{ title: "Read WAL tree" }],
+            inputSchemaJson: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.cli.generateSoundbank",
+            title: "CLI Generate SoundBank",
+            description: "Run the CLI SoundBank generation operation.",
+            domain: "debug",
+            risk: "high",
+            permissions: ["waapi:cli"],
+            tags: ["waapi", "cli", "soundbank", "stub"],
+            examples: [{ title: "Generate SoundBanks via CLI", input: { project: "C:/Projects/GameAudio/GameAudio.wproj" } }],
+            inputSchema: {
+                project: v4_1.z.string().min(1)
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    project: { type: "string", minLength: 1 }
+                },
+                required: ["project"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.executeLuaScript",
+            title: "Execute Lua Script",
+            description: "Execute a Lua script in the Wwise authoring environment.",
+            domain: "debug",
+            risk: "high",
+            permissions: ["waapi:authoring:write", "waapi:debug"],
+            tags: ["waapi", "lua", "debug", "stub"],
+            examples: [{ title: "Execute inline Lua", input: { script: 'print("hello")' } }],
+            inputSchema: {
+                script: v4_1.z.string().min(1)
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    script: { type: "string", minLength: 1 }
+                },
+                required: ["script"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.debug.enableAsserts",
+            title: "Enable Asserts",
+            description: "Enable or disable Wwise debug assertions.",
+            domain: "debug",
+            risk: "high",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "debug"],
+            examples: [{ title: "Enable debug asserts", input: { enable: true } }],
+            inputSchema: { enable: v4_1.z.boolean() },
+            inputSchemaJson: { type: "object", properties: { enable: { type: "boolean" }, options: {} }, required: ["enable"], additionalProperties: false }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.debug.enableAutomationMode",
+            title: "Enable Automation Mode",
+            description: "Enable or disable automation mode in Wwise (suppresses UI dialogs).",
+            domain: "debug",
+            risk: "high",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "debug", "automation"],
+            examples: [{ title: "Enable automation mode", input: { enable: true } }],
+            inputSchema: { enable: v4_1.z.boolean() },
+            inputSchemaJson: { type: "object", properties: { enable: { type: "boolean" }, options: {} }, required: ["enable"], additionalProperties: false }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.debug.generateToneWAV",
+            title: "Generate Tone WAV",
+            description: "Generate a WAV tone file for testing purposes.",
+            domain: "debug",
+            risk: "medium",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "debug", "audio"],
+            examples: [{ title: "Generate a 440 Hz sine wave", input: { path: "C:/temp/tone.wav", frequency: 440 } }],
+            inputSchema: {
+                path: v4_1.z.string().min(1),
+                bitDepth: v4_1.z.number().int().optional(),
+                sampleRate: v4_1.z.number().int().optional(),
+                sustainTime: v4_1.z.number().optional(),
+                sustainLevel: v4_1.z.number().optional(),
+                attackTime: v4_1.z.number().optional(),
+                releaseTime: v4_1.z.number().optional(),
+                waveform: v4_1.z.enum(["sine", "square", "triangle", "sawtooth", "whiteNoise", "pinkNoise"]).optional(),
+                frequency: v4_1.z.number().optional()
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    path: { type: "string", minLength: 1 },
+                    bitDepth: { type: "integer" }, sampleRate: { type: "integer" },
+                    sustainTime: { type: "number" }, sustainLevel: { type: "number" },
+                    attackTime: { type: "number" }, releaseTime: { type: "number" },
+                    waveform: { type: "string", enum: ["sine", "square", "triangle", "sawtooth", "whiteNoise", "pinkNoise"] },
+                    frequency: { type: "number" }, options: {}
+                },
+                required: ["path"],
+                additionalProperties: false
+            }
+        }),
+        (0, toolFactory_js_1.createWaapiStubTool)({
+            name: "ak.wwise.core.debug.restartWaapiServers",
+            title: "Restart WAAPI Servers",
+            description: "Restart the WAAPI server endpoint inside Wwise Authoring.",
+            domain: "debug",
+            risk: "high",
+            permissions: ["waapi:authoring:write"],
+            tags: ["waapi", "debug"],
+            examples: [{ title: "Restart WAAPI servers" }],
+            inputSchemaJson: { type: "object", properties: {}, additionalProperties: false }
+        })
+    ];
+}

package/dist/src/domains/example/tools.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExampleTools = getExampleTools;
+const v4_1 = require("zod/v4");
+const response_js_1 = require("../../lib/response.js");
+/**
+ * 示例领域工具，用于演示如何添加新工具。
+ * 这些工具不调用 WAAPI，可在离线状态下正常运行。
+ */
+function getExampleTools() {
+    return [
+        {
+            name: "example.echo",
+            title: "Echo Message",
+            description: "Example business-domain tool used to demonstrate how to add a new domain.",
+            domain: "example",
+            risk: "low",
+            permissions: [],
+            tags: ["example", "sample"],
+            examples: [
+                {
+                    title: "Echo and uppercase a value",
+                    input: {
+                        message: "hello wwise",
+                        uppercase: true
+                    }
+                }
+            ],
+            implementationStatus: "implemented",
+            callable: true,
+            inputSchema: {
+                message: v4_1.z.string().min(1).describe("Text to echo back."),
+                uppercase: v4_1.z.boolean().optional().describe("Whether to uppercase the echoed text.")
+            },
+            inputSchemaJson: {
+                type: "object",
+                properties: {
+                    message: { type: "string", minLength: 1 },
+                    uppercase: { type: "boolean" }
+                },
+                required: ["message"],
+                additionalProperties: false
+            },
+            outputSchemaJson: response_js_1.standardResponseJsonSchema,
+            handler: async (rawArgs) => {
+                const args = rawArgs;
+                const echoed = args.uppercase ? args.message.toUpperCase() : args.message;
+                return (0, response_js_1.ok)({
+                    message: echoed,
+                    original: args.message,
+                    domain: "example"
+                });
+            }
+        }
+    ];
+}