@rse/ase 0.0.50 → 0.0.51

package/dst/ase-setup.js

@@ -8,6 +8,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { execa } from "execa";
 import which from "which";
+import * as dotenvx from "@dotenvx/dotenvx";
+import Table from "cli-table3";
+import chalk from "chalk";
 import Version from "./ase-version.js";
 const toolSpecs = {
     "claude": { cli: "claude", label: "Claude Code" },
@@ -96,7 +99,8 @@ export default class SetupCommand {
     /*  run a sub-process, suppressing output on success and emitting it on failure  */
     async run(cmd, args, opts = {}) {
         const { cwd, quiet = false, retries = 1, ignoreError } = opts;
-        this.log.write("info", `setup: $ ${cmd} ${args.join(" ")}` +
+        const argsLog = args.map((arg) => arg.replace(/(_KEY=)(\S+)/, (_, k, v) => k + "*".repeat(v.length)));
+        this.log.write("info", `setup: $ ${cmd} ${argsLog.join(" ")}` +
             (cwd !== undefined ? ` (cwd: ${cwd})` : ""));
         for (let i = 0; i < retries; i++) {
             const final = (i === retries - 1);
@@ -240,6 +244,416 @@ export default class SetupCommand {
         }
         return 0;
     }
+    /*  handler for "ase setup mcp list"  */
+    async doMcpList() {
+        const table = new Table({
+            head: ["ID", "NAME", "VERS", "MCP", "KEY", "SKILLS"],
+            colWidths: [16, 16, 8, 21, 17, 20],
+            wordWrap: true,
+            chars: { "mid": "", "left-mid": "", "mid-mid": "", "right-mid": "" },
+            style: { head: ["blue"] }
+        });
+        for (const handle of this.mcpServers)
+            table.push([
+                chalk.bold(handle.id),
+                handle.name,
+                handle.version ?? "(unknown)",
+                handle.server,
+                handle.env.join(", "),
+                handle.skills.join(", ")
+            ]);
+        process.stdout.write(`${table.toString()}\n`);
+        return 0;
+    }
+    /*  handler for "ase setup mcp activate|deactivate [<servers>]"  */
+    async doMcp(action, tool, servers) {
+        await this.ensureTool(toolSpecs[tool].cli);
+        /*  source .env files into the environment so the per-server
+            API keys (ASE_MCP_KEY_<XXX>) can live in a .env file instead
+            of the exported interactive shell environment  */
+        dotenvx.config({ quiet: true, ignore: ["MISSING_ENV_FILE"] });
+        /*  resolve the comma-separated list of server ids, with an empty
+            list or the literal "all" expanding to every registered server
+            id; track whether the ids were explicitly given on the CLI  */
+        const known = this.mcpServers.map((handle) => handle.id);
+        const explicit = servers.trim() !== "" && servers.trim() !== "all";
+        const ids = explicit ?
+            servers.split(",").map((s) => s.trim()).filter((s) => s !== "") : known;
+        for (const id of ids)
+            if (this.mcpServers.find((handle) => handle.id === id) === undefined)
+                throw new Error(`unknown MCP server "${id}" ` +
+                    `(known: ${known.join(", ")})`);
+        /*  dispatch each selected server to its dedicated handler  */
+        for (const id of ids) {
+            /*  find handle  */
+            const handle = this.mcpServers.find((handle) => handle.id === id);
+            /*  determine information and action  */
+            let envKey = "";
+            let envVal = "";
+            if (action === "activate") {
+                /*  on activation, require at least one of the per-server API
+                    key environment variables (ASE_MCP_KEY_<XXX>) to
+                    be set; skip the server when its id was only
+                    implicitly selected (empty list or "all"), but fail
+                    hard when it was given explicitly on the CLI  */
+                envKey = handle.env.find((name) => (process.env[`ASE_MCP_KEY_${name}`] ?? "") !== "") ?? "";
+                if (envKey === "") {
+                    const vars = handle.env.map((name) => `ASE_MCP_KEY_${name}`).join(", ");
+                    if (explicit)
+                        throw new Error(`none of ${vars} set: ` +
+                            `cannot activate MCP server "${handle.server}"`);
+                    this.log.write("info", `setup: mcp: activate: [${id}]: none of ${vars} set: ` +
+                        `skipping MCP server "${handle.server}" (${handle.name})`);
+                    continue;
+                }
+                envVal = process.env[`ASE_MCP_KEY_${envKey}`] ?? "";
+            }
+            /*  probe whether the MCP server is currently registered with the tool  */
+            const installed = await this.mcpInstalled(tool, handle.server);
+            if (action === "activate") {
+                /*  on activation, remove a stale registration first so the
+                    handler can re-create it cleanly  */
+                if (installed) {
+                    this.log.write("info", `setup: mcp: activate: [${id}]: MCP server "${handle.server}" ` +
+                        "already registered: removing stale registration first");
+                    await this.mcpRemove(tool, handle.server);
+                }
+            }
+            else if (!installed) {
+                /*  on deactivation, skip the removal of an absent server  */
+                this.log.write("info", `setup: mcp: deactivate: [${id}]: MCP server "${handle.server}" ` +
+                    "not registered: skipping removal");
+                continue;
+            }
+            /*  call the handler  */
+            this.log.write("info", `setup: mcp: ${action}: [${id}]: MCP server "${handle.server}" ` +
+                `(name: ${handle.name}${handle.version ? (", version: " + handle.version) : ""})`);
+            await handle.handler(handle, tool, action, envKey, envVal);
+        }
+        return 0;
+    }
+    /*  probe whether an MCP server is currently registered with the tool
+        by inspecting the exit code of "<cli> mcp get <name>"  */
+    async mcpInstalled(tool, name) {
+        const result = await execa(toolSpecs[tool].cli, ["mcp", "get", name], { stdio: "ignore", reject: false });
+        return result.exitCode === 0;
+    }
+    /*  register an MCP server with the tool, supporting both the "stdio"
+        (a local subprocess command) and "http" (a remote URL, optionally
+        with HTTP headers) transports; the per-tool command line differs
+        between Claude Code and GitHub Copilot CLI  */
+    async mcpAdd(tool, name, env, transport) {
+        const args = ["mcp", "add"];
+        if (tool === "claude") {
+            args.push("--scope", "user");
+            args.push("--transport", transport.type);
+            if (transport.type === "stdio") {
+                for (const [key, val] of Object.entries(env))
+                    args.push("-e", `${key}=${val}`);
+                args.push("--", name, ...transport.command);
+            }
+            else {
+                for (const [key, val] of Object.entries(transport.headers ?? {}))
+                    args.push("--header", `${key}: ${val}`);
+                args.push(name, transport.url);
+            }
+        }
+        else {
+            /*  GitHub Copilot CLI implies the stdio transport when the
+                command is provided after "--"; only "http"/"sse" servers
+                need an explicit "--transport" flag and take the URL as a
+                positional argument  */
+            if (transport.type === "stdio") {
+                args.push(name);
+                for (const [key, val] of Object.entries(env))
+                    args.push("--env", `${key}=${val}`);
+                args.push("--", ...transport.command);
+            }
+            else {
+                args.push("--transport", "http");
+                for (const [key, val] of Object.entries(transport.headers ?? {}))
+                    args.push("--header", `${key}: ${val}`);
+                args.push(name, transport.url);
+            }
+        }
+        await this.run(toolSpecs[tool].cli, args);
+    }
+    /*  unregister an MCP server from the tool; the per-tool command line
+        differs between Claude Code and GitHub Copilot CLI  */
+    async mcpRemove(tool, name) {
+        const args = tool === "claude" ?
+            ["mcp", "remove", "--scope", "user", name] :
+            ["mcp", "remove", name];
+        await this.run(toolSpecs[tool].cli, args, { ignoreError: `MCP server "${name}" not registered` });
+    }
+    /*  registry of pre-defined MCP servers: maps each server id onto its
+        dedicated handler which performs the activate/deactivate operation  */
+    mcpServers = [
+        {
+            id: "openai-chatgpt",
+            name: "OpenAI ChatGPT",
+            version: "5.5",
+            env: ["OPENAI_CHATGPT", "OPENROUTER"],
+            server: "chat-openai-chatgpt",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "openai/gpt-5.5"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.openai.com/v1",
+                                "--openai-api", "responses",
+                                "--openai-model", "gpt-5.5"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "google-gemini",
+            name: "Google Gemini",
+            version: "3.5",
+            env: ["GOOGLE_GEMINI", "OPENROUTER"],
+            server: "chat-google-gemini",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "google/gemini-3.5-flash"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://generativelanguage.googleapis.com/v1beta/openai/",
+                                "--openai-api", "completion",
+                                "--openai-model", "gemini-3.5-flash"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "deepseek",
+            name: "DeepSeek",
+            version: "4.0",
+            env: ["DEEPSEEK", "OPENROUTER"],
+            server: "chat-deepseek",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio",
+                            command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "deepseek/deepseek-v4-flash"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.deepseek.com/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "deepseek-v4-flash"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "xai-grok",
+            name: "xAI Grok",
+            version: "4.3",
+            env: ["XAI_GROK", "OPENROUTER"],
+            server: "chat-xai-grok",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "x-ai/grok-4.3"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.x.ai/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "grok-4.3"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "alibaba-qwen",
+            name: "Alibaba Qwen",
+            version: "3.7",
+            env: ["ALIBABA_QWEN", "OPENROUTER"],
+            server: "chat-alibaba-qwen",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "qwen/qwen3.7-max"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://dashscope.aliyuncs.com/compatible-mode/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "qwen3.7-max"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "zai-glm",
+            name: "Z.AI GLM",
+            version: "5.1",
+            env: ["ZAI_GLM", "OPENROUTER"],
+            server: "chat-zai-glm",
+            skills: ["ase-meta-chat", "ase-meta-quorum"],
+            handler: async (spec, tool, action, envKey, envVal) => {
+                if (action === "activate") {
+                    if (envKey === "OPENROUTER")
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://openrouter.ai/api/v1",
+                                "--openai-api", "completion",
+                                "--openai-model", "z-ai/glm-5.1"
+                            ]
+                        });
+                    else
+                        await this.mcpAdd(tool, spec.server, { OPENAI_KEY: envVal }, {
+                            type: "stdio", command: [
+                                "npx", "-y", "mcp-to-openai",
+                                "--service", spec.name,
+                                "--mcp-tool", "query",
+                                "--openai-url", "https://api.z.ai/api/paas/v4/",
+                                "--openai-api", "completion",
+                                "--openai-model", "glm-5.1"
+                            ]
+                        });
+                }
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "brave",
+            name: "Brave",
+            version: "latest",
+            env: ["BRAVE"],
+            server: "search-brave",
+            skills: ["ase-meta-search", "ase-meta-evaluate", "ase-arch-discover"],
+            handler: async (spec, tool, action, _envKey, envVal) => {
+                if (action === "activate")
+                    await this.mcpAdd(tool, spec.server, {
+                        "BRAVE_API_KEY": envVal,
+                        "BRAVE_MCP_ENABLED_TOOLS": "brave_web_search"
+                    }, { type: "stdio", command: ["npx", "-y", "@brave/brave-search-mcp-server"] });
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "perplexity",
+            name: "Perplexity",
+            version: "latest",
+            env: ["PERPLEXITY"],
+            server: "search-perplexity",
+            skills: ["ase-meta-search", "ase-meta-evaluate", "ase-arch-discover"],
+            handler: async (spec, tool, action, _envKey, envVal) => {
+                if (action === "activate")
+                    await this.mcpAdd(tool, spec.server, {
+                        "PERPLEXITY_API_KEY": envVal
+                    }, { type: "stdio", command: ["npx", "-y", "@perplexity-ai/mcp-server"] });
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        },
+        {
+            id: "exa",
+            name: "Exa",
+            version: "latest",
+            env: ["EXA"],
+            server: "search-exa",
+            skills: ["ase-meta-search", "ase-meta-evaluate", "ase-arch-discover"],
+            handler: async (spec, tool, action, _envKey, envVal) => {
+                if (action === "activate")
+                    await this.mcpAdd(tool, spec.server, {}, { type: "http", url: `https://mcp.exa.ai/mcp?exaApiKey=${envVal}` });
+                else
+                    await this.mcpRemove(tool, spec.server);
+            }
+        }
+    ];
     /*  parse and validate the --tool option  */
     parseTool(value) {
         if (value !== "claude" && value !== "copilot")
@@ -306,5 +720,36 @@ export default class SetupCommand {
             .action(async (opts) => {
             process.exit(await this.doDisable(this.parseTool(opts.tool)));
         });
+        /*  register CLI sub-command "ase setup mcp"  */
+        const mcpCmd = setupCmd
+            .command("mcp")
+            .description("activate or deactivate pre-defined MCP servers for a tool")
+            .action(() => {
+            mcpCmd.outputHelp();
+            process.exit(1);
+        });
+        /*  register CLI sub-command "ase setup mcp list"  */
+        mcpCmd
+            .command("list")
+            .description("list all available pre-defined MCP server names")
+            .action(async () => {
+            process.exit(await this.doMcpList());
+        });
+        /*  register CLI sub-command "ase setup mcp activate"  */
+        mcpCmd
+            .command("activate [servers]")
+            .description("activate pre-defined MCP servers (comma-separated list, or \"all\")")
+            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .action(async (servers, opts) => {
+            process.exit(await this.doMcp("activate", this.parseTool(opts.tool), servers ?? "all"));
+        });
+        /*  register CLI sub-command "ase setup mcp deactivate"  */
+        mcpCmd
+            .command("deactivate [servers]")
+            .description("deactivate pre-defined MCP servers (comma-separated list, or \"all\")")
+            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .action(async (servers, opts) => {
+            process.exit(await this.doMcp("deactivate", this.parseTool(opts.tool), servers ?? "all"));
+        });
     }
 }

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.0.50",
+    "version":                              "0.0.51",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -41,6 +41,7 @@
     },
     "dependencies": {
         "commander":                        "14.0.3",
+        "@dotenvx/dotenvx":                 "1.68.1",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.0",
         "execa":                            "9.6.1",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.0.50",
+    "version":     "0.0.51",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.github/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.0.50",
+    "version":     "0.0.51",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/agents/ase-meta-chat.md

@@ -1,43 +1,54 @@
 ---
 name: ase-meta-chat
 description: "Query Foreign LLM for Chat via MCP Tool"
-effort: low
+effort: high
 tools:
-    - "mcp__chat-openai-chatgpt__chat-with-openai-chatgpt"
-    - "mcp__chat-google-gemini__chat-with-google-gemini"
-    - "mcp__chat-deepseek__chat-with-deepseek"
-    - "mcp__chat-xai-grok__chat-with-xai-grok"
+    - mcp__chat-openai-chatgpt__query
+    - mcp__chat-google-gemini__query
+    - mcp__chat-deepseek__query
+    - mcp__chat-xai-grok__query
+    - mcp__chat-zai-glm__query
+    - mcp__chat-alibaba-qwen__query
 ---
 
-1.  **Determine LLM and Query**:
+@../meta/ase-control.md
 
-    Set <llm>$ARGUMENTS[0]</llm>.
-    Set <query/> to the second and following tokens in `$ARGUMENTS`.
+1.  Treat `$ARGUMENTS` as a single whitespace-separated string.
+    Set <llm/> to the *first* token.
+    Set <query/> to the *second and all following* tokens.
     You *MUST* *NOT* output anything related to this step.
 
-2.  **Determine MCP Tool**:
+2.  Set <server></server> (set to empty).
 
-    Use the <llm/> to determine the corresponding MCP tool <tool/>, from
-    the following list of potentially available MCP tool:
+    <if condition="<llm/> is equal 'chatgpt'"> <server>chat-openai-chatgpt</server></if>
+    <if condition="<llm/> is equal 'gemini'">  <server>chat-google-gemini</server> </if>
+    <if condition="<llm/> is equal 'deepseek'"><server>chat-deepseek</server>      </if>
+    <if condition="<llm/> is equal 'grok'">    <server>chat-xai-grok</server>      </if>
+    <if condition="<llm/> is equal 'glm'">     <server>chat-zai-glm</server>       </if>
+    <if condition="<llm/> is equal 'qwen'">    <server>chat-alibaba-qwen</server>  </if>
 
-    - **OpenAI ChatGPT** (<llm/> `chatgpt`): MCP <tool/> `chat-with-openai-chatgpt`
-    - **Google Gemini** (<llm/> `gemini`):   MCP <tool/> `chat-with-google-gemini`
-    - **DeepSeek** (<llm/> `deepseek`):      MCP <tool/> `chat-with-deepseek`
-    - **xAI Grok** (<llm/> `grok`):          MCP <tool/> `chat-with-xai-grok`
+    <if condition="<server/> is empty">
+        You *MUST* output the following <template/> and immediately *STOP* processing
+        (do *NOT* continue with any further step and do *NOT* call any MCP tool):
 
-    You *MUST* *NOT* output anything related to this step, except if the
-    MCP tool <tool/> cannot be determined (because the corresponding
-    MCP server is not available or currently disabled), just output the
+        <template>
+        ERROR: unknown LLM `<llm/>` (has to be one of: chatgpt, gemini, deepseek, grok, glm, qwen)
+        </template>
+    </if>
+
+3.  Check whether the MCP server <server/> is available (because perhaps
+    it is currently disabled or not configured at all).
+
+    You *MUST* *NOT* output anything related to this step, except if
+    the MCP server <server/> is not available, then just output the
     following <template/> and immediately *STOP* processing:
 
     <template>
-    ERROR: LLM `<llm/>` required MCP tool `<tool/>`, but this is (currently) not available.
+    ERROR: LLM `<llm/>` requires MCP server `<server/>`, but it is (currently) not available!
     </template>
 
-3.  **Call MCP Tool**:
-
-    Else, call the MCP tool with `<tool/>(content: <query/>)` and
-    then return its result *verbatim* and *without any modifications*.
-    Especially, do *NOT* add or remove any text from the agent response
-    on your own and do not interpret the result in any way.
-
+4.  Now call the MCP tool `query(query: <query/>)` from the MCP server
+    <server/> and then return its result `text` *verbatim* and
+    *without any modifications*. Especially, do *NOT* add or remove
+    any text to the MCP server response on your own and do not
+    interpret the result in any way.

package/plugin/agents/ase-meta-diagram.md

@@ -3,7 +3,7 @@ name: ase-meta-diagram
 description: "Diagram Rendering"
 tools:
     - "mcp__plugin_ase_ase__diagram"
-effort: low
+effort: high
 ---
 
 Your role is to render a *single* diagram, with *deterministic* and

package/plugin/agents/ase-meta-search.md

@@ -7,6 +7,11 @@ tools:
     - "WebSearch"
 model: sonnet
 effort: low
+tools:
+    - "mcp__search-perplexity__perplexity_search"
+    - "mcp__search-brave__brave_web_search"
+    - "mcp__search-exa__web_search_exa"
+    - "WebSearch"
 ---
 
 Just perform the given *query* `$ARGUMENTS` and

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.0.50",
+    "version":                              "0.0.51",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/skills/ase-meta-quorum/SKILL.md

@@ -78,6 +78,8 @@ by querying *multiple* AIs for an *optimal consensus*.
     <expand name="agent" arg1="Google Gemini"  arg2="gemini"></expand>
     <expand name="agent" arg1="DeepSeek"       arg2="deepseek"></expand>
     <expand name="agent" arg1="xAI Grok"       arg2="grok"></expand>
+    <expand name="agent" arg1="Z.AI GLM"       arg2="glm"></expand>
+    <expand name="agent" arg1="Alibaba Qwen"   arg2="qwen"></expand>
 
     You *MUST* *NOT* output anything in this step.
 

package/plugin/skills/ase-meta-search/SKILL.md

@@ -8,8 +8,10 @@ user-invocable: true
 disable-model-invocation: false
 effort: low
 allowed-tools:
-    - "mcp__perplexity__perplexity_search"
-    - "mcp__brave__brave_web_search"
+    - "mcp__search-perplexity__perplexity_search"
+    - "mcp__search-brave__brave_web_search"
+    - "mcp__search-exa__web_search_exa"
+    - "WebSearch"
     - "Agent"
 ---
 
@@ -47,18 +49,26 @@ Your objective is to *search* the *Internet*/*Web* for the following query:
     ```
     </define>
 
-    If the MCP tool `mcp__perplexity__perplexity_search` is available, call:
+    If the MCP tool `perplexity_search` from the MCP server `search-perplexity` is available:
     <expand name="agent">
-        Call the MCP tool `mcp__perplexity__perplexity_search(query: "<query/>")`
+        Call the MCP tool `perplexity_search(query: "<query/>")`
+        from the MCP server `search-perplexity`.
     </expand>
 
-    If the MCP tool `mcp__brave__brave_web_search` is available, call:
+    If the MCP tool `brave_web_search` from the MCP server `search-brave` is available:
     <expand name="agent">
-        Call the MCP tool `mcp__brave__brave_web_search(query: "<query/>")`
+        Call the MCP tool `brave_web_search(query: "<query/>")`
+        from the MCP server `search-brave`.
     </expand>
 
+    If the MCP tool `web_search_exa` from the MCP server `search-exa` is available:
     <expand name="agent">
-        Call the tool `WebSearch(query: "<query/>")`
+        Call the MCP tool `web_search_exa(query: "<query/>")`
+        from the MCP server `search-exa`.
+    </expand>
+
+    <expand name="agent">
+        Call the tool `WebSearch(query: "<query/>")`.
     </expand>
 
     </step>