@smartbear/mcp 0.19.0 → 0.20.0

package/dist/common/transport-http.js

@@ -1,13 +1,41 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
+import querystring from "node:querystring";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { clientRegistry } from "./client-registry.js";
 import { withRequestContext } from "./request-context.js";
 import { SmartBearMcpServer } from "./server.js";
+import { isDraining, registerShutdownHandler } from "./shutdown.js";
 import { getEnvVarName } from "./transport-stdio.js";
-import { isOptionalType } from "./zod-utils.js";
+import { isOptionalType, getTypeDescription } from "./zod-utils.js";
+const PROBE_HEADERS = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store"
+};
+function handleHealthRequest(res) {
+  res.writeHead(200, PROBE_HEADERS);
+  res.end(
+    JSON.stringify({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+  );
+}
+function handleReadyRequest(res, draining = isDraining) {
+  if (draining()) {
+    res.writeHead(503, PROBE_HEADERS);
+    res.end(
+      JSON.stringify({
+        status: "draining",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return;
+  }
+  res.writeHead(200, PROBE_HEADERS);
+  res.end(
+    JSON.stringify({ status: "ready", timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+  );
+}
 function getBaseUrl(req) {
   const baseUrlOverride = process.env.BASE_URL;
   if (baseUrlOverride) {
@@ -54,10 +82,11 @@ async function runHttpMode() {
       const baseUrl = getBaseUrl(req);
       const url = new URL(req.url || "/", baseUrl);
       if (req.method === "GET" && url.pathname === "/health") {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(
-          JSON.stringify({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() })
-        );
+        handleHealthRequest(res);
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/ready") {
+        handleReadyRequest(res);
         return;
       }
       if (req.method === "GET" && (url.pathname === "/.well-known/oauth-protected-resource" || url.pathname === "/.well-known/oauth-protected-resource/mcp")) {
@@ -89,9 +118,8 @@ async function runHttpMode() {
   );
   httpServer.listen(PORT, () => {
     console.log(`[MCP HTTP Server] Listening on http://localhost:${PORT}`);
-    console.log(
-      `[MCP HTTP Server] Health check: http://localhost:${PORT}/health`
-    );
+    console.log(`[MCP HTTP Server] Liveness:  http://localhost:${PORT}/health`);
+    console.log(`[MCP HTTP Server] Readiness: http://localhost:${PORT}/ready`);
     console.log(
       `[MCP HTTP Server] Modern endpoint: http://localhost:${PORT}/mcp (Streamable HTTP)`
     );
@@ -110,6 +138,29 @@ ${headerHelp.join("\n")}`
       );
     }
   });
+  registerShutdownHandler("http-transport", async () => {
+    await drainHttpTransport(httpServer, transports);
+  });
+}
+async function drainHttpTransport(httpServer, transports) {
+  console.log(
+    `[MCP][shutdown] Draining HTTP transport (${transports.size} active session(s))`
+  );
+  const serverClosed = new Promise((resolve) => {
+    httpServer.close(() => resolve());
+  });
+  httpServer.closeIdleConnections?.();
+  const transportCloses = [...transports.values()].map(async (entry) => {
+    try {
+      await entry.transport.close();
+    } catch (err) {
+      console.error("[MCP][shutdown] Error closing transport:", err);
+    }
+  });
+  await Promise.all(transportCloses);
+  httpServer.closeAllConnections?.();
+  await serverClosed;
+  console.log("[MCP][shutdown] HTTP transport drained");
 }
 async function parseRequestBody(req) {
   if (req.method !== "POST") {
@@ -186,9 +237,24 @@ async function createNewTransport(req, res, transports) {
 async function handleStreamableHttpRequest(req, res, transports) {
   try {
     const sessionId = req.headers["mcp-session-id"];
+    if (sessionId && !transports.has(sessionId)) {
+      req.resume();
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32001,
+            message: "Session not found"
+          },
+          id: null
+        })
+      );
+      return;
+    }
     const parsedBody = await parseRequestBody(req);
     let transport;
-    if (sessionId && transports.has(sessionId)) {
+    if (sessionId) {
       const existingTransport = getExistingTransport(
         sessionId,
         transports,
@@ -196,7 +262,7 @@ async function handleStreamableHttpRequest(req, res, transports) {
       );
       if (!existingTransport) return;
       transport = existingTransport;
-    } else if (!sessionId && req.method === "POST" && parsedBody && isInitializeRequest(parsedBody)) {
+    } else if (req.method === "POST" && parsedBody && isInitializeRequest(parsedBody)) {
       const newTransport = await createNewTransport(req, res, transports);
       if (!newTransport) return;
       transport = newTransport;
@@ -285,8 +351,14 @@ async function newServer(req, res) {
       () => clientRegistry.configure(
         server,
         (client, key) => {
+          const queryStringName = getQueryStringName(client, key);
+          const queryParams = querystring.parse(req.url?.split("?")[1] || "");
+          let value = queryParams[queryStringName] || queryParams[queryStringName.toLowerCase()];
+          if (typeof value === "string") {
+            return value;
+          }
           const headerName = getHeaderName(client, key);
-          const value = req.headers[headerName] || req.headers[headerName.toLowerCase()];
+          value = req.headers[headerName] || req.headers[headerName.toLowerCase()];
           if (typeof value === "string") {
             return value;
           }
@@ -338,6 +410,11 @@ function getHeaderName(client, key) {
     (part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
   ).join("-")}`;
 }
+function getQueryStringName(client, key) {
+  return `${client.configPrefix.toLowerCase()}${key.split("_").map(
+    (part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
+  ).join("")}`;
+}
 function getHttpHeaders() {
   const headers = /* @__PURE__ */ new Set();
   for (const entry of clientRegistry.getAll()) {
@@ -355,15 +432,20 @@ function getHttpHeadersHelp() {
       const headerName = getHeaderName(entry, configKey);
       const requiredTag = isOptionalType(requirement) ? " (optional)" : " (required)";
       messages.push(
-        `    - ${headerName}${requiredTag}: ${requirement.description}`
+        `    - ${headerName}${requiredTag}: ${getTypeDescription(requirement)}`
       );
     }
   }
   return messages;
 }
 export {
+  drainHttpTransport,
   getBaseUrl,
   getHeaderName,
+  getQueryStringName,
+  handleHealthRequest,
+  handleReadyRequest,
+  handleStreamableHttpRequest,
   newServer,
   runHttpMode
 };

package/dist/common/transport-stdio.js

@@ -2,7 +2,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { clientRegistry } from "./client-registry.js";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./info.js";
 import { SmartBearMcpServer } from "./server.js";
-import { isOptionalType } from "./zod-utils.js";
+import { registerShutdownHandler } from "./shutdown.js";
+import { isOptionalType, getTypeDescription } from "./zod-utils.js";
 function getNoConfigMessage() {
   const messages = [];
   for (const entry of clientRegistry.getAll()) {
@@ -11,7 +12,7 @@ function getNoConfigMessage() {
       const envVarName = getEnvVarName(entry, configKey);
       const requiredTag = isOptionalType(requirement) ? " (optional)" : " (required)";
       messages.push(
-        `    - ${envVarName}${requiredTag}: ${requirement.description}`
+        `    - ${envVarName}${requiredTag}: ${getTypeDescription(requirement)}`
       );
     }
   }
@@ -21,6 +22,12 @@ async function runStdioMode() {
   if (process.argv.includes("--version")) {
     console.log(`${MCP_SERVER_NAME}: v${MCP_SERVER_VERSION}`);
     process.exit(0);
+  } else if (process.argv.includes("--help")) {
+    console.log(
+      "The following environment variables can be set to configure each of the SmartBear clients:"
+    );
+    console.log(getNoConfigMessage().join("\n"));
+    process.exit(0);
   }
   const server = new SmartBearMcpServer();
   const configuredCount = await clientRegistry.configure(
@@ -41,6 +48,13 @@ ${message.join("\n")}` : "No clients support environment variable configuration.
     }
   }
   const transport = new StdioServerTransport();
+  registerShutdownHandler("stdio-transport", async () => {
+    try {
+      await transport.close();
+    } catch (err) {
+      console.error("[MCP][shutdown] Error closing stdio transport:", err);
+    }
+  });
   transport.onmessage = (message) => {
     if ("method" in message && message.method === "initialize") {
       if (message.params?.protocolVersion === "2025-11-25") {

package/dist/common/zod-utils.js

@@ -1,20 +1,75 @@
-import { ZodOptional, ZodDefault, ZodNullable } from "zod";
-function isOptionalType(zodType) {
-  return zodType instanceof ZodOptional || zodType instanceof ZodDefault || zodType instanceof ZodNullable;
-}
+import { ZodOptional, ZodDefault, ZodNullable, ZodRecord, ZodString, ZodNumber, ZodBoolean, ZodArray, ZodObject, ZodEnum, ZodLiteral, ZodUnion, ZodAny } from "zod";
 function unwrapZodType(zodType) {
   if (zodType instanceof ZodOptional) {
-    return unwrapZodType(zodType.unwrap());
+    return zodType.unwrap();
   }
   if (zodType instanceof ZodDefault) {
-    return unwrapZodType(zodType.unwrap());
+    return zodType.unwrap();
   }
   if (zodType instanceof ZodNullable) {
-    return unwrapZodType(zodType.unwrap());
+    return zodType.unwrap();
   }
   return zodType;
 }
+function isOptionalType(zodType) {
+  const isOptional = zodType instanceof ZodOptional || zodType instanceof ZodDefault || zodType instanceof ZodNullable;
+  if (!isOptional) {
+    const unwrapped = unwrapZodType(zodType);
+    if (unwrapped !== zodType) {
+      return isOptionalType(unwrapped);
+    }
+  }
+  return isOptional;
+}
+function getDefaultValue(zodType) {
+  if (zodType instanceof ZodDefault) {
+    return zodType.def.defaultValue;
+  }
+  const unwrapped = unwrapZodType(zodType);
+  if (unwrapped !== zodType) {
+    return getDefaultValue(unwrapped);
+  }
+  return null;
+}
+function fullyUnwrapZodType(zodType) {
+  const unwrappedType = unwrapZodType(zodType);
+  if (unwrappedType === zodType) {
+    return unwrappedType;
+  }
+  return fullyUnwrapZodType(unwrappedType);
+}
+function getTypeDescription(zodType) {
+  if (zodType.description) {
+    return zodType.description;
+  }
+  const unwrapped = unwrapZodType(zodType);
+  if (unwrapped !== zodType) {
+    return getTypeDescription(unwrapped);
+  }
+  return null;
+}
+function getReadableTypeName(zodType) {
+  zodType = fullyUnwrapZodType(zodType);
+  if (zodType instanceof ZodRecord) {
+    const record = zodType;
+    return `record<${getReadableTypeName(record.def.keyType)}, ${getReadableTypeName(record.def.valueType)}>`;
+  }
+  if (zodType instanceof ZodString) return "string";
+  if (zodType instanceof ZodNumber) return "number";
+  if (zodType instanceof ZodBoolean) return "boolean";
+  if (zodType instanceof ZodArray) return "array";
+  if (zodType instanceof ZodObject) return "object";
+  if (zodType instanceof ZodEnum) return "enum";
+  if (zodType instanceof ZodLiteral) return "literal";
+  if (zodType instanceof ZodUnion) return "union";
+  if (zodType instanceof ZodAny) return "any";
+  return "any";
+}
 export {
+  fullyUnwrapZodType,
+  getDefaultValue,
+  getReadableTypeName,
+  getTypeDescription,
   isOptionalType,
   unwrapZodType
 };

package/dist/index.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import Bugsnag from "./common/bugsnag.js";
 import "./common/register-clients.js";
+import { installSignalHandlers } from "./common/shutdown.js";
 import { runHttpMode } from "./common/transport-http.js";
 import { runStdioMode } from "./common/transport-stdio.js";
 const McpServerBugsnagAPIKey = process.env.MCP_SERVER_BUGSNAG_API_KEY;
 if (McpServerBugsnagAPIKey) {
   Bugsnag.start(McpServerBugsnagAPIKey);
 }
+installSignalHandlers();
 async function main() {
   const transportMode = process.env.MCP_TRANSPORT?.toLowerCase() || "stdio";
   if (transportMode === "http") {

package/dist/package.json.js

@@ -1,4 +1,4 @@
-const version = "0.19.0";
+const version = "0.20.0";
 const config = { "mcpServerName": "SmartBear MCP Server" };
 const packageJson = {
   version,

package/dist/pactflow/client/prompts.js

@@ -105,27 +105,28 @@ Now provided the below OpenAPI document:-
 
 Give JSON recommendations only provide the JSON block in markdown don't include any additional text.
 `;
+const argsSchema = z.object({
+  openAPI: z.string().describe("The OpenAPI document to generate matcher recommendations for")
+});
 const PROMPTS = [
   {
-    name: "OpenAPI Matcher recommendations",
-    params: {
-      description: "Get OpenAPI matcher recommendations using sampling",
-      title: "OpenAPI Matcher recommendations",
-      argsSchema: {
-        openAPI: z.string()
-      }
-    },
-    callback: ({ openAPI }) => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: OADMatcherPrompt.replace("{0}", openAPI)
+    title: "OpenAPI Matcher recommendations",
+    description: "Get OpenAPI matcher recommendations using sampling",
+    argsSchema,
+    callback: (args) => {
+      const params = argsSchema.parse(args);
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: OADMatcherPrompt.replace("{0}", params.openAPI)
+            }
           }
-        }
-      ]
-    })
+        ]
+      };
+    }
   }
 ];
 export {

package/dist/pactflow/client/tools.js

@@ -27,14 +27,9 @@ const TOOLS = [
     title: "Get Provider States",
     summary: "Retrieve the states of a specific provider",
     purpose: "A provider state in Pact defines the specific preconditions that must be met on the provider side before a consumer-provider interaction can be tested. It sets up the provider in the right context—such as ensuring a particular user or record exists—so that the provider can return the response the consumer expects. This makes contract tests reliable, repeatable, and isolated by injecting or configuring the necessary data and conditions directly into the provider before each test runs.",
-    parameters: [
-      {
-        name: "provider",
-        type: z.string(),
-        description: "name of the provider to retrieve states for",
-        required: true
-      }
-    ],
+    inputSchema: z.object({
+      provider: z.string().describe("name of the provider to retrieve states for")
+    }),
     handler: "getProviderStates",
     clients: ["pactflow", "pact_broker"]
   },
@@ -256,7 +251,7 @@ const TOOLS = [
     clients: ["pactflow"]
   },
   {
-    title: "Get BDCT Consumer Contract by Consumer Version",
+    title: "Get BDCT Consumer by Consumer Version",
     summary: "Fetch the consumer Pact contract for a specific consumer-provider version pair in Bi-Directional Contract Testing.",
     purpose: "Retrieve the Pact contract published by a specific consumer version, in the context of a specific provider version. Use this when you need the exact consumer contract that was compared against a given provider spec.",
     inputSchema: GetBiDirectionalConsumerProviderVersionSchema,
@@ -264,7 +259,7 @@ const TOOLS = [
     clients: ["pactflow"]
   },
   {
-    title: "Get BDCT Provider Contract by Consumer Version",
+    title: "Get BDCT Provider by Consumer Version",
     summary: "Fetch the provider OpenAPI contract for a specific consumer-provider version pair in Bi-Directional Contract Testing.",
     purpose: "Retrieve the provider's OpenAPI spec in the context of a specific consumer version pair. Useful when investigating why a particular consumer-provider combination failed cross-contract verification.",
     inputSchema: GetBiDirectionalConsumerProviderVersionSchema,
@@ -272,7 +267,7 @@ const TOOLS = [
     clients: ["pactflow"]
   },
   {
-    title: "Get BDCT Provider Contract Verification Results by Consumer Version",
+    title: "Get BDCT Provider Check Results by Consumer",
     summary: "Fetch the provider contract self-verification results for a specific consumer-provider version pair in Bi-Directional Contract Testing.",
     purpose: "Retrieve the provider's self-verification results in the context of a specific consumer version pair. Use when diagnosing failures for a particular consumer-provider combination.",
     inputSchema: GetBiDirectionalConsumerProviderVersionSchema,
@@ -280,7 +275,7 @@ const TOOLS = [
     clients: ["pactflow"]
   },
   {
-    title: "Get BDCT Consumer Contract Verification Results by Consumer Version",
+    title: "Get BDCT Consumer Pact Test Results by Consumer",
     summary: "Fetch the consumer contract verification results for a specific consumer-provider version pair in Bi-Directional Contract Testing.",
     purpose: "Retrieve the results of comparing a specific consumer version's Pact against the provider's OpenAPI spec. Shows exactly which interactions passed or failed the cross-contract comparison.",
     inputSchema: GetBiDirectionalConsumerProviderVersionSchema,
@@ -288,7 +283,7 @@ const TOOLS = [
     clients: ["pactflow"]
   },
   {
-    title: "Get BDCT Cross-Contract Verification Results by Consumer Version",
+    title: "Get BDCT X-Contract Test Results by Consumer",
     summary: "Fetch the cross-contract verification results for a specific consumer-provider version pair in Bi-Directional Contract Testing.",
     purpose: "Retrieve the precise cross-contract comparison outcome between a specific consumer version and provider version. This is the most granular BDCT result — use it to understand exactly why a specific consumer-provider pairing succeeded or failed, and which interactions were incompatible.",
     inputSchema: GetBiDirectionalConsumerProviderVersionSchema,

package/dist/pactflow/client.js

@@ -16,7 +16,7 @@ const ConfigurationSchema = zod__default.object({
 });
 class PactflowClient {
   name = "Contract Testing";
-  toolPrefix = "contract-testing";
+  capabilityPrefix = "contract-testing";
   configPrefix = "Pact-Broker";
   config = ConfigurationSchema;
   token;
@@ -136,10 +136,17 @@ class PactflowClient {
    * @throws Error if the request fails or returns a non-OK response.
    */
   async checkAIEntitlements() {
-    return await this.fetchJson(`${this.aiBaseUrl}/entitlement`, {
-      method: "GET",
-      errorContext: "PactFlow AI Entitlements Request"
-    });
+    if (this.aiBaseUrl) {
+      return await this.fetchJson(
+        `${this.aiBaseUrl}/entitlement`,
+        {
+          method: "GET",
+          errorContext: "PactFlow AI Entitlements Request"
+        }
+      );
+    } else {
+      return null;
+    }
   }
   /**
    * Polls the given status URL with a HEAD request to check operation progress.
@@ -2060,7 +2067,7 @@ class PactflowClient {
     let disablePactflowAItools = false;
     try {
       const entitlement = await this.checkAIEntitlements();
-      if (!entitlement.aiEnabled) {
+      if (entitlement && !entitlement.aiEnabled) {
         disablePactflowAItools = true;
       }
     } catch (error) {
@@ -2074,8 +2081,8 @@ class PactflowClient {
       if (tool.tags && disablePactflowAItools && tool.tags.includes("pactflow-ai")) {
         continue;
       }
-      const { handler, clients: _, formatResponse, ...toolparams } = tool;
-      register(toolparams, async (args, _extra) => {
+      const { handler, clients: _, formatResponse, ...toolParams } = tool;
+      register(toolParams, async (args, _extra) => {
         const handler_fn = this[handler];
         if (typeof handler_fn !== "function") {
           throw new Error(`Handler '${handler}' not found on PactClient`);
@@ -2100,10 +2107,17 @@ class PactflowClient {
    *
    * @param register - The function used to register prompts.
    */
-  registerPrompts(register) {
-    PROMPTS.forEach((prompt) => {
-      register(prompt.name, prompt.params, prompt.callback);
-    });
+  async registerPrompts(register) {
+    for (const prompt of PROMPTS) {
+      register(
+        {
+          title: prompt.title,
+          description: prompt.description,
+          argsSchema: prompt.argsSchema
+        },
+        prompt.callback
+      );
+    }
   }
 }
 export {

package/dist/qmetry/client/tools/testsuite-tools.js

@@ -926,8 +926,8 @@ const TESTSUITE_TOOLS = [
           entityType: "TCR",
           qmTsRunId: "2720260",
           runStatusID: 123266,
-          username: "dhaval.mistry",
-          password: "Ispl123#",
+          username: "test.user",
+          password: "password",
           isBulkOperation: false
         },
         expectedOutput: "Test case run status updated with Part 11 Compliance authentication"

package/dist/qmetry/client.js

@@ -13,7 +13,7 @@ const ConfigurationSchema = zod__default.object({
 });
 class QmetryClient {
   name = "QMetry";
-  toolPrefix = "qmetry";
+  capabilityPrefix = "qmetry";
   configPrefix = "Qmetry";
   config = ConfigurationSchema;
   token;

package/dist/reflect/client.js

@@ -27,7 +27,7 @@ class ReflectClient {
   sessionStates = /* @__PURE__ */ new Map();
   mcpSessionConnections = /* @__PURE__ */ new Map();
   name = "Reflect";
-  toolPrefix = "reflect";
+  capabilityPrefix = "reflect";
   configPrefix = "Reflect";
   config = ConfigurationSchema;
   async configure(_server, config, _cache) {
@@ -136,10 +136,10 @@ class ReflectClient {
       register(tool.specification, tool.handle);
     }
   }
-  registerPrompts(register) {
+  async registerPrompts(register) {
     const prompts = [new SapTest(this)];
     for (const prompt of prompts) {
-      register(prompt.name, prompt.params, prompt.callback);
+      register(prompt.specification, prompt.callback);
     }
   }
 }

package/dist/reflect/prompt/sap-test.js

@@ -1,12 +1,12 @@
+import { z } from "zod";
 import { Prompt } from "../../common/prompts.js";
 class SapTest extends Prompt {
-  name = "reflect-sap-test";
-  params = {
-    title: "Reflect SAP Test",
+  specification = {
+    title: "SAP Test",
     description: "Guidelines for creating a Reflect test against an SAP S4/HANA or SAP BTP application.",
-    argsSchema: {}
+    argsSchema: z.object({})
   };
-  callback = () => ({
+  callback = (_args) => ({
     messages: [
       {
         role: "user",

package/dist/reflect/tool/recording/add-prompt-step.js

@@ -7,20 +7,12 @@ class AddPromptStep extends Tool {
     summary: "Add a natural language prompt step to an active Reflect recording session",
     readOnly: false,
     idempotent: false,
-    parameters: [
-      {
-        name: "sessionId",
-        type: z.string(),
-        description: "The ID of the Reflect recording session",
-        required: true
-      },
-      {
-        name: "prompt",
-        type: z.string(),
-        description: 'The natural language prompt describing the test step. The prompt should describe a single action, assertion, or query. The prompt can only contain literal text; it cannot contain template variables, secrets, or other dynamic syntax. If we are in a Web recording, the prompt can perform browser navigation (e.g. "Click on the back button", "Navigate to https://www.example.com") and use the tab and enter keys to navigate (e.g. "Press the tab key", "Press the enter key").',
-        required: true
-      }
-    ]
+    inputSchema: z.object({
+      sessionId: z.string().describe("The ID of the Reflect recording session"),
+      prompt: z.string().describe(
+        "The natural language prompt describing the test step. The prompt should describe a single action, assertion, or query. The prompt can only contain literal text; it cannot contain template variables, secrets, or other dynamic syntax. If we are in a Web recording, the prompt can perform browser navigation (e.g. 'Click on the back button', 'Navigate to https://www.example.com') and use the tab and enter keys to navigate (e.g. 'Press the tab key', 'Press the enter key')."
+      )
+    })
   };
   handle = async (args) => {
     const { sessionId, prompt } = args;

package/dist/reflect/tool/recording/add-segment.js

@@ -7,20 +7,10 @@ class AddSegment extends Tool {
     summary: "Insert a reusable test segment into an active Reflect recording session",
     readOnly: false,
     idempotent: false,
-    parameters: [
-      {
-        name: "sessionId",
-        type: z.string(),
-        description: "The ID of the Reflect recording session",
-        required: true
-      },
-      {
-        name: "segmentId",
-        type: z.number(),
-        description: "The ID of the segment to add",
-        required: true
-      }
-    ]
+    inputSchema: z.object({
+      sessionId: z.string().describe("The ID of the Reflect recording session"),
+      segmentId: z.number().describe("The ID of the segment to add")
+    })
   };
   handle = async (args) => {
     const { sessionId, segmentId } = args;

package/dist/reflect/tool/recording/connect-to-session.js

@@ -16,14 +16,9 @@ class ConnectToSession extends Tool {
 7. After completing a task, if the task required multiple prompt steps, add a final prompt step that validates the current state of the page based on what you see on the screen. In your validation, do not reference information that can change from run to run.`,
     readOnly: false,
     idempotent: true,
-    parameters: [
-      {
-        name: "sessionId",
-        type: z.string(),
-        description: "The ID of the Reflect recording session to connect to",
-        required: true
-      }
-    ]
+    inputSchema: z.object({
+      sessionId: z.string().describe("The ID of the Reflect recording session to connect to")
+    })
   };
   handle = async (args, extra) => {
     const { sessionId } = args;