@skyramp/mcp 0.4.4-rc.1 → 0.4.4

package/build/tools/executeFleetTool.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/server";
+export declare const fleetExecutionInputSchema: {
+    directory: z.ZodString;
+    entryClass: z.ZodOptional<z.ZodString>;
+    certsDir: z.ZodString;
+    credentials: z.ZodOptional<z.ZodString>;
+    libraryJar: z.ZodOptional<z.ZodString>;
+    executorImage: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodEnum<{
+        linux: "linux";
+        windows: "windows";
+    }>>;
+    timeoutSec: z.ZodOptional<z.ZodNumber>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+};
+/**
+ * Runs a generated fleet test and reports what happened.
+ *
+ * Generation ends at three files someone still has to run. This closes that loop: the same
+ * executor container every other generated test runs in compiles the trio and starts the
+ * fleet manager, and the caller gets the run's own report plus its result as data.
+ *
+ * The worker is deployed by the test, not by this tool, so the run needs a remote Docker
+ * engine: inside a container, a locally deployed worker is not reachable at the localhost
+ * address the fleet resolves for it.
+ */
+export declare function registerExecuteFleetTool(server: McpServer): void;

package/build/tools/executeFleetTool.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { executeFleet, JAVA_CLASS_NAME, } from "../services/FleetExecutionService.js";
+import { logger } from "../utils/logger.js";
+import { toolError } from "../utils/utils.js";
+const TOOL_NAME = "skyramp_execute_fleet";
+export const fleetExecutionInputSchema = {
+    directory: z
+        .string()
+        .describe("Directory holding a generated Java ui-load trio (the fleet, load and journey " +
+        "classes) and, usually, its credentials.csv. Java only: a python, typescript or " +
+        "javascript fleet manager is a script, run it directly."),
+    entryClass: z
+        .string()
+        .regex(JAVA_CLASS_NAME)
+        .optional()
+        .describe("The fleet class to run. Discovered from *FleetTest.java when omitted."),
+    certsDir: z
+        .string()
+        .describe("Docker client certificates for the remote engine (ca.pem, cert.pem, key.pem). " +
+        "Required: the run needs a remote engine, and a remote engine is mTLS. Mounted " +
+        "read-only and exported as SKYRAMP_DOCKER_CERTS."),
+    credentials: z
+        .string()
+        .optional()
+        .describe("Credential pool file. Defaults to credentials.csv beside the test."),
+    libraryJar: z
+        .string()
+        .optional()
+        .describe("A branch-built skyramp-library jar to compile and run against, for a fix that is not " +
+        "released yet. The executor image's own SDK is used when this is omitted."),
+    executorImage: z
+        .string()
+        .optional()
+        .describe("Container image to compile and run in. Defaults to the released executor, or " +
+        "SKYRAMP_EXECUTOR_IMAGE. Name a branch-built one when its baked SDK is what you " +
+        "are testing."),
+    platform: z
+        .enum(["linux", "windows"])
+        .optional()
+        .describe("The daemon's container OS. Omit it to use the daemon's own OS. If given, it " +
+        "must match the daemon, or the run is refused."),
+    timeoutSec: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Seconds before the run is killed. Default 600."),
+    env: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("Extra environment for the run, e.g. SKYRAMP_TEST_BASE_URL."),
+};
+/**
+ * Runs a generated fleet test and reports what happened.
+ *
+ * Generation ends at three files someone still has to run. This closes that loop: the same
+ * executor container every other generated test runs in compiles the trio and starts the
+ * fleet manager, and the caller gets the run's own report plus its result as data.
+ *
+ * The worker is deployed by the test, not by this tool, so the run needs a remote Docker
+ * engine: inside a container, a locally deployed worker is not reachable at the localhost
+ * address the fleet resolves for it.
+ */
+export function registerExecuteFleetTool(server) {
+    server.registerTool(TOOL_NAME, {
+        title: "Execute a generated fleet test",
+        description: "Compile and run a generated Java ui-load fleet trio in the Skyramp executor container, " +
+            "against a remote Docker engine, and return the run's report, its verdict and its " +
+            "structured result. Point it at the directory the generation wrote.",
+        inputSchema: z.object(fleetExecutionInputSchema),
+    }, async (args) => {
+        try {
+            const run = await executeFleet({
+                directory: args.directory,
+                executorImage: args.executorImage,
+                platform: args.platform,
+                entryClass: args.entryClass,
+                certsDir: args.certsDir,
+                credentials: args.credentials,
+                libraryJar: args.libraryJar,
+                timeoutSec: args.timeoutSec,
+                env: args.env,
+            });
+            const headline = run.timedOut
+                ? `Fleet run timed out after ${args.timeoutSec ?? 600}s`
+                : `Fleet run ${run.passed ? "PASSED" : "FAILED"} (${run.entryClass} in ${run.executorImage}, exit ${run.exitCode})`;
+            const text = [
+                headline,
+                run.report || "(the run printed no report lines)",
+                run.result
+                    ? "Structured result:\n" + JSON.stringify(run.result, null, 2)
+                    : "",
+                run.passed ? "" : "Output:\n" + run.output.slice(-4000),
+            ]
+                .filter(Boolean)
+                .join("\n\n");
+            return {
+                content: [{ type: "text", text }],
+                ...(run.passed ? {} : { isError: true }),
+            };
+        }
+        catch (error) {
+            logger.error(`${TOOL_NAME} failed: ${error}`);
+            return toolError(error instanceof Error ? error.message : String(error));
+        }
+    });
+}

