[BUG] @mastra/mcp: a function `requireToolApproval` sets a static `requireApproval: true` on every tool, which forces tool-call concurrency to 1

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { z } from 'zod';

const server = new McpServer({ name: 'probe', version: '1.0.0' });

server.registerTool(
  'echo',
  { description: 'echo the input', inputSchema: { text: z.string() } },
  async ({ text }) => ({ content: [{ type: 'text', text }] }),
);

for (const name of ['slow_a', 'slow_b']) {
  server.registerTool(
    name,
    { description: 'sleeps 300 ms', inputSchema: {} },
    async () => {
      await new Promise(r => setTimeout(r, 300));
      return { content: [{ type: 'text', text: name }] };
    },
  );
}

await server.connect(new StdioServerTransport());

import { Agent } from '@mastra/core/agent';
import { MCPClient } from '@mastra/mcp';
import { fileURLToPath } from 'node:url';

const serverPath = fileURLToPath(new URL('./mcp-server.mjs', import.meta.url));

function stream(parts) {
  return {
    stream: new ReadableStream({
      start(c) {
        for (const p of parts) c.enqueue(p);
        c.close();
      },
    }),
  };
}

// Stub model: step 1 calls both slow tools, step 2 ends the run with text.
function makeModel(toolNames) {
  let call = 0;
  return {
    specificationVersion: 'v2',
    provider: 'mock',
    modelId: 'mock-model',
    supportedUrls: {},
    async doGenerate() {
      throw new Error('not used');
    },
    async doStream() {
      if (call++ === 0) {
        return stream([
          { type: 'stream-start', warnings: [] },
          { type: 'response-metadata', id: 'r1', modelId: 'mock', timestamp: new Date(0) },
          ...toolNames.map((toolName, i) => ({
            type: 'tool-call',
            toolCallId: `call-${i}`,
            toolName,
            input: '{}',
          })),
          { type: 'finish', finishReason: 'tool-calls', usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 } },
        ]);
      }
      return stream([
        { type: 'stream-start', warnings: [] },
        { type: 'response-metadata', id: 'r2', modelId: 'mock', timestamp: new Date(0) },
        { type: 'text-start', id: 't1' },
        { type: 'text-delta', id: 't1', delta: 'done' },
        { type: 'text-end', id: 't1' },
        { type: 'finish', finishReason: 'stop', usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 } },
      ]);
    },
  };
}

async function run(label, requireToolApproval) {
  const mcp = new MCPClient({
    id: `probe-${label}`,
    servers: {
      probe: {
        command: process.execPath,
        args: [serverPath],
        ...(requireToolApproval ? { requireToolApproval } : {}),
      },
    },
  });

  const toolsets = await mcp.listToolsets();
  const agent = new Agent({
    name: 'probe-agent',
    instructions: 'test',
    model: makeModel(['probe_slow_a', 'probe_slow_b']),
  });

  const t0 = Date.now();
  const result = await agent.stream('go', { toolsets });
  for await (const _ of result.fullStream) {
    /* drain */
  }
  const elapsed = Date.now() - t0;

  const flags = Object.fromEntries(
    Object.entries(toolsets.probe).map(([n, t]) => [n, t.requireApproval ?? false]),
  );
  console.log(`${label}: elapsedMs=${elapsed} requireApproval=${JSON.stringify(flags)}`);
  await mcp.disconnect();
}

await run('no-policy', undefined);
await run('fn-policy-always-false', () => false);

no-policy:              elapsedMs=363  requireApproval={"echo":false,"slow_a":false,"slow_b":false}
fn-policy-always-false: elapsedMs=629  requireApproval={"echo":true,"slow_a":true,"slow_b":true}

const mcp = new MCPClient({
  id: 'probe-client',
  servers: {
    probe: { command: process.execPath, args: [serverPath], requireToolApproval: () => false },
  },
});
for (const [name, tool] of Object.entries(await mcp.listTools())) {
  console.log(JSON.stringify({ tool: name, requireApproval: tool.requireApproval }));
}
await mcp.disconnect();

{"tool":"probe_echo","requireApproval":true}
{"tool":"probe_slow_a","requireApproval":true}
{"tool":"probe_slow_b","requireApproval":true}