@gremlin/mcp-server 2.2.1 → 2.3.0

package/build/index.mjs

@@ -0,0 +1,821 @@
+// src/elicitation.ts
+var McpElicitationClient = class {
+  constructor(server) {
+    this.server = server;
+  }
+  async confirm(prompt, options) {
+    const [proceed, ...rest] = options;
+    const cancel = rest[rest.length - 1] ?? proceed;
+    const result = await this.server.server.elicitInput({
+      message: prompt,
+      requestedSchema: {
+        type: "object",
+        properties: {
+          confirmed: {
+            type: "boolean",
+            title: proceed.label,
+            description: proceed.description,
+            default: false
+          }
+        },
+        required: ["confirmed"]
+      }
+    });
+    if (result.action === "accept" && result.content?.["confirmed"] === true) {
+      return proceed.value;
+    }
+    return cancel.value;
+  }
+};
+
+// src/tools/reliability-management.ts
+import z from "zod";
+function summarizeScenarioRun(testRun) {
+  const { graph: _graph, ...runSummary } = testRun.run;
+  return {
+    ...testRun,
+    run: runSummary
+  };
+}
+function createGetReliabilityExperimentTool(api) {
+  return {
+    name: "get_reliability_experiments",
+    description: "Retrieves recent reliability experiment for a specific service.",
+    schema: {
+      teamId: z.string().describe("The ID of the team that owns the service."),
+      serviceId: z.string().describe("The ID of the service to retrieve the reliability experiment."),
+      dependencyId: z.string().optional().describe("The ID of the dependency to retrieve the reliability experiment for, if applicable."),
+      testId: z.string().optional().describe("The ID of the reliability test to retrieve the experiment for, if applicable."),
+      limit: z.number().optional().describe("The maximum number of results to return. Defaults to 100."),
+      includeScenarioRun: z.boolean().optional().describe("Include the full scenario run graph data. Defaults to false. Only set to true when you need detailed step-by-step execution data.")
+    },
+    handler: async (args) => {
+      const { serviceId, teamId, dependencyId, testId, limit, includeScenarioRun } = args;
+      if (!serviceId || !teamId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { serviceId: string, teamId: string }`);
+      }
+      try {
+        const results = await api.getReliabilityExperiment(serviceId, teamId, dependencyId, testId, limit);
+        if (includeScenarioRun) {
+          return results;
+        }
+        if ("items" in results) {
+          results.items = results.items.map(summarizeScenarioRun);
+        } else {
+          return summarizeScenarioRun(results);
+        }
+        return results;
+      } catch (error) {
+        console.error(`Error fetching reliability report`, error);
+        throw new Error(`Failed to fetch reliability report: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createGetReliabilityReportTool(api) {
+  return {
+    name: "get_reliability_report",
+    description: "Retrieves the reliability report for a specific service.",
+    schema: {
+      teamId: z.string().describe("The ID of the team that owns the service."),
+      serviceId: z.string().describe("The ID of the service to retrieve the reliability report."),
+      date: z.string().optional().describe("The date for which to retrieve the reliability report, in YYYY-MM-DD format. Defaults to today.")
+    },
+    handler: async (args) => {
+      const { serviceId, teamId, date } = args;
+      if (!serviceId || !teamId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { serviceId: string, teamId: string }`);
+      }
+      try {
+        return await api.getReliabilityReport(serviceId, teamId, date);
+      } catch (error) {
+        console.error(`Error fetching reliability report`, error);
+        throw new Error(`Failed to fetch reliability report: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createGetCurrentTestSuiteTool(api) {
+  return {
+    name: "get_current_test_suite",
+    description: "Retrieves the current test suite for a specific team. Or all if no team is specified.",
+    schema: {
+      teamId: z.string().optional().describe("The ID of the team you're examining the current test suite for.")
+    },
+    handler: async (args) => {
+      const { teamId } = args;
+      try {
+        const testSuites = await api.getAllTestSuite();
+        if (!teamId) {
+          return testSuites;
+        }
+        if (!testSuites || !Array.isArray(testSuites)) {
+          throw new Error("No test suites found or invalid format.");
+        }
+        if (testSuites.length === 0) {
+          return [];
+        }
+        if (!testSuites.some((suite) => suite.targetTeamIds.includes(teamId))) {
+          throw new Error(`No test suites found for team ID: ${teamId}`);
+        }
+        return testSuites.filter((suite) => suite.targetTeamIds.includes(teamId));
+      } catch (error) {
+        console.error(`Error fetching current test suite`, error);
+        throw new Error(`Failed to fetch current test suite: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createRunReliabilityTestTool(api) {
+  return {
+    name: "run_reliability_test",
+    description: [
+      "Run a reliability test for a service.",
+      "Use get_reliability_report to discover valid reliabilityTestId, dependencyId, and failureFlagName values for a service.",
+      "You can also extract these parameters from a previous reliability test run (via get_reliability_experiments) to rerun a test.",
+      "Requires the SERVICES_RUN privilege.",
+      "This call may fail with HTTP 400 if a test is already running or scheduled for the service.",
+      "When this happens, use get_pending_test_runs to see what is queued and wait for it to finish before retrying."
+    ].join(" "),
+    schema: {
+      teamId: z.string().describe("The ID of the team that owns the service."),
+      serviceId: z.string().describe("The ID of the service to run the reliability test against."),
+      reliabilityTestId: z.string().describe("The ID of the reliability test to run. Found in the reliability report's policyStates as 'reliabilityTestId'."),
+      dependencyId: z.string().optional().describe("The ID of the dependency to target, if the test is a dependency test. Found in the reliability report's policyStates."),
+      failureFlagName: z.string().optional().describe("The name of the failure flag to target, if the test uses failure flags. Found in the reliability report's policyStates."),
+      includeScenarioRun: z.boolean().optional().describe("Include the full scenario run graph data. Defaults to false. Only set to true when you need detailed step-by-step execution data.")
+    },
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    handler: async (args) => {
+      const { teamId, serviceId, reliabilityTestId, dependencyId, failureFlagName, includeScenarioRun } = args;
+      if (!teamId || !serviceId || !reliabilityTestId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { teamId: string, serviceId: string, reliabilityTestId: string }`);
+      }
+      try {
+        const result = await api.runReliabilityTest(reliabilityTestId, teamId, {
+          serviceId,
+          dependencyId,
+          failureFlagName
+        });
+        if (includeScenarioRun) {
+          return result;
+        }
+        return summarizeScenarioRun(result);
+      } catch (error) {
+        console.error(`Error running reliability test`, error);
+        throw new Error(`Failed to run reliability test: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createGetPendingTestRunsTool(api) {
+  return {
+    name: "get_pending_test_runs",
+    description: [
+      "Get pending reliability test runs for a service, ordered by expected trigger time.",
+      "Shows tests queued via schedule, Run All, or manual trigger that have not yet started.",
+      "Use this to check whether a test is already queued before calling run_reliability_test,",
+      "or to understand why run_reliability_test returned a 400 error."
+    ].join(" "),
+    schema: {
+      teamId: z.string().describe("The ID of the team that owns the service."),
+      serviceId: z.string().describe("The ID of the service to check for pending test runs.")
+    },
+    handler: async (args) => {
+      const { teamId, serviceId } = args;
+      if (!teamId || !serviceId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { teamId: string, serviceId: string }`);
+      }
+      try {
+        return await api.getPendingTestRuns(serviceId, teamId);
+      } catch (error) {
+        console.error(`Error fetching pending test runs`, error);
+        throw new Error(`Failed to fetch pending test runs: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createGetRecentReliabilityTestsTool(api) {
+  return {
+    name: "get_recent_reliability_tests",
+    description: "Retrieves recent reliability tests for a given team.",
+    schema: {
+      teamId: z.string().describe("The ID of the team that owns the service."),
+      pageSize: z.number().optional().describe("The maximum number of results to return. Defaults to 5."),
+      pageToken: z.string().optional().describe("The token for pagination, if applicable.")
+    },
+    handler: async (args) => {
+      const { teamId, pageSize, pageToken } = args;
+      let limit = pageSize;
+      if (!teamId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { teamId: string }`);
+      }
+      if (!limit) {
+        limit = 5;
+      }
+      try {
+        return await api.getRecentReliabilityTests(teamId, limit, pageToken);
+      } catch (error) {
+        console.error(`Error fetching recent reliability tests`, error);
+        throw new Error(`Failed to fetch recent reliability tests: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+
+// src/tools/services.ts
+import z2 from "zod";
+function createGetServiceDependenciesTool(api) {
+  return {
+    name: "get_service_dependencies",
+    description: "Retrieves the service dependencies for a specific service.",
+    schema: {
+      teamId: z2.string().describe("The ID of the team that owns the service."),
+      serviceId: z2.string().describe("The ID of the service to retrieve the dependencies for")
+    },
+    handler: async (args) => {
+      const { serviceId, teamId } = args;
+      if (!serviceId || !teamId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { serviceId: string, teamId: string }`);
+      }
+      try {
+        return await api.getServiceDependencies(serviceId, teamId);
+      } catch (error) {
+        console.error(`Error fetching service dependencies`, error);
+        throw new Error(`Failed to fetch service dependencies: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createListServiceRisksTool(api) {
+  return {
+    name: "list_service_risks",
+    description: "Lists the risks associated with a specific service.",
+    schema: {
+      teamId: z2.string().describe("The ID of the team that owns the service."),
+      serviceId: z2.string().describe("The ID of the service to retrieve risks for.")
+    },
+    handler: async (args) => {
+      const { serviceId, teamId } = args;
+      if (!serviceId || !teamId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { serviceId: string, teamId: string }`);
+      }
+      try {
+        return await api.getServiceRisks(serviceId, teamId);
+      } catch (error) {
+        console.error(`Error fetching service risks`, error);
+        throw new Error(`Failed to fetch service risks: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createGetServiceStatusChecksTool(api) {
+  return {
+    name: "get_service_status_checks",
+    description: "Retrieves the status checks for a specific service.",
+    schema: {
+      teamId: z2.string().describe("The ID of the team that owns the service."),
+      serviceId: z2.string().describe("The ID of the service to retrieve status checks for.")
+    },
+    handler: async (args) => {
+      const { serviceId, teamId } = args;
+      if (!serviceId || !teamId) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { serviceId: string, teamId: string }`);
+      }
+      try {
+        return await api.getServiceStatusChecks(serviceId, teamId);
+      } catch (error) {
+        console.error(`Error fetching service status checks`, error);
+        throw new Error(`Failed to fetch service status checks: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createListServicesTool(api) {
+  return {
+    name: "list_services",
+    description: "Lists available reliability management services (RM Services for short). Returns service names, descriptions, score, and targeting information.",
+    schema: {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {}
+    },
+    /**
+     * Handles the list_services tool request with pagination and search
+     *
+     * @param params -  none currently, but will be extended for pagination 
+     * @returns list of services with their details
+     */
+    handler: async (params) => {
+      try {
+        const self = await api.getSelf();
+        const services = [];
+        for (const team of self.team_memberships) {
+          const teamServices = (await api.listServicesForTeam(team)).items.map((s) => {
+            s.schedulableTests = [];
+            return s;
+          });
+          services.push(...teamServices);
+        }
+        return services;
+      } catch (error) {
+        console.error(`Error fetching services`, error);
+        throw new Error(`Failed to fetch services: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+
+// src/tools/teams.ts
+function createListTeamsTool(api) {
+  return {
+    name: "list_teams",
+    description: "Lists all teams you have access to",
+    schema: {},
+    handler: async () => {
+      try {
+        return await api.listTeams();
+      } catch (error) {
+        console.error(`Error fetching teams`, error);
+        throw new Error(`Failed to fetch teams: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+
+// src/tools/company.ts
+import z3 from "zod";
+var reportPeriodSchema = z3.enum(["MONTHS", "WEEKS", "DAYS"]);
+var teamIdSchema = z3.string().describe(
+  "The team identifier. Use the list_teams tool to find available teams and match by name or ID."
+);
+function createGetPricingReportTool(api) {
+  return {
+    name: "get_pricing_report",
+    description: "Fetches the pricing usage report for the company over a specified date range. Returns usage broken down by tracking period including active agents, targetable applications, and unique targets by type (host, container, application).",
+    schema: {
+      startDate: z3.string().describe("Start date (yyyy-mm-dd) for the pricing usage. Should be within the current contract duration."),
+      endDate: z3.string().describe("End date (yyyy-mm-dd) for the pricing usage. Should be within the current contract duration."),
+      trackingPeriod: z3.enum(["Daily", "Weekly", "Monthly"]).optional().describe("Tracking period for the pricing usage. Defaults to the currently configured period for the company's plan.")
+    },
+    handler: async (args) => {
+      const { startDate, endDate, trackingPeriod } = args;
+      if (!startDate || !endDate) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { startDate: string, endDate: string, trackingPeriod?: "Daily" | "Weekly" | "Monthly" }`);
+      }
+      try {
+        return await api.getPricingReport(startDate, endDate, trackingPeriod);
+      } catch (error) {
+        throw new Error(`Failed to fetch pricing report: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createGetClientSummaryTool(api) {
+  return {
+    name: "get_client_summary",
+    description: "Loads the client (agent) summary for a team over a specified time period. Shows agent activity and status. Requires a teamId, use the list_teams tool first to find available teams.",
+    schema: {
+      teamId: teamIdSchema,
+      start: z3.string().describe("Start date (yyyy-mm-dd) for the report."),
+      end: z3.string().describe("End date (yyyy-mm-dd) for the report."),
+      period: reportPeriodSchema.describe("Aggregation period for the report: MONTHS, WEEKS, or DAYS.")
+    },
+    handler: async (args) => {
+      const { teamId, start, end, period } = args;
+      if (!teamId || !start || !end || !period) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { teamId: string, start: string, end: string, period: "MONTHS" | "WEEKS" | "DAYS" }`);
+      }
+      try {
+        return await api.getClientSummary(teamId, start, end, period);
+      } catch (error) {
+        throw new Error(`Failed to fetch client summary: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function createGetAttackSummaryTool(api) {
+  return {
+    name: "get_attack_summary",
+    description: "Loads the attack summary for a team over a specified time period. Shows attack activity and results. Requires a teamId, use the list_teams tool first to find available teams.",
+    schema: {
+      teamId: teamIdSchema,
+      start: z3.string().describe("Start date (yyyy-mm-dd) for the report."),
+      end: z3.string().describe("End date (yyyy-mm-dd) for the report."),
+      period: reportPeriodSchema.describe("Aggregation period for the report: MONTHS, WEEKS, or DAYS.")
+    },
+    handler: async (args) => {
+      const { teamId, start, end, period } = args;
+      if (!teamId || !start || !end || !period) {
+        throw new Error(`got ${JSON.stringify(args)} but expected { teamId: string, start: string, end: string, period: "MONTHS" | "WEEKS" | "DAYS" }`);
+      }
+      try {
+        return await api.getAttackSummary(teamId, start, end, period);
+      } catch (error) {
+        throw new Error(`Failed to fetch attack summary: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+
+// src/tools/openapi.ts
+import z4 from "zod";
+
+// src/openapi/spec-loader.ts
+var SPEC_URL = "https://api.gremlin.com/v1/openapi.json";
+var HTTP_METHODS = ["get", "post", "put", "delete", "patch"];
+var SPEC_TTL_MS = 60 * 60 * 1e3;
+var cachedSpec = null;
+var cachedAt = 0;
+var specFetchPromise = null;
+async function getSpec() {
+  if (cachedSpec && Date.now() - cachedAt < SPEC_TTL_MS) return cachedSpec;
+  if (!specFetchPromise) {
+    specFetchPromise = fetchSpec().then((spec) => {
+      cachedSpec = spec;
+      cachedAt = Date.now();
+      specFetchPromise = null;
+      return spec;
+    }).catch((err) => {
+      specFetchPromise = null;
+      throw err;
+    });
+  }
+  return specFetchPromise;
+}
+async function fetchSpec() {
+  const res = await fetch(SPEC_URL);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch Gremlin OpenAPI spec: HTTP ${res.status}`);
+  }
+  return res.json();
+}
+function scoreToken(token, pathLower, op) {
+  let score = 0;
+  if (pathLower.includes(token)) score += 3;
+  if (op.operationId?.toLowerCase().includes(token)) score += 3;
+  if (op.summary?.toLowerCase().includes(token)) score += 2;
+  if (op.tags?.some((t) => t.toLowerCase().includes(token))) score += 2;
+  if (op.description?.toLowerCase().includes(token)) score += 1;
+  return score;
+}
+function tokenize(query) {
+  return query.toLowerCase().split(/[\s/\-_{}]+/).filter((t) => t.length > 0);
+}
+function searchSpec(spec, query, methodFilter, tagFilter, topN = 10) {
+  const queryLower = query.toLowerCase();
+  const tokens = tokenize(query);
+  const methodLower = methodFilter?.toLowerCase();
+  const tagLower = tagFilter?.toLowerCase();
+  const scored = [];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (!op) continue;
+      if (methodLower && method !== methodLower) continue;
+      if (tagLower && !op.tags?.some((t) => t.toLowerCase().includes(tagLower))) continue;
+      const pathLower = path.toLowerCase();
+      const phraseScore = scoreToken(queryLower, pathLower, op);
+      let tokenScore = 0;
+      let allTokensMatched = true;
+      for (const token of tokens) {
+        const ts = scoreToken(token, pathLower, op);
+        if (ts === 0) {
+          allTokensMatched = false;
+          break;
+        }
+        tokenScore += ts;
+      }
+      if (!allTokensMatched) tokenScore = 0;
+      const score = Math.max(phraseScore, tokenScore);
+      if (score === 0) continue;
+      scored.push({
+        score,
+        match: {
+          method: method.toUpperCase(),
+          path,
+          summary: op.summary,
+          description: op.description,
+          operationId: op.operationId,
+          tags: op.tags,
+          parameters: op.parameters,
+          requestBody: op.requestBody
+        }
+      });
+    }
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, topN).map((s) => s.match);
+}
+
+// src/tools/openapi.ts
+function createSearchGremlinApiTool(_api) {
+  return {
+    name: "search_gremlin_api",
+    description: [
+      "Search the Gremlin OpenAPI spec to discover available API endpoints.",
+      "Returns matching endpoints with their method, path, parameters, and request body schema.",
+      "Use this before execute_gremlin_api to find the correct path and parameter names.",
+      "Paths use OpenAPI template syntax (e.g. /reliability-tests/{reliabilityTestId}/runs) \u2014",
+      "pass them directly to execute_gremlin_api."
+    ].join(" "),
+    schema: {
+      query: z4.string().describe(
+        "Text to search for in endpoint paths, summaries, operationIds, tags, and descriptions."
+      ),
+      method: z4.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("Filter results to a specific HTTP method."),
+      tag: z4.string().optional().describe("Filter results to endpoints with this tag (partial match, case-insensitive)."),
+      limit: z4.number().int().min(1).max(50).optional().describe("Maximum number of results to return. Defaults to 10.")
+    },
+    handler: async (args) => {
+      const { query, method, tag, limit = 10 } = args;
+      if (!query?.trim()) {
+        throw new Error("query must be a non-empty string");
+      }
+      let spec;
+      try {
+        spec = await getSpec();
+      } catch (err) {
+        throw new Error(
+          `Failed to load Gremlin OpenAPI spec: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      const results = searchSpec(spec, query, method, tag, limit);
+      if (results.length === 0) {
+        return {
+          message: "No matching endpoints found. Try a broader query or different filters.",
+          results: []
+        };
+      }
+      return {
+        message: `Found ${results.length} matching endpoint(s).`,
+        results
+      };
+    }
+  };
+}
+function getRunPrivileges(spec, specPath, method) {
+  const op = spec.paths[specPath]?.[method.toLowerCase()];
+  if (!op?.security) return [];
+  const privileges = [];
+  for (const secReq of op.security) {
+    for (const perms of Object.values(secReq)) {
+      for (const perm of perms) {
+        if (perm.endsWith("_RUN")) privileges.push(perm);
+      }
+    }
+  }
+  return privileges;
+}
+function createExecuteGremlinApiTool(api, elicitation) {
+  return {
+    name: "execute_gremlin_api",
+    description: [
+      "Execute any Gremlin API endpoint directly.",
+      "Use search_gremlin_api first to discover the correct path, method, and parameter names.",
+      "The path should use OpenAPI template syntax for path parameters",
+      "(e.g. /reliability-tests/{reliabilityTestId}/runs) \u2014 they are substituted automatically.",
+      "WARNING: This tool can trigger real chaos experiments. Verify the endpoint and parameters carefully."
+    ].join(" "),
+    schema: {
+      method: z4.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).describe("HTTP method for the request."),
+      path: z4.string().describe(
+        "API path as shown in the OpenAPI spec, e.g. /reliability-tests/{reliabilityTestId}/runs. Leading slash is optional."
+      ),
+      pathParams: z4.record(z4.string()).optional().describe(
+        "Values to substitute into path template variables, e.g. { reliabilityTestId: 'abc123' }."
+      ),
+      queryParams: z4.record(z4.string()).optional().describe("Query string parameters, e.g. { teamId: 'my-team' }."),
+      body: z4.record(z4.unknown()).optional().describe("Request body for POST/PUT/PATCH requests."),
+      confirmExecution: z4.boolean().optional().describe(
+        "Set to true to explicitly confirm execution of endpoints that require a *_RUN privilege, bypassing the interactive elicitation prompt. Use this when your MCP client does not support elicitation. Only set this after verifying the endpoint and parameters."
+      )
+    },
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    handler: async (args) => {
+      const { method, path: rawPath, pathParams, queryParams, body, confirmExecution } = args;
+      const specPath = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
+      let runPrivileges = [];
+      try {
+        const spec = await getSpec();
+        runPrivileges = getRunPrivileges(spec, specPath, method);
+      } catch (err) {
+        console.error(
+          `Warning: could not load spec to check permissions for ${method} ${specPath}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      if (runPrivileges.length > 0 && !confirmExecution) {
+        let answer;
+        try {
+          answer = await elicitation.confirm(
+            `This endpoint requires the **${runPrivileges.join(", ")}** privilege(s), which can trigger live chaos experiments. Do you want to proceed?
+
+**Endpoint:** \`${method} ${specPath}\``,
+            [
+              { label: "Execute", value: "confirmed", description: "Proceed with the API call." },
+              { label: "Cancel", value: "cancelled", description: "Abort without making the request." }
+            ]
+          );
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw new Error(
+            `Cannot confirm execution of ${method} ${specPath}: the runtime does not support interactive prompts. This endpoint requires the ${runPrivileges.join(", ")} privilege(s). Pass confirmExecution: true to bypass the prompt and proceed directly. (${msg})`
+          );
+        }
+        if (answer !== "confirmed") {
+          throw new Error(`Execution cancelled. The request was not sent to Gremlin.`);
+        }
+      }
+      let resolvedPath = specPath.slice(1);
+      if (pathParams) {
+        for (const [key, value] of Object.entries(pathParams)) {
+          resolvedPath = resolvedPath.replace(
+            new RegExp(`\\{${key}\\}`, "g"),
+            encodeURIComponent(value)
+          );
+        }
+      }
+      const unresolved = resolvedPath.match(/\{[^}]+\}/g);
+      if (unresolved) {
+        throw new Error(
+          `Path still contains unresolved template variables: ${unresolved.join(", ")}. Provide values for these in pathParams.`
+        );
+      }
+      try {
+        return await api.execute(method, resolvedPath, queryParams, body);
+      } catch (err) {
+        throw new Error(
+          `Gremlin API call failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  };
+}
+
+// src/tools/index.ts
+function registerTools(server, api) {
+  const tools = [
+    createListServicesTool(api),
+    createGetServiceDependenciesTool(api),
+    createGetServiceStatusChecksTool(api),
+    createListServiceRisksTool(api),
+    createGetReliabilityReportTool(api),
+    createGetReliabilityExperimentTool(api),
+    createGetRecentReliabilityTestsTool(api),
+    createGetCurrentTestSuiteTool(api),
+    createRunReliabilityTestTool(api),
+    createGetPendingTestRunsTool(api),
+    createListTeamsTool(api),
+    createGetPricingReportTool(api),
+    createGetClientSummaryTool(api),
+    createGetAttackSummaryTool(api),
+    createSearchGremlinApiTool(api),
+    createExecuteGremlinApiTool(api, new McpElicitationClient(server))
+  ];
+  for (const tool of tools) {
+    server.tool(
+      tool.name,
+      tool.description,
+      tool.schema,
+      //tool.annotations || { example: "annotation"},
+      async (args, extra) => {
+        try {
+          const result = await tool.handler(args, extra);
+          if (result && typeof result === "object" && "content" in result) {
+            return result;
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: error instanceof Error ? error.message : String(error)
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+}
+
+// src/resources/index.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResources(server, api) {
+  server.resource(
+    "teams",
+    new ResourceTemplate("gremlin://team/{teamId}", {
+      list: async () => {
+        const resources = [];
+        try {
+          const teams = await api.listTeams();
+          teams.forEach((team) => {
+            resources.push({
+              uri: `gremlin://team/${team.identifier}`,
+              name: team.name,
+              companyId: team.companyId,
+              production: team.production
+            });
+          });
+        } catch (error) {
+          console.error(`Error fetching teams`, error);
+        }
+        return { resources };
+      }
+    }),
+    async (_uri, variables) => {
+      const teamId = Array.isArray(variables.teamId) ? variables.teamId[0] : variables.teamId;
+      try {
+        const team = await api.getTeam(teamId);
+        return {
+          contents: [{
+            uri: `gremlin://team/${teamId}`,
+            text: JSON.stringify(team, null, 2),
+            mimeType: "application/json"
+          }]
+        };
+      } catch (error) {
+        throw new Error(`Failed to get team: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  );
+  server.resource(
+    "services",
+    new ResourceTemplate("gremlin://service/{teamId}/{serviceId}", {
+      list: async () => {
+        const resources = [];
+        try {
+          const self = await api.getSelf();
+          const services = [];
+          for (const team of self.team_memberships) {
+            const teamServices = (await api.listServicesForTeam(team)).items;
+            services.push(...teamServices);
+          }
+          services.forEach((service) => {
+            resources.push({
+              uri: `gremlin://service/${service.teamId}/${service.serviceId}`,
+              name: service.name,
+              targets: service.targetingStrategy || service.applicationSelector || ""
+            });
+          });
+        } catch (error) {
+          console.error(`Error fetching services`, error);
+        }
+        return { resources };
+      }
+    }),
+    async (_uri, variables) => {
+      const serviceId = Array.isArray(variables.serviceId) ? variables.serviceId[0] : variables.serviceId;
+      const teamId = Array.isArray(variables.teamId) ? variables.teamId[0] : variables.teamId;
+      try {
+        const service = await api.getService(serviceId, teamId);
+        return {
+          contents: [{
+            uri: `gremlin://service/${teamId}/${serviceId}`,
+            text: JSON.stringify(service, null, 2),
+            mimeType: "application/json"
+          }]
+        };
+      } catch (error) {
+        throw new Error(`Failed to get service: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  );
+}
+export {
+  McpElicitationClient,
+  createExecuteGremlinApiTool,
+  createGetAttackSummaryTool,
+  createGetClientSummaryTool,
+  createGetCurrentTestSuiteTool,
+  createGetPendingTestRunsTool,
+  createGetPricingReportTool,
+  createGetRecentReliabilityTestsTool,
+  createGetReliabilityExperimentTool,
+  createGetReliabilityReportTool,
+  createGetServiceDependenciesTool,
+  createGetServiceStatusChecksTool,
+  createListServiceRisksTool,
+  createListServicesTool,
+  createListTeamsTool,
+  createRunReliabilityTestTool,
+  createSearchGremlinApiTool,
+  registerResources,
+  registerTools
+};