@skyramp/mcp 0.2.8 → 0.2.150-rc.ldw-

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

@@ -357,8 +357,8 @@ const TOOL_NAME = "skyramp_contract_test_generation";
 const MODES_SECTION = CONSUMER_MODE_ENABLED
     ? `**Modes:**
 - Default (no mode set): both \`providerMode\` and \`consumerMode\` default to false. This generates both provider and consumer contract tests — equivalent to setting both modes to true.
-- \`providerMode\`: set to true ONLY if the user explicitly requests a provider-side contract test. Optionally specify \`providerOutput\` for the output file path.
-- \`consumerMode\`: set to true ONLY if the user explicitly requests a consumer-side contract test. Optionally specify \`consumerOutput\` for the output file path.
+- \`providerMode\`: set to true ONLY if the user explicitly requests a provider-side contract test. Optionally specify \`providerOutput\` for the output file path. Provider tests hit the real endpoint — no mocks.
+- \`consumerMode\`: set to true ONLY if the user explicitly requests a consumer-side contract test. Optionally specify \`consumerOutput\` for the output file path. Consumer tests include mocks wired inline (\`client.apply_mock(mock)\` in the test function) — no separate \`skyramp_enrich_test_with_mocks\` call needed.
 - Both \`providerMode\` and \`consumerMode\` can be enabled simultaneously to generate both sides.`
     : `**Mode:**
 - Only provider-side contract tests are generated. Pass \`providerMode: true\` (or omit it — the tool always behaves as provider-only). Optionally specify \`providerOutput\` for the output file path.`;

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