package/build/tools/executeSkyrampTestTool.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 import { TestExecutionStatus, TestExecutionResult, type TestExecutionRecord } from "../types/TestExecution.js";
 import { ProgrammingLanguage, TestType } from "../types/TestTypes.js";
 import { MaintenanceActionCore, TestAnalysisResult } from "../types/TestAnalysis.js";
@@ -178,14 +178,17 @@ export declare const inputSchema: {
     cwd: z.ZodOptional<z.ZodString>;
     workspacePath: z.ZodOptional<z.ZodString>;
     testFile: z.ZodString;
-    language: z.ZodNativeEnum<typeof ProgrammingLanguage>;
-    testType: z.ZodNativeEnum<typeof TestType>;
-    phase: z.ZodDefault<z.ZodEnum<["before", "after"]>>;
+    language: z.ZodEnum<typeof ProgrammingLanguage>;
+    testType: z.ZodEnum<typeof TestType>;
+    phase: z.ZodDefault<z.ZodEnum<{
+        before: "before";
+        after: "after";
+    }>>;
     stateFile: z.ZodOptional<z.ZodString>;
     repository: z.ZodString;
     token: z.ZodOptional<z.ZodString>;
     unauthenticated: z.ZodOptional<z.ZodBoolean>;
-    rebaselineSnapshots: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rebaselineSnapshots: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timeout: z.ZodOptional<z.ZodNumber>;
 };
 export declare function registerExecuteSkyrampTestTool(server: McpServer): void;

package/build/tools/executeSkyrampTestTool.js

