@jrpool/kilotest 38.1.0 → 39.0.1

package/api/schemas.js

@@ -0,0 +1,297 @@
+/*
+  schemas.js
+  Zod input and response schemas shared by mcp.js (MCP tool inputSchema/outputSchema), api/routes.js, and the openapi.yaml generation script (scripts/generate-openapi.js). Descriptions and component ids (.meta({id})) in this file are the single source of truth for parameter documentation and OpenAPI component naming and reuse.
+*/
+
+// IMPORTS
+
+const {z} = require('zod');
+
+// REQUEST SCHEMAS
+
+// listIssues: GET /api/listIssues/{timeStamp}/{jobID}
+exports.listIssuesSchema = {
+  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
+  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+};
+
+// listViolators: GET /api/listViolators/{issueID}/{timeStamp}/{jobID}
+exports.listViolatorsSchema = {
+  issueID: z.string().describe('Issue identifier (example: contrastPoor)'),
+  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
+  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+};
+
+// listDiagnoses: GET /api/listDiagnoses/{catalogIndex}/{issueID}/{timeStamp}/{jobID}
+exports.listDiagnosesSchema = {
+  catalogIndex: z.string().describe('Identifier of the issue-exhibiting element in the catalog of elements on the page (example: 372)'),
+  issueID: z.string().describe('Issue identifier (example: contrastPoor)'),
+  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
+  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+};
+
+// getReport: GET /api/getReport/{timeStamp}/{jobID}
+exports.getReportSchema = {
+  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
+  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+};
+
+// requestTest: POST /api/requestTest
+exports.requestTestSchema = {
+  description: z.string().describe('10- to 100-character description of the page conforming to the naming convention used in the listReports output'),
+  URL: z.string().describe('12- to 300-character URL of the page, including the https:// scheme and any query'),
+  reason: z.string().describe('20- to 100-character reason why the page should be tested')
+};
+
+// requestRetest: POST /api/requestRetest/{timeStamp}/{jobID}
+exports.requestRetestSchema = {
+  timeStamp: z.string().describe('Timestamp of the latest report about the page in YYMMDDTHHmm format (example: 260503T0432)'),
+  jobID: z.string().describe('Job identifier of the latest report about the page (example: x9z)'),
+  reason: z.string().describe('20- to 100-character reason why the page should be retested')
+};
+
+// requestFeature: POST /api/requestFeature
+exports.requestFeatureSchema = {
+  request: z.string().describe('description of requested new feature or feature improvement')
+};
+
+// listReports takes no input; omitted (mcp.js already uses inputSchema: {}).
+
+// RESPONSE SCHEMAS
+
+// Facts about a rule engine, as constructed by Kilotest's own getRuleEngineFacts (never copied from a Testaro report).
+const ruleEngineFactsSchema = z.object({
+  identifier: z.string(),
+  name: z.string().nullable(),
+  sponsor: z.string().nullable()
+}).meta({id: 'RuleEngineFacts'});
+
+// Facts about the Kilotest tool collection, included in every response.
+const toolsFactsSchema = z.object({
+  name: z.string(),
+  description: z.object({
+    'what Kilotest does': z.string(),
+    'how to retrieve findings': z.object({
+      'level 1': z.string(),
+      'level 2': z.string(),
+      'level 3': z.string(),
+      'level 4': z.string()
+    }),
+    'how to generate more findings': z.object({
+      'new testing': z.string(),
+      'retesting': z.string(),
+      'latency': z.string(),
+      'confirmation': z.string()
+    })
+  }).describe('Explanation of what Kilotest does and how to use its tools.'),
+  URL: z.string().describe('URL of the Kilotest MCP server.'),
+  'web users can obtain similar functionalities at': z.string()
+}).meta({id: 'ToolsFacts'});
+
+// Identifies a related request (e.g., the closest ancestor request in the drill-down hierarchy).
+const requestReferenceSchema = z.object({
+  'tool name': z.string(),
+  description: z.string(),
+  method: z.literal('GET'),
+  URL: z.string()
+}).meta({id: 'RequestReference'});
+
+// GET endpoints have no 'body'; POST endpoints get a request-specific body schema.
+const thisRequestSchema = (method, bodySchema) => z.object({
+  description: z.string(),
+  method: z.literal(method),
+  URL: z.string(),
+  ...(bodySchema ? {body: bodySchema} : {}),
+  'closest ancestor request': requestReferenceSchema.nullable()
+});
+
+const envelope = (method, responseContentSchema, bodySchema) => z.object({
+  'tool collection': toolsFactsSchema,
+  'tool name': z.string(),
+  'this request': thisRequestSchema(method, bodySchema),
+  'URLs of similar requests for web users': similarWebRequestsSchema,
+  'response metadata': responseMetadataSchema,
+  'response content': responseContentSchema
+});
+
+const similarWebRequestsSchema = z.object({
+  'this request': z.string().describe('URL of the equivalent web UI page for this request.'),
+  'closest ancestor request': z.string().nullable()
+}).meta({id: 'SimilarWebRequests'});
+
+const responseMetadataSchema = z.object({
+  identifier: z.string().describe('Unique identifier of this response (timestamp and random suffix).'),
+  'date and time': z.string().describe('UTC date and time when the response was generated, in ISO 8601 format.')
+}).meta({id: 'ResponseMetadata'});
+
+// Facts about a report, as constructed by Kilotest's own getReportBasics (never copied from a Testaro report).
+const reportBasicsSchema = z.object({
+  identifier: z.string().describe('timeStamp-jobID identifier of the report.'),
+  'completion date and time': z.string(),
+  'days since the report was completed': z.number(),
+  'tested web page': z.object({description: z.string(), URL: z.string()}),
+  'whether a later report about the same page exists': z.boolean()
+}).meta({id: 'ReportBasics'});
+
+const reportBasicsOrErrorSchema = z.union([
+  reportBasicsSchema,
+  z.object({error: z.string()})
+]).meta({id: 'ReportBasicsOrError'});
+
+// Facts about an issue based on the Testilo issue classification.
+const issueBasicsSchema = z.object({
+  identifier: z.string(),
+  summary: z.string(),
+  'impact on a user': z.string(),
+  priority: z.enum(['lowest', 'low', 'high', 'highest'])
+}).meta({id: 'IssueBasics'});
+
+const issueBasicsOrErrorSchema = z.union([
+  issueBasicsSchema.extend({
+    'related WCAG standard': z.object({
+      layer: z.enum(['success criterion', 'guideline']),
+      identifier: z.string()
+    })
+  }),
+  z.object({error: z.string()})
+]).meta({id: 'IssueBasicsOrError'});
+
+exports.listReportsResponseSchema = envelope('GET', z.object({
+  'basics about all available reports': z.array(reportBasicsSchema.extend({
+    'how to get details about the report': z.object({method: z.literal('GET'), URL: z.string()}),
+    'web users can get details about the report at': z.string()
+  })),
+  'how to request that a page with no report be tested': z.object({
+    method: z.literal('POST'),
+    URL: z.string(),
+    'request body': z.object({description: z.string(), URL: z.string(), reason: z.string()}),
+    'how to check whether the request has been fulfilled': z.string()
+  }),
+  'how a web user can request that the page be tested': z.object({URL: z.string()})
+}));
+
+exports.listIssuesResponseSchema = envelope('GET', z.object({
+  'basics about the report': reportBasicsOrErrorSchema,
+  'details about the report': z.object({
+    'job definition': z.object({
+      'whether the job prohibited redirection': z.unknown().describe('Copied from the report (strict); type not guaranteed.'),
+      'whether the native results of rule engines are reported': z.boolean(),
+      'whether standardized results are reported': z.boolean(),
+      'device emulated by the job': z.unknown().describe('Device object copied verbatim from the report; shape may vary.'),
+      'browser type used by the job': z.unknown().describe('Copied from the report (browserID); type not guaranteed.')
+    }),
+    'test results': z.object({
+      'rule engines that tried to test the page': z.array(ruleEngineFactsSchema),
+      'rule engines that could not test the page': z.array(z.object({
+        name: z.string().nullable(),
+        'reason for failure': z.unknown().describe('Copied verbatim from the Testaro report; shape may vary.')
+      })),
+      'names of rule engines that reported rule violations': z.array(z.string().nullable()),
+      'counts of issues by priority': z.object({
+        highest: z.number(), high: z.number(), low: z.number(), lowest: z.number()
+      }),
+      'number of elements reported as violators': z.number()
+    })
+  }).nullable(),
+  'how to request that the page be retested': z.union([
+    z.object({notice: z.string()}),
+    z.object({
+      method: z.literal('POST'),
+      URL: z.string(),
+      'request body': z.object({reason: z.string()}),
+      'how to check whether the request has been fulfilled': z.string()
+    })
+  ]).nullable(),
+  'how a web user can request that the page be retested': z.object({URL: z.string()}).nullable(),
+  'how to get the full report in JSON': z.object({
+    'size of the report in bytes': z.number(),
+    method: z.literal('GET'),
+    URL: z.string()
+  }).nullable(),
+  'how a web user can get the full report in JSON': z.object({URL: z.string()}).nullable(),
+  'basics about all issues reported in the report': z.array(issueBasicsSchema.extend({
+    'rule engines with any violations belonging to the issue': z.array(z.string()),
+    'how to get details about the issue': z.object({method: z.literal('GET'), URL: z.string()}),
+    'web users can get details about the issue at': z.string()
+  }))
+}));
+
+exports.listViolatorsResponseSchema = envelope('GET', z.object({
+  'basics about the report': reportBasicsOrErrorSchema,
+  'basics about the issue': issueBasicsOrErrorSchema,
+  'details about the issue': z.object({
+    'rule engines reporting violations belonging to the issue': z.array(ruleEngineFactsSchema)
+  }).nullable(),
+  'basics about all elements reported as exhibiting the issue': z.array(z.object({
+    identifier: z.string(),
+    'tag name': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.'),
+    'inner text': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.'),
+    'count of rule engines reporting that the element exhibited the issue': z.number(),
+    'how to get details about the element': z.object({URL: z.string(), 'request method': z.literal('GET')}),
+    'web users can get details about the element at': z.string()
+  })).nullable()
+}));
+
+exports.listDiagnosesResponseSchema = envelope('GET', z.object({
+  'basics about the report': reportBasicsOrErrorSchema,
+  'basics about the issue': issueBasicsOrErrorSchema,
+  'basics about the element': z.object({
+    identifier: z.string(),
+    'tag name': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.'),
+    'inner text': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.')
+  }).or(z.object({error: z.string()})).nullable(),
+  'details about the element': z.object({
+    'start tag': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.'),
+    'XPath': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.'),
+    'x, y, width, and height of bounding box': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.')
+  }).nullable(),
+  'diagnoses of how the element exhibited the issue': z.array(z.object({
+    'identifier of the violated rule': z.unknown().describe('Copied from the report instance (ruleID); type not guaranteed.'),
+    'description of the violation': z.unknown().describe('Copied from the report instance (what); type not guaranteed.'),
+    'severity of the violation on a 0-to-3 scale': z.unknown().describe('Copied from the report instance (ordinalSeverity); type not guaranteed.'),
+    'count of violations of the rule by the element': z.number()
+  })).or(z.object({error: z.string()}))
+}));
+
+exports.getReportResponseSchema = envelope('GET', z.object({
+  'size of the report in bytes': z.union([z.number(), z.string()]),
+  'full report': z.unknown().describe('The full raw Testaro/Testilo report JSON, copied verbatim, or an error object if it could not be retrieved.')
+}));
+
+exports.requestTestResponseSchema = envelope(
+  'POST',
+  z.object({'details about your request': z.union([
+    z.object({error: z.string()}),
+    z.object({
+      'date and time received': z.string(),
+      'page to be tested': z.object({description: z.string(), URL: z.string()}),
+      'reason why the page should be tested': z.string()
+    })
+  ])}),
+  z.object(exports.requestTestSchema)
+);
+
+exports.requestRetestResponseSchema = envelope(
+  'POST',
+  z.object({'details about your request': z.union([
+    z.object({error: z.string()}),
+    z.object({
+      'date and time received': z.string(),
+      'page to be retested': z.object({description: z.string(), URL: z.string()}),
+      'reason why the page should be retested': z.string()
+    })
+  ])}),
+  z.object({reason: exports.requestRetestSchema.reason})
+);
+
+exports.requestFeatureResponseSchema = envelope(
+  'POST',
+  z.object({'details about your request': z.union([
+    z.object({error: z.string()}),
+    z.object({
+      'date and time received': z.string(),
+      disposition: z.string()
+    })
+  ])}),
+  z.object(exports.requestFeatureSchema)
+);