@@ -1,9 +1,17 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { TestType } from "../../types/TestTypes.js";
+import { MockProtocol } from "../../types/TestTypes.js";
+export { MockProtocol } from "../../types/TestTypes.js";
 import { TestGenerationService } from "../../services/TestGenerationService.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare const MOCK_PROTOCOL_EXAMPLES = "\n<example protocol=\"rest\">\nGenerate a REST mock for one HTTP endpoint. Required fields: protocol=\"rest\", endpointURL, method. Use apiSchema with an empty method only when intentionally generating all schema methods.\n{\n  \"protocol\": \"rest\",\n  \"endpointURL\": \"http://payment-service:5001/orders/:order_id/payment_authorizations\",\n  \"method\": \"PUT\",\n  \"requestAware\": true,\n  \"requestData\": \"{\"payment_method_id\":\"pm_123\"}\",\n  \"responseData\": \"{\"accepted\":true}\",\n  \"responseStatusCode\": \"200\"\n}\n</example>\n\n<example protocol=\"grpc\">\nGenerate a gRPC mock. Required fields: protocol=\"grpc\", endpointURL as host:port, protoPath, grpcServiceName. method is the RPC method name; omit or leave empty to generate all service methods. responseData must be a successful protobuf-shaped response, not a gRPC status error.\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}\n</example>\n\n<example protocol=\"kafka-producer\">\nGenerate a Kafka producer validation mock. Required fields: protocol=\"kafka\", endpointURL as broker host:port, kafkaTopic, and requestData. Do not pass method or responseData.\n{\n  \"protocol\": \"kafka\",\n  \"endpointURL\": \"broker:9092\",\n  \"kafkaTopic\": \"events\",\n  \"requestData\": \"{\"name\":\"order.created\"}\"\n}\n</example>\n\n<example protocol=\"kafka-consumer\">\nGenerate a Kafka consumer message mock. Required fields: protocol=\"kafka\", endpointURL as broker host:port, kafkaTopic, and responseData. Do not pass method or requestData.\n{\n  \"protocol\": \"kafka\",\n  \"endpointURL\": \"broker:9092\",\n  \"kafkaTopic\": \"events\",\n  \"responseData\": \"{\"accepted\":true}\"\n}\n</example>";
 type MockParams = {
+    protocol?: MockProtocol;
     endpointURL?: string;
+    protoPath?: string;
+    grpcServiceName?: string;
+    protobufExtraFiles?: string[];
+    protobufExtraImportPath?: string[];
+    kafkaTopic?: string;
     method?: string;
     apiSchema?: string;
     responseData?: string;
@@ -29,13 +37,18 @@ type MockParams = {
     prompt?: string;
 };
 export declare class MockGenerationService extends TestGenerationService {
-    protected getTestType(): TestType;
+    protected getTestType(): "mock";
     generateTest(params: MockParams & Record<string, any>): Promise<CallToolResult>;
     private buildReorganizationInstructions;
+    protected validateInputs(params: MockParams & Record<string, any>): CallToolResult;
     protected buildGenerationOptions(params: MockParams): {
-        uri: string | undefined;
         method: string | undefined;
-        apiSchema: string[];
+        url: string | undefined;
+        protoPath: string | undefined;
+        service: string | undefined;
+        extraFiles: string[];
+        extraImports: string[];
+        protocol: MockProtocol;
         language: string;
         framework: string;
         output: string | undefined;
@@ -48,17 +61,54 @@ export declare class MockGenerationService extends TestGenerationService {
         k8sNamespace: string | undefined;
         k8sConfig: string | undefined;
         k8sContext: string | undefined;
+        responseData: string | undefined;
+        entrypoint: string;
+    } | {
+        url: string | undefined;
+        topic: string | undefined;
         requestData: string | undefined;
+        protocol: MockProtocol;
+        language: string;
+        framework: string;
+        output: string | undefined;
+        outputDir: string;
+        force: boolean;
+        deployDashboard: boolean | undefined;
+        runtime: string | undefined;
+        dockerNetwork: string | undefined;
+        dockerWorkerPort: string;
+        k8sNamespace: string | undefined;
+        k8sConfig: string | undefined;
+        k8sContext: string | undefined;
         responseData: string | undefined;
+        entrypoint: string;
+    } | {
+        method: string;
+        uri: string | undefined;
+        apiSchema: string[];
+        requestData: string | undefined;
         responseStatusCode: string | undefined;
         formParams: string | undefined;
         requestAware: boolean | undefined;
         traceFilePath: string | undefined;
-        entrypoint: string;
         mockPort: number;
         optionalFields: boolean;
+        protocol: MockProtocol;
+        language: string;
+        framework: string;
+        output: string | undefined;
+        outputDir: string;
+        force: boolean;
+        deployDashboard: boolean | undefined;
+        runtime: string | undefined;
+        dockerNetwork: string | undefined;
+        dockerWorkerPort: string;
+        k8sNamespace: string | undefined;
+        k8sConfig: string | undefined;
+        k8sContext: string | undefined;
+        responseData: string | undefined;
+        entrypoint: string;
     };
     protected executeGeneration(generateOptions: any): Promise<string>;
 }
 export declare function registerMockTool(server: McpServer): void;
-export {};

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

@@ -1,18 +1,93 @@
 import { z } from "zod";
-import { baseSchema, HttpMethod, TestType } from "../../types/TestTypes.js";
+import { baseSchema, MockProtocol, MOCK_TYPE } from "../../types/TestTypes.js";
+export { MockProtocol } from "../../types/TestTypes.js";
 import { TestGenerationService } from "../../services/TestGenerationService.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { getEntryPoint } from "../../utils/telemetry.js";
+import { getRestMockMethodValidationError, normalizeRestMockMethod, } from "../../utils/httpMethodValidation.js";
+import { getGrpcMockResponseValidationError } from "../../utils/grpcMockValidation.js";
+import { isLocalDevEnabled } from "../../utils/featureFlags.js";
+export const MOCK_PROTOCOL_EXAMPLES = `
+<example protocol="rest">
+Generate a REST mock for one HTTP endpoint. Required fields: protocol="rest", endpointURL, method. Use apiSchema with an empty method only when intentionally generating all schema methods.
+{
+  "protocol": "rest",
+  "endpointURL": "http://payment-service:5001/orders/:order_id/payment_authorizations",
+  "method": "PUT",
+  "requestAware": true,
+  "requestData": "{\"payment_method_id\":\"pm_123\"}",
+  "responseData": "{\"accepted\":true}",
+  "responseStatusCode": "200"
+}
+</example>
+
+<example protocol="grpc">
+Generate a gRPC mock. Required fields: protocol="grpc", endpointURL as host:port, protoPath, grpcServiceName. method is the RPC method name; omit or leave empty to generate all service methods. responseData must be a successful protobuf-shaped response, not a gRPC status error.
+{
+  "protocol": "grpc",
+  "endpointURL": "profile-service:50051",
+  "protoPath": "/repo/proto/profiles.proto",
+  "grpcServiceName": "ProfileService",
+  "method": "GetProfile",
+  "responseData": "{\"eligible\":true}"
+}
+</example>
+
+<example protocol="kafka-producer">
+Generate a Kafka producer validation mock. Required fields: protocol="kafka", endpointURL as broker host:port, kafkaTopic, and requestData. Do not pass method or responseData.
+{
+  "protocol": "kafka",
+  "endpointURL": "broker:9092",
+  "kafkaTopic": "events",
+  "requestData": "{\"name\":\"order.created\"}"
+}
+</example>
+
+<example protocol="kafka-consumer">
+Generate a Kafka consumer message mock. Required fields: protocol="kafka", endpointURL as broker host:port, kafkaTopic, and responseData. Do not pass method or requestData.
+{
+  "protocol": "kafka",
+  "endpointURL": "broker:9092",
+  "kafkaTopic": "events",
+  "responseData": "{\"accepted\":true}"
+}
+</example>`;
 const mockSchema = {
+    protocol: z
+        .nativeEnum(MockProtocol)
+        .default(MockProtocol.Rest)
+        .describe("Protocol for the mock to generate. Use 'rest' for HTTP/OpenAPI mocks, 'grpc' for protobuf/gRPC mocks, and 'kafka' for Kafka topic mocks. See <example> blocks in the tool description for protocol-specific required fields."),
     endpointURL: z
         .string()
-        .describe("The base URL or endpoint URL to generate a mock for. " +
-        "If only a base URL is provided (e.g., https://api.example.com) and an apiSchema is given, mocks will be generated for ALL endpoints and methods in the schema — do NOT append paths to the URL. " +
-        "Only include a specific path (e.g., https://api.example.com/api/v1/products) if the user explicitly requests mocking a single endpoint."),
+        .describe("For REST: the base URL or endpoint URL to generate a mock for. " +
+        "For gRPC: the target service address as host:port (for example, profile-service:50051); do not include http://. " +
+        "For Kafka: the broker address as host:port (for example, broker:9092); do not include http://. " +
+        "If only a base URL is provided (e.g., https://api.example.com) and an apiSchema is given, REST mocks will be generated for ALL endpoints and methods in the schema — do NOT append paths to the URL. " +
+        "Only include a specific path (e.g., https://api.example.com/api/v1/products) if the user explicitly requests mocking a single REST endpoint."),
+    protoPath: z
+        .string()
+        .optional()
+        .describe("Required for protocol='grpc'. Absolute or repo-relative path to the .proto file that defines the gRPC service."),
+    grpcServiceName: z
+        .string()
+        .optional()
+        .describe("Required for protocol='grpc'. gRPC service name from the proto file, e.g. Greeter or ProfileService."),
+    protobufExtraFiles: z
+        .array(z.string())
+        .optional()
+        .describe("Optional extra .proto files needed to compile the primary proto for gRPC mocks."),
+    protobufExtraImportPath: z
+        .array(z.string())
+        .optional()
+        .describe("Optional extra import directories used when compiling protobuf files for gRPC mocks."),
+    kafkaTopic: z
+        .string()
+        .optional()
+        .describe("Required for protocol='kafka'. Kafka topic name to mock, e.g. order.created or orders."),
     method: z
-        .union([z.nativeEnum(HttpMethod), z.literal("")])
+        .string()
         .default("")
-        .describe('HTTP method to mock. DEFAULT: Use empty string ("") to mock ALL available methods from the OpenAPI schema. Only specify a specific method (GET, POST, PUT, DELETE, etc.) if the user explicitly requests mocking a single method.'),
+        .describe('For REST: HTTP method to mock; required unless apiSchema is provided for schema-wide generation. Empty string ("") with apiSchema mocks ALL available schema methods. For gRPC: RPC method name to mock; empty string generates all service methods. For Kafka: MUST be empty; use kafkaTopic for the topic name.'),
     apiSchema: z
         .string()
         .default("")
@@ -20,16 +95,18 @@ const mockSchema = {
     responseData: z
         .string()
         .optional()
-        .describe("Sample response body data to use in the mock, provided either as an inline JSON/YAML string or as an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
+        .describe("REST/gRPC: sample response body data to return. Kafka: consumer messages to inject. Provide inline JSON/YAML or an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
     responseStatusCode: z
         .string()
         .default("")
-        .refine((val) => !val || /^\d{3}$/.test(val), { message: "Must be a 3-digit HTTP status code (e.g., '200', '201') or empty string" })
+        .refine((val) => !val || /^\d{3}$/.test(val), {
+        message: "Must be a 3-digit HTTP status code (e.g., '200', '201') or empty string",
+    })
         .describe("HTTP status code the mock should return (e.g., '200', '201'). DO NOT ASSUME a status code if not provided."),
     requestData: z
         .string()
         .default("")
-        .describe("Sample request body data for request-aware mocks, provided either as an inline JSON/YAML string or as an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
+        .describe("REST: request body sample for request-aware matching. Kafka: producer validation payload/schema. Provide inline JSON/YAML or an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
     formParams: z
         .string()
         .default("")
@@ -42,17 +119,18 @@ const mockSchema = {
         .string()
         .optional()
         .describe("MUST be absolute path to a trace file (e.g., /path/to/trace.json) to generate the mock from captured traffic."),
-    ...(({ authHeader, insecure, ...rest }) => rest)(baseSchema.shape),
+    ...(({ authHeader: _authHeader, insecure: _insecure, ...rest }) => rest)(baseSchema.shape),
 };
 export class MockGenerationService extends TestGenerationService {
     getTestType() {
-        return TestType.MOCK;
+        return MOCK_TYPE;
     }
     async generateTest(params) {
         const result = await super.generateTest(params);
         if (result.isError)
             return result;
-        if (!params.apiSchema)
+        if (!params.apiSchema ||
+            (params.protocol ?? MockProtocol.Rest) !== MockProtocol.Rest)
             return result;
         return {
             ...result,
@@ -123,11 +201,68 @@ This file must:
 - Do NOT modify any mock logic, response data, or function signatures — only reorganize and add import/export wiring.
 `;
     }
-    buildGenerationOptions(params) {
+    validateInputs(params) {
+        const result = super.validateInputs(params);
+        const protocol = params.protocol ?? MockProtocol.Rest;
+        if (protocol === MockProtocol.Rest) {
+            const methodError = getRestMockMethodValidationError(params.method);
+            if (methodError) {
+                result.content.push({
+                    type: "text",
+                    text: `Error: ${methodError}.`,
+                });
+                result.isError = true;
+            }
+            if (!params.apiSchema && !params.method) {
+                result.content.push({
+                    type: "text",
+                    text: "Error: REST mock method is required unless apiSchema is provided for schema-wide generation.",
+                });
+                result.isError = true;
+            }
+            return result;
+        }
+        const missing = [];
+        if (protocol === MockProtocol.Grpc) {
+            if (!params.protoPath)
+                missing.push("protoPath is required for protocol='grpc'");
+            if (!params.grpcServiceName)
+                missing.push("grpcServiceName is required for protocol='grpc'");
+            const grpcResponseError = getGrpcMockResponseValidationError(params.responseData);
+            if (grpcResponseError)
+                missing.push(grpcResponseError);
+        }
+        if (protocol === MockProtocol.Kafka) {
+            if (!params.kafkaTopic) {
+                missing.push("kafkaTopic is required for protocol='kafka'");
+            }
+            if (params.method) {
+                missing.push("Kafka mock method must be empty; use kafkaTopic for the topic name. Produce validation uses requestData and consumer messages use responseData");
+            }
+            const hasRequestData = Boolean(params.requestData && params.requestData.trim());
+            const hasResponseData = Boolean(params.responseData && params.responseData.trim());
+            if (hasRequestData === hasResponseData) {
+                missing.push("Kafka mock requires exactly one of requestData (producer validation) or responseData (consumer messages)");
+            }
+        }
+        if (missing.length === 0) {
+            return result;
+        }
         return {
-            uri: params.endpointURL,
-            method: params.method,
-            apiSchema: params.apiSchema ? [params.apiSchema] : [],
+            content: [
+                ...result.content,
+                {
+                    type: "text",
+                    text: `Error: ${missing.join("; ")}.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    buildGenerationOptions(params) {
+        const protocol = params.protocol ?? MockProtocol.Rest;
+        const common = {
+            protocol,
             language: params.language ?? "python",
             framework: params.framework ??
                 (params.language === "typescript" || params.language === "javascript"
@@ -143,20 +278,51 @@ This file must:
             k8sNamespace: params.k8sNamespace,
             k8sConfig: params.k8sConfig,
             k8sContext: params.k8sContext,
-            requestData: params.requestData,
             responseData: params.responseData,
+            entrypoint: getEntryPoint(),
+        };
+        if (protocol === MockProtocol.Grpc) {
+            return {
+                ...common,
+                method: params.method,
+                url: params.endpointURL,
+                protoPath: params.protoPath,
+                service: params.grpcServiceName,
+                extraFiles: params.protobufExtraFiles ?? [],
+                extraImports: params.protobufExtraImportPath ?? [],
+            };
+        }
+        if (protocol === MockProtocol.Kafka) {
+            return {
+                ...common,
+                url: params.endpointURL,
+                topic: params.kafkaTopic,
+                requestData: params.requestData?.trim() ? params.requestData : undefined,
+            };
+        }
+        return {
+            ...common,
+            method: normalizeRestMockMethod(params.method),
+            uri: params.endpointURL,
+            apiSchema: params.apiSchema ? [params.apiSchema] : [],
+            requestData: params.requestData,
             responseStatusCode: params.responseStatusCode,
             formParams: params.formParams,
             requestAware: params.requestAware,
             traceFilePath: params.trace,
-            entrypoint: getEntryPoint(),
             mockPort: params.mockPort ?? 0,
             optionalFields: params.optionalFields ?? false,
         };
     }
     async executeGeneration(generateOptions) {
         try {
-            const result = await this.client.generateRestMock(generateOptions);
+            const protocol = generateOptions.protocol ?? MockProtocol.Rest;
+            const client = this.client;
+            const result = protocol === MockProtocol.Grpc
+                ? await client.generateGrpcMock(generateOptions)
+                : protocol === MockProtocol.Kafka
+                    ? await client.generateKafkaMock(generateOptions)
+                    : await client.generateRestMock(generateOptions);
             if (result && result.length > 0) {
                 const lowerResult = result.toLowerCase();
                 if (!lowerResult.includes("success")) {
@@ -177,12 +343,18 @@ ${result}`;
         }
     }
 }
+const LOCAL_DEV_GUARD = `
+**LOCAL-DEV GUARD:** If the user asked to run a local-dev workflow, test local changes, validate a feature branch, test against a base/prod/main branch, or mock downstream services for local testing, do NOT start with this tool. First call \`skyramp_one_click_tool\` with workflow \`local_dev_test_changes\`, \`callingAgent\` set to the current MCP client, \`repositoryPath\`, and \`baseBranch\`; that workflow installs skills, initializes the workspace, analyzes the diff, and then calls mock generation at the correct phase.
+`;
+function getLocalDevGuard() {
+    return isLocalDevEnabled() ? LOCAL_DEV_GUARD : "";
+}
 const TOOL_NAME = "skyramp_mock_generation";
 export function registerMockTool(server) {
     server.registerTool(TOOL_NAME, {
-        description: `Generate a mock server implementation using Skyramp's deterministic mock generation platform.
+        description: `${getLocalDevGuard()}Generate a mock server implementation using Skyramp's deterministic mock generation platform.
 
-Mocks simulate API endpoints so that consumers can develop and test against them without requiring a live backend. They are useful for parallel development, isolating dependencies, and simulating edge-case responses.
+Mocks simulate REST, gRPC, or Kafka dependencies so that consumers can develop and test against them without requiring a live backend. They are useful for parallel development, isolating dependencies, and simulating edge-case responses.
 
 **IMPORTANT: If an apiSchema parameter (OpenAPI/Swagger file path or URL) is provided, DO NOT attempt to read or analyze the file contents. Simply pass the path/URL to the tool — the backend will handle reading and processing the schema file.**
 

package/build/tools/generateEnrichedIntegrationTestTool.d.ts

@@ -0,0 +1,24 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * skyramp_generate_enriched_integration_test
+ *
+ * Combines integration test generation (from a scenario file) and mock enrichment
+ * into a single atomic operation. Eliminates the need to call
+ * skyramp_integration_test_generation and skyramp_enrich_test_with_mocks separately.
+ */
+export declare function registerGenerateEnrichedIntegrationTestTool(server: McpServer): void;
+export declare function executeGenerateEnrichedIntegrationTest(params: {
+    scenarioFile: string;
+    mockFiles: string[];
+    scenarioName: string;
+    outputDir: string;
+    output?: string;
+    runtime?: string;
+    dockerNetwork?: string;
+    authHeader?: string;
+    authScheme?: string;
+    language?: string;
+    framework?: string;
+    traceComments?: string[];
+}): Promise<CallToolResult>;

package/build/tools/generateEnrichedIntegrationTestTool.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { SkyrampClient } from "@skyramp/skyramp";
+import { logger } from "../utils/logger.js";
+import { injectMockImports } from "./enrichTestWithMocksTool.js";
+import { isAuthorizationHeaderName } from "../utils/workspaceAuth.js";
+import * as fs from "fs";
+import * as path from "path";
+const TOOL_NAME = "skyramp_generate_enriched_integration_test";
+const enrichedIntegrationTestSchema = {
+    scenarioFile: z
+        .string()
+        .describe("Absolute path to the scenario JSON file (from skyramp_batch_scenario_test_generation). Used as trace input for integration test generation."),
+    mockFiles: z
+        .array(z.string())
+        .describe("Absolute paths to the generated mock files (from skyramp_mock_generation or skyramp_batch_mock_generation) that this test needs."),
+    scenarioName: z
+        .string()
+        .describe("Human-readable scenario name (e.g., order-happy-path). Used as the SCENARIO_NAME constant in the enriched test."),
+    outputDir: z
+        .string()
+        .describe("Absolute path to the directory where the test file will be written."),
+    output: z
+        .string()
+        .optional()
+        .describe("Output test file name (e.g., order_happy_path_integration_test.py). Derived from scenario if omitted."),
+    runtime: z
+        .string()
+        .optional()
+        .default("docker")
+        .describe("Runtime environment: 'docker' or 'k8s'. Defaults to docker."),
+    dockerNetwork: z
+        .string()
+        .optional()
+        .describe("Docker network name for the test runtime."),
+    authHeader: z
+        .string()
+        .optional()
+        .describe("HTTP header that carries the auth credential (e.g., Authorization, X-Api-Key)."),
+    authScheme: z
+        .string()
+        .optional()
+        .describe("Auth scheme prefix (e.g., Bearer). Mapped to authType for the backend."),
+    language: z
+        .string()
+        .optional()
+        .describe("Programming language for the generated test (e.g., python, typescript)."),
+    framework: z
+        .string()
+        .optional()
+        .describe("Test framework (e.g., pytest, playwright)."),
+    traceComments: z
+        .array(z.string())
+        .optional()
+        .describe("Optional trace comments showing how mock values flow to assertions."),
+};
+/**
+ * skyramp_generate_enriched_integration_test
+ *
+ * Combines integration test generation (from a scenario file) and mock enrichment
+ * into a single atomic operation. Eliminates the need to call
+ * skyramp_integration_test_generation and skyramp_enrich_test_with_mocks separately.
+ */
+export function registerGenerateEnrichedIntegrationTestTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: "Generate an integration test from a scenario file AND enrich it with mock imports in one step. " +
+            "Combines skyramp_integration_test_generation + skyramp_enrich_test_with_mocks into a single call. " +
+            "Use this after skyramp_batch_scenario_test_generation and skyramp_batch_mock_generation to " +
+            "produce a fully wired test file ready for execution.",
+        inputSchema: enrichedIntegrationTestSchema,
+    }, async (params) => {
+        return executeGenerateEnrichedIntegrationTest(params);
+    });
+}
+export async function executeGenerateEnrichedIntegrationTest(params) {
+    const { scenarioFile, mockFiles, scenarioName, outputDir, output, runtime, dockerNetwork, authHeader, authScheme, language, framework, traceComments, } = params;
+    try {
+        // Step 1: Validate language — enrichment currently supports Python only
+        if (language && language !== "python") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Mock enrichment is currently supported only for Python tests; received language "${language}". Use \`skyramp_integration_test_generation\` followed by \`skyramp_enrich_test_with_mocks\` for non-Python languages.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 1b: Validate scenarioFile exists
+        if (!fs.existsSync(scenarioFile)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Scenario file not found: ${scenarioFile}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 1b: Validate mock files exist
+        const missingFiles = mockFiles.filter((f) => !fs.existsSync(f));
+        if (missingFiles.length > 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Mock files not found:\n` +
+                            missingFiles.map((f) => `  - ${f}`).join("\n") +
+                            `\n\nGenerate them first with \`skyramp_batch_mock_generation\`.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 2: Generate the integration test
+        // Normalize auth params: the Go CLI treats --auth-type and --auth-header as
+        // mutually exclusive when authHeader is the standard Authorization header.
+        // Mirror TestGenerationService.executeGeneration() normalization:
+        // if authScheme is set and authHeader is Authorization, use authType only.
+        let resolvedAuthHeader = authHeader;
+        const resolvedAuthType = authScheme;
+        if (resolvedAuthType !== undefined && isAuthorizationHeaderName(resolvedAuthHeader || "")) {
+            resolvedAuthHeader = undefined;
+        }
+        const client = new SkyrampClient();
+        const result = await client.generateRestTest({
+            traceFilePath: scenarioFile,
+            outputDir,
+            output,
+            runtime,
+            force: true,
+            dockerNetwork,
+            authHeader: resolvedAuthHeader,
+            authType: resolvedAuthType,
+            language,
+            framework,
+            testType: "integration",
+        });
+        // Check if generation succeeded
+        if (!result || !result.toLowerCase().includes("success")) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Integration test generation failed: ${result || "no output from backend"}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 3: Determine the test file path and read it
+        const testFileName = output || deriveTestFileName(scenarioFile, language);
+        const testFilePath = path.join(outputDir, testFileName);
+        if (!fs.existsSync(testFilePath)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Generated test file not found at expected path: ${testFilePath}\n` +
+                            `Backend output: ${result}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const testContent = fs.readFileSync(testFilePath, "utf-8");
+        // Step 4: Enrich with mock imports
+        const enrichedContent = injectMockImports(testContent, testFilePath, scenarioName, mockFiles, traceComments);
+        // Step 5: Write the enriched content back
+        fs.writeFileSync(testFilePath, enrichedContent);
+        logger.info(`Generated and enriched integration test: ${testFilePath}`, {
+            scenarioName,
+            mockFileCount: mockFiles.length,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `**Integration test generated and enriched with mocks for scenario "${scenarioName}".**\n`,
+                        `**Test file:** ${testFilePath}`,
+                        `**Mock files imported:** ${mockFiles.length}`,
+                        ...mockFiles.map((f) => `  - ${path.basename(f)}`),
+                        `\nThe test is ready for execution with: \`skyramp_execute_test({testFile: "${testFilePath}", ...})\``,
+                    ].join("\n"),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        logger.error(`Failed to generate enriched integration test: ${error.message}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**Failed to generate enriched integration test:** ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+function deriveTestFileName(scenarioFile, language) {
+    const base = path.basename(scenarioFile, ".json");
+    const name = base.replace(/^scenario_/, "").replace(/[^a-zA-Z0-9]/g, "_");
+    const ext = language === "typescript" || language === "javascript" ? ".spec.ts" : ".py";
+    return `${name}_integration_test${ext}`;
+}

package/build/tools/localDevWorkflowFixes.test.d.ts

@@ -0,0 +1 @@
+export {};