@skyramp/mcp 0.0.4 → 0.0.5

package/build/prompts/startTraceCollectionPrompts.js

@@ -1,9 +1,6 @@
 // src/prompts/skyrampPrompt.ts
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
-// read env variable and use it to set custom prompt
-const isDockerEnv = process.env.MCP_SERVER_RUNTIME === "docker";
-logger.info("MCP server runtime environment", { isDockerEnv });
 export function registerStartTraceCollectionPrompt(mcpServer) {
     logger.info("registering start trace collection prompt");
     mcpServer.prompt("skyramp_trace_prompt", "Skyramp trace collection prompt", {

package/build/prompts/testGenerationPrompt.js

@@ -1,8 +1,5 @@
 // src/prompts/skyrampPrompt.ts
 import { logger } from "../utils/logger.js";
-// read env variable and use it to set custom prompt
-const isDockerEnv = process.env.MCP_SERVER_RUNTIME === "docker";
-logger.info("MCP server runtime environment", { isDockerEnv });
 export function registerTestGenerationPrompt(mcpServer) {
     logger.info("test generation prompt");
     mcpServer.prompt("skyramp_test_generation_prompt", "Skyramp test generation prompt", {}, () => ({

package/build/services/TestGenerationService.js

@@ -1,6 +1,8 @@
 import { SkyrampClient } from "@skyramp/skyramp";
 import { analyzeOpenAPIWithGivenEndpoint } from "../utils/analyze-openapi.js";
 import { getPathParameterValidationError, OUTPUT_DIR_FIELD_NAME, PATH_PARAMS_FIELD_NAME, QUERY_PARAMS_FIELD_NAME, FORM_PARAMS_FIELD_NAME, validateParams, validatePath, validateRequestData, TELEMETRY_entrypoint_FIELD_NAME, } from "../utils/utils.js";
+import { getLanguageSteps } from "../utils/language-helper.js";
+import { getModularizationPrompt } from "../utils/modularization-prompts.js";
 export class TestGenerationService {
     client;
     constructor() {
@@ -13,100 +15,21 @@ export class TestGenerationService {
                 return validationResult;
             }
             const generateOptions = this.buildGenerationOptions(params);
-            const apiAnalysisResult = await this.handleApiAnalysis(params, generateOptions);
-            if (apiAnalysisResult) {
-                return apiAnalysisResult;
-            }
+            // TODO- understand and make the logic better
+            // const apiAnalysisResult = await this.handleApiAnalysis(
+            //   params,
+            //   generateOptions
+            // );
+            // if (apiAnalysisResult) {
+            //   return apiAnalysisResult;
+            // }
             const result = await this.executeGeneration(generateOptions);
-            let modularizedResultPrompt = `
-**IMPORTANT: Now please modularize the code by**
-
-1. Group related lines logically (e.g., login steps together) to improve readability.
-2. Parameterize the test function(s) with meaningful parameters to make it more flexible. Preserve the original order of code lines within each function
-3. Do not change or remove any existing lines of code, variable names, function names, or function structures.
-4. Only extract reusable logical sections into helper functions or parameterized structures where applicable.
-5. Do not create any new test cases but only helper functions.
-6. Make sure the logic is same and the test works as expected.
-7. Do not add any new logic or classes or any other files.
-
-Please refactor the code with these modularization principles.
-      `;
-            let languageSteps = "";
-            switch (params.language) {
-                case "python":
-                    // python steps
-                    languageSteps += `
-# Install skyramp dependency
-pip3 install skyramp
-        `;
-                    // e2e and ui tests
-                    if (params.testType == "e2e" || params.testType == "ui") {
-                        languageSteps += `
-# Install playwright dependencies
-pip3 install pytest-playwright
-# Execute the test file
-python3 -m pytest --browser chromium <test-file>.py
-            `;
-                    }
-                    //framework pytest
-                    languageSteps += `
-# Install pytest dependency
-pip3 install pytest
-
-# Execution test file
-python3 -m pytest <test-file>.py
-          `;
-                    // robot framework
-                    languageSteps += `
-# Install robotframework dependency
-pip3 install robotframework
-
-# Execution of test file
-python3 -m robot <robot-file>.robot
-        `;
-                    break;
-                case "javascript":
-                    languageSteps += `
-# install dependencies for package.json
-npm install @skyramp/skyramp @playwright/test
-
-# Execution of test file
-npx playwright test <test-file>.spec.js --reporter=list
-          `;
-                    break;
-                case "typescript":
-                    languageSteps += `
-# install dependencies for package.json
-npm install @skyramp/skyramp @playwright/test
-
-# Execution of test file
-npx playwright test <test-file>.spec.ts --reporter=list
-          `;
-                    break;
-                case "java":
-                    languageSteps += `
-# Prerequisites
-# Compile the test file
-javac -cp "./lib/*" -d target <test-file>.java
-
-# Execution of test file
-JUNIT_PLATFORM_VER="1.9.3"
-classpath="target:$(echo ./lib/*.jar | tr ' ' ':')"
-java -jar "./lib/junit-platform-console-standalone-\${JUNIT_PLATFORM_VER}.jar" \\
-  --classpath "\$classpath" \\
-  --include-engine=junit-jupiter \\
-  --select-class=<test-file> \\
-  --reports-dir=target/test-results
-          `;
-                    break;
-            }
-            let isError = false;
-            // check the result include 'Successfully generated/updated tests files:'
-            if (!result.includes("Successfully generated/updated tests files:")) {
-                isError = true;
-            }
             const testType = this.getTestType();
-            const shouldModularize = testType == "ui" || testType == "e2e";
+            const shouldModularize = testType == "ui" || testType == "e2e" || testType == "integration";
+            const languageSteps = getLanguageSteps({
+                language: params.language || "",
+                testType: params.testType,
+            });
             return {
                 content: [
                     {
@@ -114,7 +37,7 @@ java -jar "./lib/junit-platform-console-standalone-\${JUNIT_PLATFORM_VER}.jar" \
                         text: `${shouldModularize
                             ? "Generated the test and WILL NOW MODULARIZE THE CODE USING THE FOLLOWING MODULARIZATION PRINCIPLES"
                             : "Generated the test and DO NOT MODULARIZE THE CODE"}
-            ${result} ${shouldModularize ? modularizedResultPrompt : ""}
+            ${result} ${shouldModularize ? getModularizationPrompt() : ""}
         ${languageSteps}
 
         - Notify the user that they can also use **Execute with Skyramp** tool to run the test. If this is your first test you are trying to execute with Skyramp, it may take a little bit longer than usual.
@@ -122,11 +45,20 @@ java -jar "./lib/junit-platform-console-standalone-\${JUNIT_PLATFORM_VER}.jar" \
           Authentication: Please provide me with your authentication token (by default we assume a Bearer Token). If you don't require any token for your service please just say: 'No token required'`,
                     },
                 ],
-                isError: isError,
+                isError: false,
             };
         }
         catch (error) {
-            return this.handleError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: errorMessage,
+                    },
+                ],
+                isError: true,
+            };
         }
     }
     validateInputs(params) {
@@ -154,7 +86,7 @@ java -jar "./lib/junit-platform-console-standalone-\${JUNIT_PLATFORM_VER}.jar" \
             : errList;
     }
     async handleApiAnalysis(params, generateOptions) {
-        if (params.apiSchema && params.endpointURL) {
+        if (params.apiSchema && params.endpointURL && params.method != "") {
             try {
                 const requiredPathParams = await analyzeOpenAPIWithGivenEndpoint(params.apiSchema, params.endpointURL, params.pathParams ?? "");
                 if (requiredPathParams && requiredPathParams.trim().length > 0) {
@@ -170,33 +102,43 @@ java -jar "./lib/junit-platform-console-standalone-\${JUNIT_PLATFORM_VER}.jar" \
                 }
             }
             catch (error) {
-                return this.handleError(error);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error analyzing OpenAPI schema: ${errorMessage}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         }
         return null;
     }
     async executeGeneration(generateOptions) {
-        const result = await this.client.generateRestTest(generateOptions);
-        return `Test generation completed successfully!
-
-**Generated Test Details:**
+        try {
+            const result = await this.client.generateRestTest(generateOptions);
+            // Check if the result indicates failure
+            if (result && result.length > 0) {
+                const lowerResult = result.toLowerCase();
+                if (!lowerResult.includes("success")) {
+                    throw new Error(`Test generation failed: ${result}`);
+                }
+            }
+            return `**Generated Test Details:**
 - Test Type: ${this.getTestType()}
 - Output Directory: ${generateOptions.outputDir}
 - Language: ${generateOptions.language}
 - Framework: ${generateOptions.framework}
 
-${result}`;
-    }
-    handleError(error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error generating ${this.getTestType()} test: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
+${result}
+`;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to execute test generation: ${errorMessage}`);
+        }
     }
     buildBaseGenerationOptions(params) {
         return {

package/build/tools/executeSkyrampTestTool.js

@@ -12,11 +12,31 @@ const LANGUAGE_PATHS = {
 };
 export function registerExecuteSkyrampTestTool(server) {
     server.registerTool("skyramp_execute_test", {
-        description: `Execute a Skyramp test to validate your application using isolated containerized environments.
-      IMPORTANT: Follow the instructions below to execute the test.
-      - Notify the user that the first time the tool is used, it will take some time to pull the image.
-      - Before I can execute the test for you, I need to confirm the following information:
-      Authentication: Please provide me with your authentication token (by default we assume a Bearer Token). If you don't require any token for your service please just say: 'No token required'`,
+        description: `Execute a Skyramp-generated test in isolated containerized environments for reliable, deterministic testing.
+
+Skyramp is a comprehensive testing platform that generates reliable, out-of-the-box functional and performance tests with AI-powered scaffolding. The test execution engine runs your generated tests in controlled, isolated environments to ensure consistent results.
+
+KEY FEATURES:
+• Isolated Execution: Tests run in containerized environments for consistency
+• Multi-Language Support: Execute tests written in Python, Java, JavaScript, or TypeScript
+• Out-of-the-Box Execution: Generated tests work immediately without modification
+
+REQUIRED PARAMETERS:
+- language: Programming language of your test file (python, javascript, typescript, java)
+- testType: Type of test to execute (smoke, contract, fuzz, integration, load, ui, e2e)
+- testFile: Absolute path to the generated test file to execute
+- token: Authentication token for your service (use empty string if no authentication required)
+
+AUTHENTICATION:
+Provide your authentication token (typically a Bearer token) for services that require authentication. Use an empty string for services that don't require authentication.
+
+IMPORTANT NOTES:
+- First-time usage may take longer as Docker images are downloaded
+- Tests run in isolated containers for maximum reliability
+- Generated tests are designed to work out-of-the-box without modification
+- Results include detailed execution logs and test outcomes
+
+For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
         inputSchema: {
             language: z
                 .string()

package/build/tools/generateContractRestTool.js

@@ -25,7 +25,12 @@ export class ContractTestService extends TestGenerationService {
 }
 export function registerContractTestTool(server) {
     server.registerTool("skyramp_contract_test_generation", {
-        description: "Generate a contract test",
+        description: `Generate a contract test using Skyramp's deterministic test generation platform.
+
+Contract tests ensure your API implementation matches its OpenAPI/Swagger specification exactly. They validate request/response schemas, status codes, headers, and data types to prevent contract violations and API breaking changes.
+
+If the user says  create tests for all methods in an endpoint then use "" as method value and skyramp will create all test in one file
+For detailed documentation visit: https://www.skyramp.dev/docs/contract-test`,
         inputSchema: contractTestSchema,
     }, async (params) => {
         const service = new ContractTestService();

package/build/tools/generateE2ERestTool.js

@@ -22,7 +22,14 @@ export class E2ETestService extends TestGenerationService {
 }
 export function registerEndtoEndTestTool(server) {
     server.registerTool("skyramp_e2e_test_generation", {
-        description: "Generate an E2E test",
+        description: `Generate an End-to-End (E2E) test using Skyramp's deterministic test generation platform.
+
+End-to-End tests validate complete user journeys by testing the entire application flow from frontend UI interactions to backend API responses. They ensure that all components work together correctly in realistic user scenarios, providing the highest confidence in application functionality.
+
+TRACE & UI INTEGRATION:
+E2E tests require both trace files (capturing backend API interactions) and Playwright recordings (capturing UI interactions) to generate comprehensive tests that validate the complete user experience.
+
+For detailed documentation visit: https://www.skyramp.dev/docs/e2e-test`,
         inputSchema: e2eTestSchema,
         annotations: {
             keywords: ["e2e test", "end-to-end test"],

package/build/tools/generateFuzzRestTool.js

@@ -20,7 +20,12 @@ export class FuzzTestService extends TestGenerationService {
 }
 export function registerFuzzTestTool(server) {
     server.registerTool("skyramp_fuzz_test_generation", {
-        description: "Generate a fuzz test",
+        description: `Generate a fuzz test using Skyramp's deterministic test generation platform.
+
+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.
+
+If the user says  create tests for all methods in an endpoint then use "" as method value and skyramp will create all test in one file
+For detailed documentation visit: https://www.skyramp.dev/docs/fuzz-test`,
         inputSchema: fuzzTestSchema,
         annotations: {
             keywords: ["negative test", "random test"],

package/build/tools/generateIntegrationRestTool.js

@@ -20,7 +20,12 @@ export class IntegrationTestService extends TestGenerationService {
 }
 export function registerIntegrationTestTool(server) {
     server.registerTool("skyramp_integration_test_generation", {
-        description: "Generate an integration test",
+        description: `Generate an integration test using Skyramp's deterministic test generation platform.
+
+Integration tests validate that multiple services, components, or modules work together correctly. They test complex user workflows, service interactions, data flow between systems, and ensure that integrated components function as expected in realistic scenarios.
+
+If the user says  create tests for all methods in an endpoint then use "" as method value and skyramp will create all test in one file
+For detailed documentation visit: https://www.skyramp.dev/docs/integration-test`,
         inputSchema: integrationTestSchema,
     }, async (params) => {
         const service = new IntegrationTestService();

package/build/tools/generateLoadRestTool.js

@@ -5,31 +5,32 @@ const loadTestSchema = {
     ...baseTestSchema,
     loadCount: z
         .string()
-        .optional()
-        .describe("Total number of requests to send during the load test"),
+        .default("")
+        .describe("Total string of iteration to be excuted for the test. DO NOT ASSUME VALUE"),
     loadDuration: z
         .string()
-        .optional()
+        .default("5")
         .describe("Duration of the load test in seconds (default: 5)"),
     loadNumThreads: z
         .string()
-        .optional()
+        .default("1")
         .describe("Number of concurrent threads/users for the load test (default: 1)"),
     loadRampupDuration: z
         .string()
-        .optional()
-        .describe("Time in seconds to gradually increase load to target level"),
+        .default("")
+        .describe("Time in seconds to gradually increase load to target level. DO NOT ASSUME VALUE"),
     loadRampupInterval: z
         .string()
-        .optional()
-        .describe("Interval in seconds between ramping up threads"),
+        .default("")
+        .describe("Interval in seconds between ramping up threads. DO NOT ASSUME VALUE"),
     loadTargetRPS: z
         .string()
-        .optional()
-        .describe("Target requests per second for the load test"),
-    trace: baseTraceSchema.shape.trace.optional(),
-    include: baseTraceSchema.shape.include.optional(),
-    exclude: baseTraceSchema.shape.exclude.optional(),
+        .default("")
+        .describe("Target requests per second for the load test. DO NOT ASSUME VALUE"),
+    trace: baseTraceSchema.shape.trace.default(""),
+    include: baseTraceSchema.shape.include,
+    exclude: baseTraceSchema.shape.exclude,
+    endpointURL: baseTestSchema.endpointURL.default(""),
 };
 export class LoadTestService extends TestGenerationService {
     getTestType() {
@@ -49,7 +50,15 @@ export class LoadTestService extends TestGenerationService {
 }
 export function registerLoadTestTool(server) {
     server.registerTool("skyramp_load_test_generation", {
-        description: "Generate a load test",
+        description: `Generate a load test using Skyramp's deterministic test generation platform.
+
+Load tests evaluate your application's performance, scalability, and stability under various traffic conditions. They simulate multiple concurrent users, measure response times, identify performance bottlenecks, and ensure your system can handle expected traffic volumes.
+
+***IMPORTANT**
+-At any given time you can provide duration of the test or test execution count
+-If the user says  create tests for all methods in an endpoint then use "" as method value and skyramp will create all test in one file
+
+For detailed documentation visit: https://www.skyramp.dev/docs/load-test`,
         inputSchema: loadTestSchema,
         annotations: {
             keywords: ["load test", "performance test"],

package/build/tools/generateSmokeRestTool.js

@@ -1,5 +1,6 @@
 import { baseTestSchema } from "../types/TestTypes.js";
 import { TestGenerationService, } from "../services/TestGenerationService.js";
+import z from "zod";
 // Concrete implementations for each test type
 export class SmokeTestService extends TestGenerationService {
     getTestType() {
@@ -9,10 +10,25 @@ export class SmokeTestService extends TestGenerationService {
         return super.buildBaseGenerationOptions(params);
     }
 }
+const smokeTestSchema = {
+    ...baseTestSchema,
+    endpointURL: z
+        .string()
+        .describe(baseTestSchema.endpointURL.description || "The endpoint URL to test"),
+    apiSchema: z
+        .string()
+        .describe(baseTestSchema.apiSchema.description || "The OpenAPI schema to test"),
+};
 export function registerSmokeTestTool(server) {
     server.registerTool("skyramp_smoke_test_generation", {
-        description: "Generate a smoke test",
-        inputSchema: baseTestSchema,
+        description: `Generate a smoke test using Skyramp's deterministic test generation platform.
+
+Smoke testing is a preliminary check used to verify that an endpoint is accessible and returns a valid response. Smoke tests are useful for quickly identifying critical defects after significant changes. They provide rapid validation for basic functionality verification and endpoint accessibility testing.
+
+If the user says  create tests for all methods in an endpoint then use "" as method value and skyramp will create all test in one file
+
+For detailed documentation visit: https://www.skyramp.dev/docs/smoke-test`,
+        inputSchema: smokeTestSchema,
         annotations: {
             keywords: ["smoke test", "quick test"],
         },

package/build/tools/generateUIRestTool.js

@@ -25,7 +25,11 @@ const uiTestSchema = {
 };
 export function registerUITestTool(server) {
     server.registerTool("skyramp_ui_test_generation", {
-        description: "Generate an UI test",
+        description: `Generate a UI test using Skyramp's deterministic test generation platform.
+      
+UI tests validate user interface functionality by simulating real user interactions with your web application. They test user workflows, form submissions, navigation, responsive design, and ensure that your frontend works correctly across different browsers and devices. UI tests use Playwright recordings as input to generate comprehensive test suites that replay user interactions, validate UI elements, and verify expected behaviors in browser environments.
+
+For detailed documentation visit: https://www.skyramp.dev/docs/ui-test`,
         inputSchema: uiTestSchema,
         annotations: {
             keywords: ["ui test", "playwright"],

package/build/tools/loginTool.js

@@ -2,7 +2,11 @@ import { SkyrampClient } from "@skyramp/skyramp";
 import { logger } from "../utils/logger.js";
 export function registerLoginTool(server) {
     server.registerTool("skyramp_login", {
-        description: "Login to Skyramp platform",
+        description: `Login to Skyramp platform 
+
+Logging into Skyramp provides access to additional platform features and services.
+
+`,
         inputSchema: {},
         annotations: {
             keywords: ["login", "authenticate", "skyramp login"],

package/build/tools/logoutTool.js

@@ -2,7 +2,10 @@ import { SkyrampClient } from "@skyramp/skyramp";
 import { logger } from "../utils/logger.js";
 export function registerLogoutTool(server) {
     server.registerTool("skyramp_logout", {
-        description: "Logout from Skyramp platform",
+        description: `Logout from Skyramp platform
+
+Logout from Skyramp platform to end your authenticated session.
+      `,
         inputSchema: {},
         annotations: {
             keywords: ["logout", "sign out", "skyramp logout"],

package/build/tools/startTraceCollectionTool.js

@@ -4,7 +4,37 @@ import openProxyTerminalTracked from "../utils/proxy-terminal.js";
 import { TELEMETRY_entrypoint_FIELD_NAME } from "../utils/utils.js";
 export function registerTraceTool(server) {
     server.registerTool("skyramp_start_trace_generation", {
-        description: "Start trace collection",
+        description: `Start trace collection using Skyramp's comprehensive tracing capabilities.
+
+Trace collection monitors your application in real-time to capture user interactions, API calls, service communications, and data flows. This captured data is then used to generate comprehensive integration, load, and E2E tests that reflect real-world usage patterns.
+
+COLLECTION TYPES:
+• UI-Only Tracing: Captures frontend user interactions for UI test generation
+• Backend-Only Tracing: Records API calls and service communications for integration tests
+• Full-Stack Tracing: Combines UI and backend tracing for comprehensive E2E test generation
+
+REQUIRED PARAMETERS:
+None - All parameters are optional with sensible defaults
+
+OPTIONAL PARAMETERS:
+- playwright: Enable Playwright for UI interaction tracing (default: true)
+- runtime: Execution environment (docker, kubernetes, local) - Defaults to docker
+- include: List of service names or patterns to include in trace collection
+- exclude: List of service names or patterns to exclude from trace collection
+- noProxy: List of hosts or patterns that should bypass proxy during tracing
+- dockerNetwork: Docker network name for containerized trace collection
+- dockerWorkerPort: Port number for the Docker worker service (default: 35142)
+
+RUNTIME ENVIRONMENTS:
+• Docker: Containerized tracing with automatic service discovery
+
+WORKFLOW:
+1. Start trace collection with desired configuration
+2. Interact with your application (UI clicks, API calls, workflows)
+3. Stop trace collection to save captured data
+4. Use traces to generate realistic test scenarios
+
+For detailed documentation visit:https://www.skyramp.dev/docs/load-test/advanced-generation#start-trace-collection`,
         inputSchema: {
             playwright: z
                 .boolean()
@@ -20,11 +50,11 @@ export function registerTraceTool(server) {
                 .describe("List of service names or patterns to include in trace collection"),
             exclude: z
                 .array(z.string())
-                .optional()
+                .default([])
                 .describe("List of service names or patterns to exclude from trace collection"),
             noProxy: z
                 .array(z.string())
-                .optional()
+                .default([])
                 .describe("List of hosts or patterns that should bypass proxy during tracing"),
             dockerNetwork: z
                 .string()

package/build/tools/stopTraceCollectionTool.js

@@ -5,7 +5,33 @@ import { PLAYWRIGHT_OUTPUT_FILE_FIELD_NAME, TELEMETRY_entrypoint_FIELD_NAME, TRA
 import { logger } from "../utils/logger.js";
 export function registerTraceStopTool(server) {
     server.registerTool("skyramp_stop_trace_generation", {
-        description: "Stop trace collection",
+        description: `Stop trace collection and save captured data using Skyramp's comprehensive tracing capabilities.
+
+Stopping trace collection finalizes the monitoring process and exports all captured data to specified files. This includes API calls, service communications, user interactions, and network traffic that occurred during the collection period.
+
+REQUIRED PARAMETERS:
+- traceOutputFile: Absolute path to save trace data (JSON format) - This file contains collected application interactions for test generation
+- playwright: Boolean flag indicating whether Playwright was used during collection (must match start configuration)
+- playwrightOutput: Absolute path to save Playwright data (ZIP format) - Required when playwright is true, contains UI interaction recordings
+
+OUTPUT FILES:
+• Trace File (JSON): Contains backend API calls, service communications, and network traffic data
+• Playwright File (ZIP): Contains UI interaction recordings and browser automation data (when enabled)
+
+USAGE WORKFLOW:
+1. Ensure this matches the configuration used when starting trace collection
+2. Provide absolute paths for output files
+3. Generated files can be used immediately for test generation
+4. Trace data reflects real application usage patterns
+
+INTEGRATION WITH TEST GENERATION:
+The generated trace and Playwright files can be used as inputs for:
+- Integration test generation (using trace files)
+- Load test generation (using trace files)  
+- E2E test generation (using both trace and Playwright files)
+- UI test generation (using Playwright files)
+
+For detailed documentation visit: https://www.skyramp.dev/docs/load-test/advanced-generation#end-trace-collection`,
         inputSchema: {
             traceOutputFile: z
                 .string()

package/build/types/TestTypes.js

@@ -2,11 +2,10 @@ import { z } from "zod";
 export const baseSchema = z.object({
     language: z
         .string()
-        .optional()
         .describe("Programming language for the generated test (default: python)"),
     framework: z
         .string()
-        .optional()
+        .default("")
         .describe("Testing framework to use (e.g., pytest for python, playwright for javascript, junit for java, etc.)"),
     output: z.string().optional().describe("Name of the output test file"),
     outputDir: z
@@ -17,36 +16,36 @@ export const baseSchema = z.object({
         .describe("Whether to overwrite existing files in the output directory"),
     deployDashboard: z
         .boolean()
-        .optional()
+        .default(false)
         .describe("Whether to deploy the Skyramp dashboard for test monitoring"),
     runtime: z
         .string()
-        .optional()
-        .describe("Runtime environment (docker, kubernetes, etc.)"),
+        .default("local")
+        .describe("Runtime environment (docker, kubernetes, local)"),
     dockerNetwork: z
         .string()
-        .optional()
+        .default("")
         .describe("Docker network name to use for containerized testing"),
     dockerWorkerPort: z
         .number()
-        .optional()
+        .default(0)
         .describe("Port number for the Docker worker service"),
     k8sNamespace: z
         .string()
-        .optional()
+        .default("")
         .describe("Kubernetes namespace for deployment"),
     k8sConfig: z
         .string()
-        .optional()
+        .default("")
         .describe("Path to Kubernetes configuration file"),
-    k8sContext: z.string().optional().describe("Kubernetes context to use"),
+    k8sContext: z.string().default("").describe("Kubernetes context to use"),
     authHeader: z
         .string()
-        .optional()
+        .default("")
         .describe("Authorization header value for authenticated requests"),
     insecure: z
         .boolean()
-        .optional()
+        .default(false)
         .describe("Whether to allow insecure SSL connections for HTTPS endpoints"),
 });
 export const baseTraceSchema = z.object({
@@ -56,46 +55,45 @@ export const baseTraceSchema = z.object({
         .describe("MUST be absolute path to trace file for test generation like /path/to/trace.json and MUST be a json file"),
     include: z
         .array(z.string())
-        .optional()
-        .describe("List of endpoints or patterns to include in test generation"),
+        .default([])
+        .describe("List of endpoints or patterns to include in test generation. DO NOT ASSUME ANYTHING IF NOT PROVIDED"),
     exclude: z
         .array(z.string())
-        .optional()
-        .describe("List of endpoints or patterns to exclude from test generation"),
+        .default([])
+        .describe("List of endpoints or patterns to exclude from test generation. DO NOT ASSUME ANYTHING IF NOT PROVIDED"),
 });
 // Base schema that all test tools share
 export const baseTestSchema = {
     ...baseSchema.shape,
     endpointURL: z
         .string()
-        .optional()
         .describe("The endpoint URL to test (e.g., https://api.example.com/v1/products)"),
     method: z
         .string()
-        .optional()
-        .describe("HTTP method to use (GET, POST, PUT, DELETE, etc.). DO NOT ASSUME METHOD IF NOT PROVIDED AND TRY TO DETECT THE METHOD FROM OPENAPI SCHEMA"),
+        .default("")
+        .describe("HTTP method to use (GET, POST, PUT, DELETE, etc.). DO NOT ASSUME VALUE IF NOT PROVIDED"),
     apiSchema: z
         .string()
-        .optional()
-        .describe("MUST be absolute path to the OpenAPI/Swagger schema file"),
+        .default("")
+        .describe("MUST be absolute path(/path/to/openapi.json) to the OpenAPI/Swagger schema file or a URL to the OpenAPI/Swagger schema file(e.g. https://demoshop.skyramp.dev/openapi.json). DO NOT TRY TO ASSUME THE OPENAPI SCHEMA IF NOT PROVIDED"),
     pathParams: z
         .string()
-        .optional()
+        .default("")
         .describe("MUST be string of comma separated values like 'id=1,name=John' for URL path parameters"),
     queryParams: z
         .string()
-        .optional()
+        .default("")
         .describe("MUST be string of comma separated values like 'id=1,name=John' for URL query parameters"),
     formParams: z
         .string()
-        .optional()
+        .default("")
         .describe("MUST be string of comma separated values like 'id=1,name=John' for form data parameters"),
     requestData: z
         .string()
-        .optional()
+        .default("")
         .describe("Sample request body data, provided either as an inline JSON/YAML string or as an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
     responseStatusCode: z
         .string()
-        .optional()
-        .describe("Expected HTTP response status code (e.g., '200', '201', '404'). DO NOT ASSUME STATUS CODE IF NOT PROVIDED AND TRY TO DETECT THE STATUS CODE FROM OPENAPI SCHEMA"),
+        .default("")
+        .describe("Expected HTTP response status code (e.g., '200', '201', '404'). DO NOT ASSUME STATUS CODE IF NOT PROVIDED"),
 };

package/build/utils/language-helper.js

@@ -0,0 +1,69 @@
+export function getLanguageSteps(params) {
+    const { language, testType } = params;
+    switch (language) {
+        case "python":
+            let pythonSteps = `
+# Install skyramp dependency
+pip3 install skyramp
+      `;
+            // e2e and ui tests
+            if (testType === "e2e" || testType === "ui") {
+                pythonSteps += `
+# Install playwright dependencies
+pip3 install pytest-playwright
+# Execute the test file
+python3 -m pytest --browser chromium <test-file>.py
+        `;
+            }
+            // framework pytest
+            pythonSteps += `
+# Install pytest dependency
+pip3 install pytest
+
+# Execution test file
+python3 -m pytest <test-file>.py
+      `;
+            // robot framework
+            pythonSteps += `
+# Install robotframework dependency
+pip3 install robotframework
+
+# Execution of test file
+python3 -m robot <robot-file>.robot
+      `;
+            return pythonSteps;
+        case "javascript":
+            return `
+# install dependencies for package.json
+npm install @skyramp/skyramp @playwright/test
+
+# Execution of test file
+npx playwright test <test-file>.spec.js --reporter=list
+      `;
+        case "typescript":
+            return `
+# install dependencies for package.json
+npm install @skyramp/skyramp @playwright/test
+
+# Execution of test file
+npx playwright test <test-file>.spec.ts --reporter=list
+      `;
+        case "java":
+            return `
+# Prerequisites
+# Compile the test file
+javac -cp "./lib/*" -d target <test-file>.java
+
+# Execution of test file
+JUNIT_PLATFORM_VER="1.9.3"
+classpath="target:$(echo ./lib/*.jar | tr ' ' ':')"
+java -jar "./lib/junit-platform-console-standalone-\${JUNIT_PLATFORM_VER}.jar" \\
+  --classpath "\$classpath" \\
+  --include-engine=junit-jupiter \\
+  --select-class=<test-file> \\
+  --reports-dir=target/test-results
+      `;
+        default:
+            return "";
+    }
+}

package/build/utils/modularization-prompts.js

@@ -0,0 +1,15 @@
+export function getModularizationPrompt() {
+    return `
+**IMPORTANT: Now please modularize the code by**
+
+1. Group related lines logically (e.g., login steps together) to improve readability and parameterize the test function(s) with meaningful parameters to make it more flexible.
+2. Parameterize the test function(s) with meaningful parameters to make it more flexible. Preserve the original order of code lines within each function
+3. Do not change or remove any existing lines of code, variable names, function names, or function structures.
+4. Only extract reusable logical sections into helper functions or parameterized structures where applicable.
+5. Do not create any new test cases but only helper functions.
+6. Make sure the logic is same and the test works as expected.
+7. Do not add any new logic or classes or any other files.
+
+Please refactor the code with these modularization principles. Respond with the complete, modularized code only.
+  `;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "main": "build/index.js",
   "type": "module",
   "bin": {