@smartbear/mcp 0.19.2 → 0.21.1

package/dist/common/shutdown.js

@@ -0,0 +1,165 @@
+const DEFAULT_TIMEOUT_MS = 25e3;
+function defaultTimeout() {
+  const fromEnv = process.env.MCP_SHUTDOWN_TIMEOUT_MS;
+  if (fromEnv) {
+    const parsed = Number.parseInt(fromEnv, 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_TIMEOUT_MS;
+}
+class ShutdownManager {
+  handlers = [];
+  state = "idle";
+  signalsInstalled = false;
+  installedSignalListeners = [];
+  signals;
+  timeoutMs;
+  proc;
+  exitFn;
+  logger;
+  constructor(options = {}) {
+    this.signals = options.signals ?? ["SIGTERM", "SIGINT"];
+    this.timeoutMs = options.timeoutMs ?? defaultTimeout();
+    this.proc = options.process ?? process;
+    this.exitFn = options.exit ?? ((code) => process.exit(code));
+    this.logger = options.logger ?? console;
+  }
+  /**
+   * Register a cleanup handler. Handlers run in LIFO order on shutdown,
+   * so subsystems registered later (closer to where they are used) tear
+   * down before subsystems registered earlier (closer to startup).
+   */
+  register(name, fn) {
+    if (this.state !== "idle") {
+      this.logger.warn(
+        `[MCP][shutdown] Refusing to register handler "${name}" — already ${this.state}`
+      );
+      return;
+    }
+    this.handlers.push({ name, fn });
+  }
+  /** True from the moment the first shutdown signal is received. */
+  isDraining() {
+    return this.state !== "idle";
+  }
+  /**
+   * Wire SIGTERM / SIGINT listeners. Idempotent — calling more than once
+   * is a no-op.
+   */
+  installSignalHandlers() {
+    if (this.signalsInstalled) return;
+    this.signalsInstalled = true;
+    for (const signal of this.signals) {
+      const listener = () => {
+        this.handleSignal(signal);
+      };
+      this.proc.on(signal, listener);
+      this.installedSignalListeners.push({ signal, listener });
+    }
+  }
+  /** Tear down installed signal listeners (test-only). */
+  uninstallSignalHandlers() {
+    for (const { signal, listener } of this.installedSignalListeners) {
+      this.proc.off(signal, listener);
+    }
+    this.installedSignalListeners = [];
+    this.signalsInstalled = false;
+  }
+  /**
+   * Run all registered handlers in LIFO order with the configured deadline.
+   * Returns the drain result without exiting the process — exposed for tests
+   * and for callers that want to log / report before exiting.
+   */
+  async drain() {
+    if (this.state === "complete") {
+      return { status: "clean", durationMs: 0, remainingHandlers: [] };
+    }
+    this.state = "draining";
+    const start = Date.now();
+    const reversed = [...this.handlers].reverse();
+    const remaining = new Set(reversed.map((h) => h.name));
+    this.logger.log(
+      `[MCP][shutdown] Draining ${reversed.length} handler(s), deadline ${this.timeoutMs}ms`
+    );
+    let timeoutHandle;
+    const drainPromise = (async () => {
+      for (const h of reversed) {
+        try {
+          await h.fn();
+        } catch (err) {
+          this.logger.error(
+            `[MCP][shutdown] Handler "${h.name}" threw during drain:`,
+            err
+          );
+        }
+        remaining.delete(h.name);
+      }
+    })();
+    const timeoutPromise = new Promise((resolve) => {
+      timeoutHandle = setTimeout(() => resolve("deadline"), this.timeoutMs);
+      timeoutHandle.unref?.();
+    });
+    const winner = await Promise.race([
+      drainPromise.then(() => "clean"),
+      timeoutPromise
+    ]);
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+    this.state = "complete";
+    const durationMs = Date.now() - start;
+    const remainingHandlers = [...remaining];
+    if (winner === "clean") {
+      this.logger.log(`[MCP][shutdown] Drained cleanly in ${durationMs}ms`);
+    } else {
+      this.logger.error(
+        `[MCP][shutdown] Deadline exceeded after ${durationMs}ms, ${remainingHandlers.length} handler(s) outstanding: ${remainingHandlers.join(", ") || "(none)"}`
+      );
+    }
+    return { status: winner, durationMs, remainingHandlers };
+  }
+  /** Exposed for tests; not part of the production call path. */
+  getState() {
+    return this.state;
+  }
+  handleSignal(signal) {
+    if (this.state === "draining") {
+      this.logger.warn(
+        `[MCP][shutdown] Received ${signal} while draining — forcing immediate exit(1)`
+      );
+      this.exitFn(1);
+      return;
+    }
+    if (this.state === "complete") {
+      this.exitFn(0);
+      return;
+    }
+    this.logger.log(`[MCP][shutdown] Received ${signal}, starting drain`);
+    this.drain().then((result) => {
+      this.exitFn(result.status === "clean" ? 0 : 1);
+    }).catch((err) => {
+      this.logger.error(
+        "[MCP][shutdown] Unexpected error from drain():",
+        err
+      );
+      this.exitFn(1);
+    });
+  }
+}
+const shutdownManager = new ShutdownManager();
+function registerShutdownHandler(name, fn) {
+  shutdownManager.register(name, fn);
+}
+function installSignalHandlers() {
+  shutdownManager.installSignalHandlers();
+}
+function isDraining() {
+  return shutdownManager.isDraining();
+}
+export {
+  ShutdownManager,
+  installSignalHandlers,
+  isDraining,
+  registerShutdownHandler,
+  shutdownManager
+};

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.2";
+const version = "0.21.1";
 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 {