package/api/testSuite.js

@@ -0,0 +1,294 @@
+/*
+  © 2026 Jonathan Robert Pool.
+
+  Licensed under the MIT License. See LICENSE file at the project root or
+  https://opensource.org/license/mit/ for details.
+
+  SPDX-License-Identifier: MIT
+*/
+
+/*
+  researchAgent.js
+  Simulates a research agent.
+*/
+
+// IMPORTS
+
+require('dotenv').config();
+const httpClient = require('http');
+const httpsClient = require('https');
+
+// CONSTANTS
+
+const kilotestHosts = [
+  process.env.LOCAL_KILOTEST_HOST || 'http://localhost:3000',
+  process.env.DEPLOYED_KILOTEST_HOST || 'https://kilotest.com'
+];
+// Kilotest host specified by the argument.
+const kilotestHost = kilotestHosts[process.argv[2] === 'pub' ? 1 : 0];
+const hostParts = kilotestHost.split(/:\/*/);
+const scheme = hostParts[0] === 'https' ? 'https' : 'http';
+const client = scheme === 'https' ? httpsClient : httpClient;
+const host = hostParts[1] || 'localhost';
+const port = hostParts[2] || (scheme === 'https' ? 443 : 80);
+
+// FUNCTIONS
+
+// Gets, parses into an object, and returns the body of a response.
+const getBody = async response => {
+  const body = await new Promise(resolve => {
+    // Initialize an array of data from the response.
+    const chunks = [];
+    response
+    // If the response throws an error:
+    .on('error', error => {
+      const {message} = error;
+      // Report and return the error message.
+      console.log(message);
+      resolve({error: message});
+    })
+    // Whenever the response delivers data:
+    .on('data', chunk => {
+      // Add them to the array.
+      chunks.push(chunk);
+    })
+    // When the response is completed:
+    .on('end', () => {
+      const bodyString = chunks.join('');
+      try {
+        const body = JSON.parse(bodyString);
+        // Return the response body as an object.
+        resolve(body);
+      }
+      // If it is not JSON:
+      catch {
+        // Return this.
+        resolve({error: `Response body not JSON (${bodyString})`});
+      }
+    });
+  });
+  return body;
+};
+const getRequestOptions = (path, method = 'GET') => ({
+  method,
+  host,
+  port,
+  path,
+  headers: {
+    'body-type': 'application/json; charset=utf-8'
+  }
+});
+// Submits a request, returns the response body, and increments the results.
+const submitRequest = async (path, method, requestBody = null) => new Promise(resolve => {
+  console.log(`Making ${scheme} ${method} request on port ${port} of ${host} to ${path}`);
+  client.request(getRequestOptions(path, method), async response => {
+    const responseBody = await getBody(response);
+    resolve(responseBody);
+  })
+  .on('error', error => {
+    console.log(`ERROR submitting request (${JSON.stringify(error, null, 2)})`);
+    resolve({error});
+  })
+  .end(requestBody ? JSON.stringify(requestBody) : '');
+});
+// Submits requests to the specified Kilotest host.
+const requestService = async () => {
+  let body;
+  let jobID;
+  let method;
+  let path;
+  let reportBasics;
+  let reportsBasics;
+  let requestDetails;
+  let requestDisposition;
+  let responseContent;
+  let timeStamp;
+  console.log('======================\nRequest: List all available reports');
+  method = 'GET';
+  path = '/api/listReports';
+  body = await submitRequest(path, method);
+  responseContent = body?.['response content'] ?? {};
+  reportsBasics = responseContent?.['basics about all available reports'] ?? [];
+  if (
+    !reportsBasics.length
+    || !Array.isArray(reportsBasics)
+    || !reportsBasics.length
+    || reportsBasics.some(
+      reportBasics => reportBasics['how to get details about the report']?.method !== 'GET'
+    )
+  ) {
+    console.log(`reportsBasics: ${JSON.stringify(reportsBasics, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: List issues in one nonexistent report');
+  [timeStamp, jobID] = ['111111T1111', 'abc'];
+  method = 'GET';
+  path = `/api/listIssues/${timeStamp}/${jobID}`;
+  body = await submitRequest(path, method);
+  responseContent = body?.['response content'] ?? {};
+  reportBasics = responseContent?.['basics about the report'] ?? {};
+  if (
+    !reportBasics.error || !reportBasics.error.includes('missing, unreadable, or not JSON')
+  ) {
+    console.log(`reportBasics: ${JSON.stringify(reportBasics, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: List issues in one report');
+  const reportsBasicsIndex = Math.floor(reportsBasics.length * Math.random());
+  // Choose one report at random.
+  reportBasics = reportsBasics[reportsBasicsIndex];
+  [timeStamp, jobID] = reportBasics.identifier?.split('-') || [null, null];
+  if (!(timeStamp && jobID)) {
+    console.log(`reportBasicsIndex: ${reportsBasicsIndex}`);
+    console.log(`reportBasics: ${JSON.stringify(reportBasics, null, 2)}`);
+    return;
+  }
+  path = `/api/listIssues/${timeStamp}/${jobID}`;
+  body = await submitRequest(path, method);
+  responseContent = body?.['response content'] ?? {};
+  const issuesBasics = responseContent?.['basics about all issues reported in the report'] ?? [];
+  if (
+    !issuesBasics.length
+    || !Array.isArray(issuesBasics)
+    || !issuesBasics.length
+    || issuesBasics.some(issueBasics => !issueBasics['impact on a user'])
+  ) {
+    console.log(`issuesBasics: ${JSON.stringify(issuesBasics, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: List violators of one issue in one report');
+  // Get the issue IDs.
+  const issueIDs = issuesBasics.map(issueBasics => issueBasics.identifier);
+  // Choose one at random.
+  const issueID = issueIDs[Math.floor(Math.random() * issueIDs.length)];
+  path = `/api/listViolators/${issueID}/${timeStamp}/${jobID}`;
+  body = await submitRequest(path, method);
+  responseContent = body?.['response content'] ?? {};
+  const violatorsBasics = responseContent?.['basics about all elements exhibiting the issue'] ?? [];
+  if (
+    !violatorsBasics.length
+    || !Array.isArray(violatorsBasics)
+    || !violatorsBasics.length
+    || violatorsBasics.some(violatorBasics => !violatorBasics[
+      'count of rule engines reporting that the element exhibited the issue'
+    ])
+  ) {
+    console.log(`violatorsBasics: ${JSON.stringify(violatorsBasics, null, 2)}`);
+    return;
+  }
+  console.log(
+    '======================\nRequest: List diagnoses of one violation of one issue in one report'
+  );
+  // Get the issue IDs.
+  const violatorIDs = violatorsBasics.map(violatorBasics => violatorBasics.identifier);
+  // Choose one at random.
+  const violatorID = violatorIDs[Math.floor(Math.random() * violatorIDs.length)];
+  path = `/api/listDiagnoses/${violatorID}/${issueID}/${timeStamp}/${jobID}`;
+  body = await submitRequest(path, method);
+  responseContent = body?.['response content'] ?? {};
+  const diagnoses = responseContent?.['diagnoses of how the element exhibited the issue'] ?? [];
+  if (
+    !diagnoses.length
+    || !Array.isArray(diagnoses)
+    || !diagnoses.length
+    || diagnoses.some(
+      diagnosis => typeof diagnosis !== 'object' || !diagnosis['description of the violation']
+    )
+  ) {
+    console.log(`diagnoses: ${JSON.stringify(diagnoses, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: Get one report');
+  path = `/api/getReport/${timeStamp}/${jobID}`;
+  body = await submitRequest(path, method);
+  responseContent = body?.['response content'] ?? {};
+  const fullReport = responseContent?.['full report'] ?? {};
+  if (responseContent.error || typeof fullReport !== 'object' || !fullReport.device) {
+    console.log('Full report request failed');
+    return;
+  }
+  console.log('======================\nRequest: Make a test request with the GET method');
+  path = '/api/requestTest';
+  body = await submitRequest(path, method);
+  if (body.error?.message !== 'Invalid service request') {
+    console.log(`body: ${JSON.stringify(body, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: Request a test with a too short URL');
+  method = 'POST';
+  body = await submitRequest(path, method, {
+    description: 'Zilch',
+    URL: 'https://a.b',
+    reason: 'Just because'
+  });
+  responseContent = body?.['response content'] ?? {};
+  requestDetails = responseContent['details about your request'] ?? {};
+  if (!requestDetails.error?.includes('specified a URL for the page')) {
+    console.log(`requestDetails: ${JSON.stringify(requestDetails, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: Request a test');
+  body = await submitRequest(path, method, {
+    description: 'Organization that does not exist',
+    URL: 'https://nonexistentorg.com',
+    reason: 'I have no good reason for wanting this page to be tested'
+  });
+  responseContent = body?.['response content'] ?? {};
+  requestDetails = responseContent['details about your request'] ?? {};
+  requestDisposition = responseContent['disposition of your request'] ?? {};
+  if (
+    !requestDetails['reason why the page should be tested']
+    || !requestDisposition['what happens next']?.includes('1 hour to 1 day')
+  ) {
+    console.log(`requestDetails: ${JSON.stringify(requestDetails, null, 2)}`);
+    console.log(`requestDisposition: ${JSON.stringify(requestDisposition, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: Request a retest of a nonexistent report');
+  path = `/api/requestRetest/${timeStamp}/xyz`;
+  body = await submitRequest(path, method, {
+    reason: 'It would be cool to retest what does not exist'
+  });
+  responseContent = body?.['response content'] ?? {};
+  requestDetails = responseContent['details about your request'] ?? {};
+  if (!requestDetails.error?.includes('not an available report')) {
+    console.log(`requestDetails: ${JSON.stringify(requestDetails, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: Request a retest');
+  path = `/api/requestRetest/${timeStamp}/${jobID}`;
+  body = await submitRequest(path, method, {
+    reason: 'I just feel like making this request'
+  });
+  responseContent = body?.['response content'] ?? {};
+  requestDetails = responseContent['details about your request'] ?? {};
+  requestDisposition = responseContent['disposition of your request'] ?? {};
+  if (
+    !requestDetails['reason why the page should be retested']
+    || !requestDisposition['how you can check for completion']
+  ) {
+    console.log(`requestDetails: ${JSON.stringify(requestDetails, null, 2)}`);
+    console.log(`requestDisposition: ${JSON.stringify(requestDisposition, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: Make a feature request');
+  path = `/api/requestFeature/${timeStamp}/${jobID}`;
+  body = await submitRequest(path, method, {
+    feature: 'Do the impossible'
+  });
+  responseContent = body?.['response content'] ?? {};
+  requestDetails = responseContent['details about your request'] ?? {};
+  if (!requestDetails.disposition?.includes('received and logged')) {
+    console.log(`requestDetails: ${JSON.stringify(requestDetails, null, 2)}`);
+    return;
+  }
+  console.log('======================\nRequest: Results');
+  console.log('All tests succeeded');
+};
+
+// EXECUTION
+
+// Execute the research agent.
+(async () => {
+  await requestService();
+})();