@@ -654,10 +654,10 @@ export const inputSchema = {
         .describe("Absolute path of the Skyramp workspace. Required when commandOverride is omitted, because the executor resolves the service and its base URL from it."),
     testFile: z.string().describe("Absolute path to the test file to execute."),
     language: z
-        .nativeEnum(ProgrammingLanguage)
+        .enum(ProgrammingLanguage)
         .describe("Programming language of the test file to execute (e.g., python, javascript, typescript, java)"),
     testType: z
-        .nativeEnum(TestType)
+        .enum(TestType)
         .describe("Type of the test to execute. Note: 'mock' is NOT a valid test type — mock files are deployed via their apply_mock() function, not executed as tests."),
     phase: z
         .enum(["before", "after"])
@@ -1035,12 +1035,12 @@ export function registerExecuteSkyrampTestTool(server) {
             idempotentHint: false,
             openWorldHint: true,
         },
-        inputSchema,
+        inputSchema: z.object(inputSchema),
         _meta: {
             keywords: ["run test", "execute test"],
         },
-    }, async (params, extra) => {
-        const sendProgress = makeProgressReporter(extra);
+    }, async (params, ctx) => {
+        const sendProgress = makeProgressReporter(ctx);
         // Progress callback adapter for TestExecutionService.
         const onExecutionProgress = async (progress) => {
             await sendProgress(progress.percent, 100, progress.message);

package/build/tools/fixErrorTool.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerFixErrorTool(server: McpServer): void;

package/build/tools/fixErrorTool.js

@@ -18,7 +18,7 @@ const TOOL_NAME = "skyramp_fix_errors";
 export function registerFixErrorTool(server) {
     server.registerTool(TOOL_NAME, {
         description: "Return guidance for repairing test reference, syntax, import, and missing-dependency errors while preserving the scenario, expected behavior, and assertion strength.",
-        inputSchema: fixErrorSchema.shape,
+        inputSchema: fixErrorSchema,
         _meta: {
             keywords: [
                 "modularization",

package/build/tools/generate-tests/batchMockGenerationTool.d.ts

@@ -1,15 +1,14 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, CallToolResult } from "@modelcontextprotocol/server";
 import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { MockProtocol } from "../../types/TestTypes.js";
 export { MockProtocol } from "../../types/TestTypes.js";
 export declare const BATCH_MOCK_PROTOCOL_EXAMPLES = "\n<example protocol=\"rest\">\nBatch REST item. Required fields: protocol=\"rest\", endpointURL, method unless apiSchema is provided.\n{\n  \"protocol\": \"rest\",\n  \"endpointURL\": \"http://identity-service:4000/api/internal/v1/users/validate\",\n  \"method\": \"POST\",\n  \"requestAware\": true,\n  \"responseData\": \"{\"valid\":true}\"\n}\n</example>\n\n<example protocol=\"rest-traffic-simulation\">\nBatch REST item with traffic simulation. minLatency/maxLatency inject a random delay per response; dropRate drops a percentage of requests.\n{\n  \"protocol\": \"rest\",\n  \"endpointURL\": \"http://payment-service:5001/payments\",\n  \"method\": \"POST\",\n  \"responseData\": \"{\"status\":\"ok\"}\",\n  \"minLatency\": 500,\n  \"maxLatency\": 1000,\n  \"dropRate\": 10\n}\n</example>\n\n<example protocol=\"rest-conditional\">\nBatch REST item with conditional response selection. Use \"when\" to match request fields.\n{\n  \"protocol\": \"rest\",\n  \"endpointURL\": \"http://payment-service:5001/api/v1/orders\",\n  \"method\": \"POST\",\n  \"when\": {\"request.body.payment.method\": \"card\"},\n  \"requestSchema\": \"{\"type\":\"object\",\"required\":[\"orderId\",\"payment\"]}\",\n  \"responseData\": \"{\"status\":\"confirmed\"}\",\n  \"responseStatusCode\": \"201\",\n  \"noMatchStatusCode\": 404,\n  \"validationFailureStatusCode\": 422\n}\n</example>\n\n<example protocol=\"grpc\">\nBatch gRPC item. Required fields: protocol=\"grpc\", endpointURL as host:port, protoPath, grpcServiceName. method is the RPC name; empty means all service methods.\n{\n  \"protocol\": \"grpc\",\n  \"endpointURL\": \"profile-service:50051\",\n  \"protoPath\": \"/repo/proto/profiles.proto\",\n  \"grpcServiceName\": \"ProfileService\",\n  \"method\": \"GetProfile\",\n  \"responseData\": \"{\"id\":\"profile_123\"}\"\n}\n</example>\n\n<example protocol=\"grpc-traffic-simulation\">\nBatch gRPC item with traffic simulation. Same latency/drop fields as REST.\n{\n  \"protocol\": \"grpc\",\n  \"endpointURL\": \"profile-service:50051\",\n  \"protoPath\": \"/repo/proto/profiles.proto\",\n  \"grpcServiceName\": \"ProfileService\",\n  \"method\": \"GetProfile\",\n  \"responseData\": \"{\"eligible\":true}\",\n  \"minLatency\": 200,\n  \"maxLatency\": 800,\n  \"dropRate\": 5\n}\n</example>\n\n<example protocol=\"grpc-status-error\">\nBatch gRPC status error item. Do not provide responseData with grpcStatusCode.\n{\n  \"protocol\": \"grpc\",\n  \"endpointURL\": \"profile-service:50051\",\n  \"protoPath\": \"/repo/proto/profiles.proto\",\n  \"grpcServiceName\": \"ProfileService\",\n  \"method\": \"GetProfile\",\n  \"grpcStatusCode\": 5,\n  \"grpcStatusMessage\": \"profile not found\"\n}\n</example>\n\n<example protocol=\"kafka-producer\">\nBatch Kafka producer validation item. Required fields: protocol=\"kafka\", endpointURL as broker host:port, kafkaTopic, and requestData. Do not pass method or responseData. Traffic simulation is NOT supported for Kafka.\n{\n  \"protocol\": \"kafka\",\n  \"endpointURL\": \"broker:9092\",\n  \"kafkaTopic\": \"orders\",\n  \"requestData\": \"{\"order_id\":\"ord_123\"}\"\n}\n</example>\n\n<example protocol=\"kafka-consumer\">\nBatch Kafka consumer message item. Required fields: protocol=\"kafka\", endpointURL as broker host:port, kafkaTopic, and responseData. Do not pass method or requestData. Traffic simulation is NOT supported for Kafka.\n{\n  \"protocol\": \"kafka\",\n  \"endpointURL\": \"broker:9092\",\n  \"kafkaTopic\": \"orders\",\n  \"responseData\": \"{\"accepted\":true}\"\n}\n</example>";
 declare const mockSpecSchema: z.ZodObject<{
-    protocol: z.ZodDefault<z.ZodNativeEnum<typeof MockProtocol>>;
+    protocol: z.ZodDefault<z.ZodEnum<typeof MockProtocol>>;
     endpointURL: z.ZodString;
     method: z.ZodDefault<z.ZodString>;
     responseData: z.ZodOptional<z.ZodString>;
-    responseStatusCode: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+    responseStatusCode: z.ZodDefault<z.ZodString>;
     grpcStatusCode: z.ZodOptional<z.ZodNumber>;
     grpcStatusMessage: z.ZodOptional<z.ZodString>;
     requestData: z.ZodDefault<z.ZodString>;
@@ -17,8 +16,8 @@ declare const mockSpecSchema: z.ZodObject<{
     apiSchema: z.ZodDefault<z.ZodString>;
     protoPath: z.ZodOptional<z.ZodString>;
     grpcServiceName: z.ZodOptional<z.ZodString>;
-    protobufExtraFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    protobufExtraImportPath: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    protobufExtraFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    protobufExtraImportPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
     kafkaTopic: z.ZodOptional<z.ZodString>;
     minLatency: z.ZodOptional<z.ZodNumber>;
     maxLatency: z.ZodOptional<z.ZodNumber>;
@@ -29,57 +28,7 @@ declare const mockSpecSchema: z.ZodObject<{
     validationFailureStatusCode: z.ZodOptional<z.ZodNumber>;
     output: z.ZodOptional<z.ZodString>;
     outputDir: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    method: string;
-    endpointURL: string;
-    apiSchema: string;
-    requestData: string;
-    responseStatusCode: string;
-    protocol: MockProtocol;
-    requestAware: boolean;
-    output?: string | undefined;
-    outputDir?: string | undefined;
-    responseData?: string | undefined;
-    when?: Record<string, unknown> | undefined;
-    protoPath?: string | undefined;
-    grpcServiceName?: string | undefined;
-    protobufExtraFiles?: string[] | undefined;
-    protobufExtraImportPath?: string[] | undefined;
-    kafkaTopic?: string | undefined;
-    grpcStatusCode?: number | undefined;
-    grpcStatusMessage?: string | undefined;
-    minLatency?: number | undefined;
-    maxLatency?: number | undefined;
-    dropRate?: number | undefined;
-    requestSchema?: string | undefined;
-    noMatchStatusCode?: number | undefined;
-    validationFailureStatusCode?: number | undefined;
-}, {
-    endpointURL: string;
-    output?: string | undefined;
-    outputDir?: string | undefined;
-    method?: string | undefined;
-    apiSchema?: string | undefined;
-    requestData?: string | undefined;
-    responseStatusCode?: string | undefined;
-    responseData?: string | undefined;
-    when?: Record<string, unknown> | undefined;
-    protocol?: MockProtocol | undefined;
-    protoPath?: string | undefined;
-    grpcServiceName?: string | undefined;
-    protobufExtraFiles?: string[] | undefined;
-    protobufExtraImportPath?: string[] | undefined;
-    kafkaTopic?: string | undefined;
-    grpcStatusCode?: number | undefined;
-    grpcStatusMessage?: string | undefined;
-    requestAware?: boolean | undefined;
-    minLatency?: number | undefined;
-    maxLatency?: number | undefined;
-    dropRate?: number | undefined;
-    requestSchema?: string | undefined;
-    noMatchStatusCode?: number | undefined;
-    validationFailureStatusCode?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type MockSpec = z.infer<typeof mockSpecSchema>;
 export type MockSpecInput = z.input<typeof mockSpecSchema>;
 export interface BatchMockResult {

package/build/tools/generate-tests/batchMockGenerationTool.js

@@ -112,7 +112,7 @@ Batch Kafka consumer message item. Required fields: protocol="kafka", endpointUR
 </example>`;
 const mockSpecSchema = z.object({
     protocol: z
-        .nativeEnum(MockProtocol)
+        .enum(MockProtocol)
         .default(MockProtocol.Rest)
         .describe("Protocol for this mock: 'rest', 'grpc', or 'kafka'. See <example> blocks in the tool description for required fields."),
     endpointURL: z
@@ -198,7 +198,7 @@ const mockSpecSchema = z.object({
         .optional()
         .describe("Percentage [0-100] of requests dropped/errored for traffic simulation (REST and gRPC only)."),
     when: z
-        .record(z.unknown())
+        .record(z.string(), z.unknown())
         .optional()
         .describe("Conditional-selection predicate (operator map) for REST and gRPC mocks. " +
         "Keys are request paths (request.body.<jsonpath>, request.path.<name>, etc.); " +
@@ -559,7 +559,7 @@ Use this tool when you need to mock 2+ downstream services simultaneously (e.g.,
 local-dev workflow with multiple dependencies).
 
 ${BATCH_MOCK_PROTOCOL_EXAMPLES}`,
-        inputSchema: batchMockSchema,
+        inputSchema: z.object(batchMockSchema),
     }, async (params) => {
         const result = await executeBatchMockGeneration(params);
         AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch(() => {

package/build/tools/generate-tests/generateBatchScenarioRestTool.d.ts

@@ -1,50 +1,14 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import { HttpMethod } from "../../types/TestTypes.js";
-export declare const stepSchema: z.ZodEffects<z.ZodObject<{
-    method: z.ZodNativeEnum<typeof HttpMethod>;
+export declare const stepSchema: z.ZodObject<{
+    method: z.ZodEnum<typeof HttpMethod>;
     path: z.ZodString;
-    requestBody: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
-    queryParams: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
-    responseBody: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    requestBody: z.ZodOptional<z.ZodString>;
+    queryParams: z.ZodOptional<z.ZodString>;
+    responseBody: z.ZodOptional<z.ZodString>;
     statusCode: z.ZodOptional<z.ZodNumber>;
-    responseHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-    uniqueFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    method: HttpMethod;
-    queryParams?: string | undefined;
-    statusCode?: number | undefined;
-    requestBody?: string | undefined;
-    responseBody?: string | undefined;
-    responseHeaders?: Record<string, string[]> | undefined;
-    uniqueFields?: string[] | undefined;
-}, {
-    path: string;
-    method: HttpMethod;
-    queryParams?: string | undefined;
-    statusCode?: number | undefined;
-    requestBody?: string | undefined;
-    responseBody?: string | undefined;
-    responseHeaders?: Record<string, string[]> | undefined;
-    uniqueFields?: string[] | undefined;
-}>, {
-    path: string;
-    method: HttpMethod;
-    queryParams?: string | undefined;
-    statusCode?: number | undefined;
-    requestBody?: string | undefined;
-    responseBody?: string | undefined;
-    responseHeaders?: Record<string, string[]> | undefined;
-    uniqueFields?: string[] | undefined;
-}, {
-    path: string;
-    method: HttpMethod;
-    queryParams?: string | undefined;
-    statusCode?: number | undefined;
-    requestBody?: string | undefined;
-    responseBody?: string | undefined;
-    responseHeaders?: Record<string, string[]> | undefined;
-    uniqueFields?: string[] | undefined;
-}>;
+    responseHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    uniqueFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare function registerBatchScenarioTestTool(server: McpServer): void;

package/build/tools/generate-tests/generateBatchScenarioRestTool.js

@@ -1,5 +1,6 @@
 import { TOOL_BATCH_SCENARIO_TEST_GENERATION } from "../../toolNames.js";
 import { z } from "zod";
+import os from "os";
 import path from "path";
 import { ScenarioGenerationService, } from "../../services/ScenarioGenerationService.js";
 import fs from "fs";
@@ -14,7 +15,22 @@ import { guardScenarioApproved } from "./planGuard.js";
 import { lintScenarioChaining } from "./scenarioLint.js";
 import { scenarioFileNameFor } from "./scenarioFileIdentity.js";
 import { toolError } from "../../utils/utils.js";
+import { isTestbotEnabled } from "../../utils/featureFlags.js";
 import { isRecord } from "ts-is-record";
+/**
+ * Where the scenario file is written. The file is only an input to integration
+ * generation — the generated test does not read it — so a Testbot run writes it
+ * outside the checkout, where staging the test directory cannot put it in the
+ * Testbot PR (SKYR-4552). A fresh directory per call keeps two same-named
+ * scenarios (one per related repo) from overwriting each other. Everywhere
+ * else it goes next to the test, as before.
+ */
+function scenarioFilePath(outputDir, fileName) {
+    if (!isTestbotEnabled())
+        return path.join(outputDir, fileName);
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-scenario-"));
+    return path.join(dir, fileName);
+}
 function isJsonValue(v) {
     if (v === undefined || v === null)
         return true;
@@ -51,7 +67,7 @@ function isJsonObject(v) {
 }
 export const stepSchema = z
     .object({
-    method: z.nativeEnum(HttpMethod).describe("HTTP method for this step."),
+    method: z.enum(HttpMethod).describe("HTTP method for this step."),
     path: z
         .string()
         .startsWith("/", {
@@ -103,7 +119,7 @@ Workspace-configured api.defaultQueryParams (if set) are merged into every step
         .optional()
         .describe("Expected HTTP status code. Defaults: DELETE→204 and GET/PUT/PATCH→200. For POST, pass the confirmed statusCode explicitly after checking whether the endpoint creates a resource (commonly 201) or performs an action (often 200)."),
     responseHeaders: z
-        .record(z.array(z.string()))
+        .record(z.string(), z.array(z.string()))
         .optional()
         .describe("Response headers as a JSON object. Defaults to Content-Type: application/json."),
     uniqueFields: z
@@ -134,7 +150,7 @@ Workspace-configured api.defaultQueryParams (if set) are merged into every step
     if (step.uniqueFields && step.uniqueFields.length > 0) {
         if (!isBodyMethod) {
             ctx.addIssue({
-                code: z.ZodIssueCode.custom,
+                code: "custom",
                 path: ["uniqueFields"],
                 message: `uniqueFields is only valid on POST/PUT/PATCH steps (got ${step.method} ${step.path}). ` +
                     `Omit it for GET/DELETE steps.`,
@@ -142,7 +158,7 @@ Workspace-configured api.defaultQueryParams (if set) are merged into every step
         }
         else if (!step.requestBody) {
             ctx.addIssue({
-                code: z.ZodIssueCode.custom,
+                code: "custom",
                 path: ["uniqueFields"],
                 message: `uniqueFields is set for ${step.method} ${step.path} but there is no requestBody ` +
                     `containing those fields.`,
@@ -152,7 +168,7 @@ Workspace-configured api.defaultQueryParams (if set) are merged into every step
             for (const fieldPath of step.uniqueFields) {
                 if (!resolvesInJson(parsedBody, fieldPath)) {
                     ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
+                        code: "custom",
                         path: ["uniqueFields"],
                         message: `uniqueFields path "${fieldPath}" does not resolve in the requestBody of ` +
                             `${step.method} ${step.path}. The generator silently skips unresolvable paths, ` +
@@ -169,7 +185,7 @@ Workspace-configured api.defaultQueryParams (if set) are merged into every step
         !Array.isArray(parsedBody) &&
         Object.keys(parsedBody).length === 0) {
         ctx.addIssue({
-            code: z.ZodIssueCode.custom,
+            code: "custom",
             path: ["requestBody"],
             message: `requestBody for ${step.method} ${step.path} is an empty object {}. ` +
                 `Provide actual field values from the source code schema (Pydantic model, Zod type, DTO) — ` +
@@ -244,7 +260,7 @@ If a step fails, the error shows which step (N/total), method+path, and reason.
 
 ### After this tool
 Call \`skyramp_integration_test_generation\` with the returned \`scenarioFile\` path. Do NOT also pass \`apiSchema\` or \`endpointURL\` — the scenario file already contains all endpoint information and passing both will cause test generation to fail.`,
-        inputSchema: batchScenarioSchema,
+        inputSchema: z.object(batchScenarioSchema),
     }, async (params) => {
         const guardMessage = await guardScenarioApproved({
             scenarioName: params.scenarioName,
@@ -526,14 +542,16 @@ Call \`skyramp_integration_test_generation\` with the returned \`scenarioFile\`
             ? `\n\n⚠️ **Chaining warnings** — the generated test may hardcode these instead of chaining:\n` +
                 chainLint.warnings.map((w) => `  - ${w}`).join("\n")
             : "";
+        let writtenPath;
         try {
+            writtenPath = scenarioFilePath(params.outputDir, fileName);
             // The contract and integration generators create the test directory through
             // the SDK, so a batch scenario that is the FIRST call into a new directory
             // wrote into one that was not there and returned ENOENT. Same shape as
             // batchMockGenerationTool.ts, and inside the try so a mkdir failure reads
             // like a write failure.
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, JSON.stringify(traceRequests, null, 2), "utf8");
+            fs.mkdirSync(path.dirname(writtenPath), { recursive: true });
+            fs.writeFileSync(writtenPath, JSON.stringify(traceRequests, null, 2), "utf8");
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -555,8 +573,8 @@ Call \`skyramp_integration_test_generation\` with the returned \`scenarioFile\`
                     text: `**Batch Scenario Generated — ${stepCount} steps**\n\n` +
                         `**Scenario:** ${params.scenarioName}\n` +
                         `**Steps:**\n${steps.map((s, i) => `  ${i + 1}. ${s.method} ${s.path} → ${s.statusCode ?? "default"}`).join("\n")}\n\n` +
-                        `**File:** ${filePath}\n\n` +
-                        `**Next:** Call \`skyramp_integration_test_generation\` with \`scenarioFile: "${filePath}"\`` +
+                        `**File:** ${writtenPath}\n\n` +
+                        `**Next:** Call \`skyramp_integration_test_generation\` with \`scenarioFile: "${writtenPath}"\`` +
                         specValidationWarning +
                         chainLintWarning,
                 },

package/build/tools/generate-tests/generateContractRestTool.d.ts

@@ -1,7 +1,6 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, CallToolResult } from "@modelcontextprotocol/server";
 import { TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 type ContractParams = BaseTestParams & {
     enhanceAssertions?: boolean;
     assertOptions?: string;

package/build/tools/generate-tests/generateContractRestTool.js

@@ -439,7 +439,7 @@ ${CHAINING_SECTION}
 **Provider setup/teardown:**
 - \`skipProvisionParents\`: when true, skips generating setup/teardown functions for the provider contract test. Use this when \`apiSchema\` is unavailable and the endpoint requires a parent resource. Requires \`providerMode\`. Not allowed with \`parentRequestData\` or \`parentStatusCode\`.
 `,
-        inputSchema: contractTestSchema,
+        inputSchema: z.object(contractTestSchema),
     }, async (params) => {
         const guardMessage = await guardScenarioApproved({
             scenarioName: params.scenarioName || undefined,

package/build/tools/generate-tests/generateE2ERestTool.d.ts

@@ -1,7 +1,6 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, CallToolResult } from "@modelcontextprotocol/server";
 import { TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 export declare class E2ETestService extends TestGenerationService {
     protected getTestType(): TestType;
     protected buildGenerationOptions(params: BaseTestParams & {

package/build/tools/generate-tests/generateE2ERestTool.js

@@ -54,7 +54,7 @@ E2E tests require both trace files (capturing backend API interactions) and Play
 
 **CRITICAL - When using trace parameter:**
 If \`trace\` parameter is provided (path to a trace file), DO NOT pass \`apiSchema\` or \`endpointURL\` parameters. The trace file already contains all necessary endpoint and schema information. Passing both will cause test generation to fail.`,
-        inputSchema: e2eTestSchema,
+        inputSchema: z.object(e2eTestSchema),
         _meta: {
             keywords: ["e2e test", "end-to-end test"],
         },

package/build/tools/generate-tests/generateFuzzRestTool.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 import { TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
 export declare class FuzzTestService extends TestGenerationService {

package/build/tools/generate-tests/generateFuzzRestTool.js

@@ -28,7 +28,7 @@ export function registerFuzzTestTool(server) {
 Fuzz tests improve application security and reliability by sending invalid, malformed, or unexpected data to your API endpoints. They help discover edge cases, input validation issues, error handling problems, and potential security vulnerabilities.
 
 **IMPORTANT: If an apiSchema parameter (OpenAPI/Swagger file path or URL) is provided, DO NOT attempt to read or analyze the file contents. These files can be very large. Simply pass the path/URL to the tool - the backend will handle reading and processing the schema file.**`,
-        inputSchema: fuzzTestSchema,
+        inputSchema: z.object(fuzzTestSchema),
         _meta: {
             keywords: ["negative test", "random test"],
         },

package/build/tools/generate-tests/generateIntegrationRestTool.d.ts

@@ -1,7 +1,6 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, CallToolResult } from "@modelcontextprotocol/server";
 import { TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 export declare class IntegrationTestService extends TestGenerationService {
     protected getTestType(): TestType;
     generateTest(params: BaseTestParams & Record<string, any>): Promise<CallToolResult>;

package/build/tools/generate-tests/generateIntegrationRestTool.js

@@ -115,7 +115,7 @@ Generate an integration test from a scenario file or a live endpoint trace.
 **Output filename:** When \`scenarioFile\` is provided and user did not specify a name, derive it: strip path and 'scenario_' prefix, replace hyphens/non-alphanum with underscores, append '_integration_test' + language extension. Example: 'scenario_orders-patch.json' → 'orders_patch_integration_test.py'. Never use the default 'integration_test.py' when scenarioFile is set — it collides.
 
 **IMPORTANT:** If \`apiSchema\` is provided in direct mode, pass the path/URL as-is — do NOT read the file contents. The backend processes it.`,
-        inputSchema: integrationTestSchema,
+        inputSchema: z.object(integrationTestSchema),
     }, async (params) => {
         if (params.scenarioFile && (params.apiSchema || params.endpointURL)) {
             return {

package/build/tools/generate-tests/generateLoadRestTool.d.ts

@@ -1,7 +1,6 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, CallToolResult } from "@modelcontextprotocol/server";
 import { TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 export { loadTestSchema, numericString } from "./loadTestSchema.js";
 export declare class LoadTestService extends TestGenerationService {
     protected getTestType(): TestType;

package/build/tools/generate-tests/generateLoadRestTool.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { TestType } from "../../types/TestTypes.js";
 import { TestGenerationService, } from "../../services/TestGenerationService.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
@@ -41,7 +42,7 @@ Load tests evaluate your application's performance, scalability, and stability u
 
 **CRITICAL - When using trace parameter:**
 If \`trace\` parameter is provided (path to a trace file), DO NOT pass \`apiSchema\` or \`endpointURL\` parameters. The trace file already contains all necessary endpoint and schema information. Passing both will cause test generation to fail.`,
-        inputSchema: loadTestSchema,
+        inputSchema: z.object(loadTestSchema),
         _meta: {
             keywords: ["load test", "performance test"],
         },