@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

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

@@ -0,0 +1,545 @@
+import { z } from "zod";
+import { SkyrampClient } from "@skyramp/skyramp";
+import { MockProtocol, RuntimeEnvironment, runtimeEnvironmentInputSchema } from "../../types/TestTypes.js";
+export { MockProtocol } from "../../types/TestTypes.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
+import { logger } from "../../utils/logger.js";
+import { getEntryPoint } from "../../utils/telemetry.js";
+import fs from "fs";
+import { getRestMockMethodValidationError, normalizeRestMockMethod, } from "../../utils/httpMethodValidation.js";
+import { getGrpcMockResponseValidationError } from "../../utils/grpcMockValidation.js";
+import { validateMockCompatibility } from "../../utils/mockCompatibility.js";
+import { buildTrafficConfigOptions, validateTrafficConfig, } from "./generateMockRestTool.js";
+export const BATCH_MOCK_PROTOCOL_EXAMPLES = `
+<example protocol="rest">
+Batch REST item. Required fields: protocol="rest", endpointURL, method unless apiSchema is provided.
+{
+  "protocol": "rest",
+  "endpointURL": "http://identity-service:4000/api/internal/v1/users/validate",
+  "method": "POST",
+  "requestAware": true,
+  "responseData": "{\"valid\":true}"
+}
+</example>
+
+<example protocol="rest-traffic-simulation">
+Batch REST item with traffic simulation. minLatency/maxLatency inject a random delay per response; dropRate drops a percentage of requests.
+{
+  "protocol": "rest",
+  "endpointURL": "http://payment-service:5001/payments",
+  "method": "POST",
+  "responseData": "{\"status\":\"ok\"}",
+  "minLatency": 500,
+  "maxLatency": 1000,
+  "dropRate": 10
+}
+</example>
+
+<example protocol="rest-conditional">
+Batch REST item with conditional response selection. Use "when" to match request fields.
+{
+  "protocol": "rest",
+  "endpointURL": "http://payment-service:5001/api/v1/orders",
+  "method": "POST",
+  "when": {"request.body.payment.method": "card"},
+  "requestSchema": "{\"type\":\"object\",\"required\":[\"orderId\",\"payment\"]}",
+  "responseData": "{\"status\":\"confirmed\"}",
+  "responseStatusCode": "201",
+  "noMatchStatusCode": 404,
+  "validationFailureStatusCode": 422
+}
+</example>
+
+<example protocol="grpc">
+Batch gRPC item. Required fields: protocol="grpc", endpointURL as host:port, protoPath, grpcServiceName. method is the RPC name; empty means all service methods.
+{
+  "protocol": "grpc",
+  "endpointURL": "profile-service:50051",
+  "protoPath": "/repo/proto/profiles.proto",
+  "grpcServiceName": "ProfileService",
+  "method": "GetProfile",
+  "responseData": "{\"id\":\"profile_123\"}"
+}
+</example>
+
+<example protocol="grpc-traffic-simulation">
+Batch gRPC item with traffic simulation. Same latency/drop fields as REST.
+{
+  "protocol": "grpc",
+  "endpointURL": "profile-service:50051",
+  "protoPath": "/repo/proto/profiles.proto",
+  "grpcServiceName": "ProfileService",
+  "method": "GetProfile",
+  "responseData": "{\"eligible\":true}",
+  "minLatency": 200,
+  "maxLatency": 800,
+  "dropRate": 5
+}
+</example>
+
+<example protocol="grpc-status-error">
+Batch gRPC status error item. Do not provide responseData with grpcStatusCode.
+{
+  "protocol": "grpc",
+  "endpointURL": "profile-service:50051",
+  "protoPath": "/repo/proto/profiles.proto",
+  "grpcServiceName": "ProfileService",
+  "method": "GetProfile",
+  "grpcStatusCode": 5,
+  "grpcStatusMessage": "profile not found"
+}
+</example>
+
+<example protocol="kafka-producer">
+Batch 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.
+{
+  "protocol": "kafka",
+  "endpointURL": "broker:9092",
+  "kafkaTopic": "orders",
+  "requestData": "{\"order_id\":\"ord_123\"}"
+}
+</example>
+
+<example protocol="kafka-consumer">
+Batch 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.
+{
+  "protocol": "kafka",
+  "endpointURL": "broker:9092",
+  "kafkaTopic": "orders",
+  "responseData": "{\"accepted\":true}"
+}
+</example>`;
+const mockSpecSchema = z.object({
+    protocol: z
+        .nativeEnum(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
+        .string()
+        .describe("For REST: the base URL or endpoint URL. " +
+        "For gRPC: the target service address as host:port. " +
+        "For Kafka: the broker address as host:port."),
+    method: z
+        .string()
+        .default("")
+        .describe("For REST: HTTP method, required unless apiSchema is provided. For gRPC: RPC method name, empty generates all service methods. For Kafka: MUST be empty; use kafkaTopic."),
+    responseData: z
+        .string()
+        .optional()
+        .describe("REST/gRPC response body data; Kafka consumer messages. Inline JSON/YAML or @/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",
+    })
+        .describe("HTTP status code the mock should return (e.g., '200', '201')."),
+    grpcStatusCode: z
+        .number()
+        .int()
+        .min(1)
+        .max(16)
+        .optional()
+        .describe("For protocol='grpc' error mocks only. Non-OK gRPC status code number. Do not combine with responseData."),
+    grpcStatusMessage: z
+        .string()
+        .optional()
+        .describe("For protocol='grpc' error mocks only. gRPC status message to return with grpcStatusCode."),
+    requestData: z
+        .string()
+        .default("")
+        .describe("REST request body sample for request-aware mocks; Kafka producer validation payload/schema."),
+    requestAware: z
+        .boolean()
+        .default(false)
+        .describe("When true, generates a dynamic mock that varies by request."),
+    apiSchema: z
+        .string()
+        .default("")
+        .describe("Path or URL to OpenAPI/Swagger schema file."),
+    protoPath: z
+        .string()
+        .optional()
+        .describe("Required for protocol='grpc'. Path to the .proto file."),
+    grpcServiceName: z
+        .string()
+        .optional()
+        .describe("Required for protocol='grpc'. gRPC service name."),
+    protobufExtraFiles: z
+        .array(z.string())
+        .optional()
+        .describe("Optional extra .proto files for gRPC compilation."),
+    protobufExtraImportPath: z
+        .array(z.string())
+        .optional()
+        .describe("Optional extra import directories for protobuf compilation."),
+    kafkaTopic: z
+        .string()
+        .optional()
+        .describe("Required for protocol='kafka'. Kafka topic name."),
+    minLatency: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Minimum injected response delay in milliseconds for traffic simulation (REST and gRPC only)."),
+    maxLatency: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Maximum injected response delay in milliseconds for traffic simulation (REST and gRPC only)."),
+    dropRate: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .optional()
+        .describe("Percentage [0-100] of requests dropped/errored for traffic simulation (REST and gRPC only)."),
+    when: z
+        .record(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.); " +
+        "values are a bare value (equality) or an operator object ({eq,ne,gt,gte,lt,lte,in,contains,regex,exists}). " +
+        'Example: {"request.body.payment.method": "card"}'),
+    requestSchema: z
+        .string()
+        .optional()
+        .describe("Explicit JSON Schema (string) to validate the request body. REST and gRPC only."),
+    noMatchStatusCode: z
+        .number()
+        .int()
+        .min(100)
+        .max(599)
+        .optional()
+        .describe("HTTP status code when no `when` branch matches (default 404). REST and gRPC only."),
+    validationFailureStatusCode: z
+        .number()
+        .int()
+        .min(100)
+        .max(599)
+        .optional()
+        .describe("HTTP status code when request validation fails (default 400). REST and gRPC only."),
+    output: z
+        .string()
+        .optional()
+        .describe("Optional output file name for this mock. Use when multiple mocks share the same endpoint and method so generated files do not overwrite each other."),
+    outputDir: z
+        .string()
+        .optional()
+        .describe("Optional output directory for this mock. Defaults to the batch-level outputDir."),
+});
+function validateMockSpec(spec) {
+    const protocol = spec.protocol ?? MockProtocol.Rest;
+    if (protocol === MockProtocol.Rest) {
+        const methodError = getRestMockMethodValidationError(spec.method);
+        if (methodError)
+            return methodError;
+        if (!spec.apiSchema && !spec.method) {
+            return "REST mock method is required unless apiSchema is provided for schema-wide generation";
+        }
+    }
+    if (protocol === MockProtocol.Grpc) {
+        const missing = [];
+        if (!spec.protoPath)
+            missing.push("protoPath");
+        if (!spec.grpcServiceName)
+            missing.push("grpcServiceName");
+        if (missing.length > 0) {
+            return `gRPC mock requires: ${missing.join(", ")}`;
+        }
+        if (spec.grpcStatusCode !== undefined && spec.responseData?.trim()) {
+            return "gRPC status error mocks must use grpcStatusCode/grpcStatusMessage instead of responseData";
+        }
+        if (spec.grpcStatusMessage && spec.grpcStatusCode === undefined) {
+            return "grpcStatusMessage requires grpcStatusCode";
+        }
+        const grpcResponseError = getGrpcMockResponseValidationError(spec.responseData);
+        if (grpcResponseError)
+            return grpcResponseError;
+    }
+    if (protocol === MockProtocol.Kafka) {
+        if (!spec.kafkaTopic)
+            return "Kafka mock requires: kafkaTopic";
+        if (spec.method) {
+            return "Kafka mock method must be empty; use kafkaTopic for the topic name. Produce validation uses requestData and consumer messages use responseData";
+        }
+        const hasRequestData = Boolean(spec.requestData && spec.requestData.trim());
+        const hasResponseData = Boolean(spec.responseData && spec.responseData.trim());
+        if (hasRequestData === hasResponseData) {
+            return "Kafka mock requires exactly one of requestData (producer validation) or responseData (consumer messages)";
+        }
+        if (spec.minLatency !== undefined ||
+            spec.maxLatency !== undefined ||
+            spec.dropRate !== undefined) {
+            return "traffic config (minLatency/maxLatency/dropRate) is not applicable for Kafka mocks";
+        }
+        if (spec.when !== undefined ||
+            spec.requestSchema !== undefined ||
+            spec.noMatchStatusCode !== undefined ||
+            spec.validationFailureStatusCode !== undefined) {
+            return "conditional response fields (when/requestSchema/noMatchStatusCode/validationFailureStatusCode) are not applicable for Kafka mocks";
+        }
+    }
+    const trafficError = validateTrafficConfig(spec);
+    if (trafficError)
+        return trafficError;
+    return null;
+}
+function buildGenerateOptions(spec, shared) {
+    const protocol = spec.protocol ?? MockProtocol.Rest;
+    const language = shared.language ?? "python";
+    const framework = shared.framework ??
+        (language === "typescript" || language === "javascript"
+            ? "playwright"
+            : "");
+    const outputDir = spec.outputDir ?? shared.outputDir;
+    const common = {
+        protocol,
+        language,
+        framework,
+        outputDir,
+        output: spec.output,
+        force: true,
+        overwrite: true,
+        runtime: shared.runtime,
+        dockerNetwork: shared.dockerNetwork,
+        entrypoint: getEntryPoint(),
+    };
+    const responseDataOption = spec.responseData !== undefined &&
+        !(protocol === MockProtocol.Grpc && spec.grpcStatusCode !== undefined)
+        ? { responseData: spec.responseData }
+        : {};
+    const trafficConfig = buildTrafficConfigOptions(spec);
+    if (protocol === MockProtocol.Grpc) {
+        return {
+            ...common,
+            ...responseDataOption,
+            ...trafficConfig,
+            method: spec.method ?? "",
+            url: spec.endpointURL,
+            protoPath: spec.protoPath,
+            service: spec.grpcServiceName,
+            grpcStatusCode: spec.grpcStatusCode,
+            grpcStatusMessage: spec.grpcStatusMessage,
+            extraFiles: spec.protobufExtraFiles ?? [],
+            extraImports: spec.protobufExtraImportPath ?? [],
+            when: spec.when,
+            requestSchema: spec.requestSchema,
+            noMatchStatusCode: spec.noMatchStatusCode,
+            validationFailureStatusCode: spec.validationFailureStatusCode,
+        };
+    }
+    if (protocol === MockProtocol.Kafka) {
+        return {
+            ...common,
+            ...responseDataOption,
+            url: spec.endpointURL,
+            topic: spec.kafkaTopic,
+            requestData: spec.requestData?.trim() ? spec.requestData : undefined,
+        };
+    }
+    // REST
+    return {
+        ...common,
+        ...responseDataOption,
+        ...trafficConfig,
+        method: normalizeRestMockMethod(spec.method),
+        uri: spec.endpointURL,
+        apiSchema: spec.apiSchema ? [spec.apiSchema] : [],
+        requestData: spec.requestData ?? "",
+        responseStatusCode: spec.responseStatusCode ?? "",
+        requestAware: spec.requestAware ?? false,
+        mockPort: 0,
+        optionalFields: false,
+        when: spec.when,
+        requestSchema: spec.requestSchema,
+        noMatchStatusCode: spec.noMatchStatusCode ?? 0,
+        validationFailureStatusCode: spec.validationFailureStatusCode ?? 0,
+    };
+}
+export async function executeBatchMockGeneration(params) {
+    const { mocks, outputDir } = params;
+    fs.mkdirSync(outputDir, { recursive: true });
+    const client = new SkyrampClient();
+    const results = [];
+    for (let i = 0; i < mocks.length; i++) {
+        const spec = mocks[i];
+        const protocol = spec.protocol ?? MockProtocol.Rest;
+        const method = spec.method ?? "";
+        // Validate spec
+        const validationError = validateMockSpec(spec);
+        if (validationError) {
+            results.push({
+                index: i,
+                protocol,
+                endpointURL: spec.endpointURL,
+                method,
+                topic: spec.kafkaTopic,
+                success: false,
+                error: validationError,
+            });
+            continue;
+        }
+        const dockerLocalDev = params.runtime === "docker" || Boolean(params.dockerNetwork?.trim());
+        const compatibility = validateMockCompatibility([{ ...spec, protocol }], {
+            dockerLocalDev,
+        });
+        const blockingWarnings = compatibility.warnings.filter((warning) => warning.blocking);
+        if (blockingWarnings.length > 0) {
+            results.push({
+                index: i,
+                protocol,
+                endpointURL: spec.endpointURL,
+                method,
+                topic: spec.kafkaTopic,
+                success: false,
+                error: blockingWarnings
+                    .map((warning) => `${warning.code}: ${warning.message} Suggestion: ${warning.suggestion}`)
+                    .join("\n"),
+            });
+            continue;
+        }
+        const resolvedOutputDir = spec.outputDir ?? outputDir;
+        fs.mkdirSync(resolvedOutputDir, { recursive: true });
+        // Build options and generate
+        const options = buildGenerateOptions(spec, {
+            outputDir,
+            runtime: params.runtime,
+            dockerNetwork: params.dockerNetwork,
+            language: params.language,
+            framework: params.framework,
+        });
+        try {
+            let result;
+            if (protocol === MockProtocol.Grpc) {
+                result = await client.generateGrpcMock(options);
+            }
+            else if (protocol === MockProtocol.Kafka) {
+                result = await client.generateKafkaMock(options);
+            }
+            else {
+                result = await client.generateRestMock(options);
+            }
+            if (!result || !result.toLowerCase().includes("success")) {
+                results.push({
+                    index: i,
+                    protocol,
+                    endpointURL: spec.endpointURL,
+                    method,
+                    topic: spec.kafkaTopic,
+                    success: false,
+                    error: `Mock generation failed: ${result || "no output from backend"}`,
+                });
+                continue;
+            }
+            results.push({
+                index: i,
+                protocol,
+                endpointURL: spec.endpointURL,
+                method,
+                topic: spec.kafkaTopic,
+                success: true,
+                outputDir: resolvedOutputDir,
+                output: spec.output,
+                detail: result,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error("Batch mock generation failed for spec", {
+                index: i,
+                protocol,
+                endpointURL: spec.endpointURL,
+                error: errorMessage,
+            });
+            results.push({
+                index: i,
+                protocol,
+                endpointURL: spec.endpointURL,
+                method,
+                topic: spec.kafkaTopic,
+                success: false,
+                error: errorMessage,
+            });
+        }
+    }
+    const succeeded = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    const summaryLines = [
+        `## Batch Mock Generation Summary`,
+        ``,
+        `- **Total:** ${mocks.length}`,
+        `- **Succeeded:** ${succeeded.length}`,
+        `- **Failed:** ${failed.length}`,
+        `- **Default Output Directory:** ${outputDir}`,
+        ``,
+    ];
+    if (succeeded.length > 0) {
+        summaryLines.push(`### Successful Mocks`);
+        for (const r of succeeded) {
+            summaryLines.push(`- [${r.index}] ${r.protocol.toUpperCase()} ${r.endpointURL} ${r.method || (r.protocol === MockProtocol.Kafka ? `topic:${r.topic ?? "?"}` : "(all methods)")}${r.output ? ` -> ${r.outputDir ?? outputDir}/${r.output}` : ""}`);
+        }
+        summaryLines.push(``);
+    }
+    if (failed.length > 0) {
+        summaryLines.push(`### Failed Mocks`);
+        for (const r of failed) {
+            summaryLines.push(`- [${r.index}] ${r.protocol.toUpperCase()} ${r.endpointURL} ${r.method || (r.protocol === MockProtocol.Kafka ? `topic:${r.topic ?? "?"}` : "(all methods)")}: ${r.error}`);
+        }
+        summaryLines.push(``);
+    }
+    return {
+        content: [{ type: "text", text: summaryLines.join("\n") }],
+        isError: failed.length > 0,
+    };
+}
+const TOOL_NAME = "skyramp_batch_mock_generation";
+const batchMockSchema = {
+    mocks: z
+        .array(mockSpecSchema)
+        .min(1)
+        .describe("Array of mock specifications. Each element describes one mock to generate."),
+    outputDir: z
+        .string()
+        .describe("Directory where generated mock files will be written."),
+    runtime: runtimeEnvironmentInputSchema
+        .default(RuntimeEnvironment.LOCAL)
+        .describe("Runtime environment: 'local', 'docker', or 'k8s' (also accepts 'kubernetes')."),
+    dockerNetwork: z
+        .string()
+        .default("")
+        .describe("Docker network name for containerized testing."),
+    language: z
+        .string()
+        .default("python")
+        .describe("Programming language for generated mocks (python, typescript, javascript, java)."),
+    framework: z
+        .string()
+        .default("")
+        .describe("Testing framework (e.g., pytest, playwright)."),
+};
+export function registerBatchMockTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: `Generate multiple mock server implementations in a single call using Skyramp.
+
+This tool accepts an array of mock specifications and generates all mocks in one operation,
+avoiding the need for N separate tool calls when mocking multiple downstream services.
+
+Each mock spec can target REST, gRPC, or Kafka protocols. Partial failures are handled
+gracefully — if some mocks fail, the others still succeed and are reported.
+
+Use this tool when you need to mock 2+ downstream services simultaneously (e.g., for a
+local-dev workflow with multiple dependencies).
+
+${BATCH_MOCK_PROTOCOL_EXAMPLES}`,
+        inputSchema: batchMockSchema,
+    }, async (params) => {
+        const result = await executeBatchMockGeneration(params);
+        AnalyticsService.pushTestGenerationToolEvent(TOOL_NAME, result, params).catch(() => {
+            // Silently ignore analytics errors
+        });
+        return result;
+    });
+}

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

@@ -5,7 +5,7 @@ import { ScenarioGenerationService } from "../../services/ScenarioGenerationServ
 import fs from "fs";
 import { baseSchema, AUTH_PLACEHOLDER_TOKEN, HttpMethod } from "../../types/TestTypes.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { getWorkspaceAuthConfig, WorkspaceAuthType, getDefaultAuthHeader, isAuthorizationHeaderName, getAuthScheme } from "../../utils/workspaceAuth.js";
+import { resolveAuthFromWorkspace, getWorkspaceDefaultQueryParams, mergeQueryParamsJson } from "../../utils/workspaceAuth.js";
 import yaml from "js-yaml";
 import { logger } from "../../utils/logger.js";
 import { guardScenarioApproved } from "./planGuard.js";
@@ -81,7 +81,9 @@ If you provide nested objects, the service JSON-stringifies them as a fallback,
 
 Use this for GET request filters, search terms, pagination, sorting — any parameter that belongs in the URL query string.
 
-CRITICAL: For search/filter/list endpoints (e.g., GET /products/search?q=bear&limit=10), parameters MUST go here, NOT in requestBody. GET request bodies are non-standard and may be ignored or rejected by servers and frameworks.`),
+CRITICAL: For search/filter/list endpoints (e.g., GET /products/search?q=bear&limit=10), parameters MUST go here, NOT in requestBody. GET request bodies are non-standard and may be ignored or rejected by servers and frameworks.
+
+Workspace-configured api.defaultQueryParams (if set) are merged into every step automatically — no need to repeat them here. An explicit value for the same key in a step overrides the workspace default for that step only.`),
     responseBody: z
         .string()
         .optional()
@@ -239,26 +241,11 @@ Call \`skyramp_integration_test_generation\` with the returned \`scenarioFile\`
         if (params.authHeader === undefined) {
             try {
                 const repoPath = params.outputDir || process.cwd();
-                const wsAuth = await getWorkspaceAuthConfig(repoPath);
-                // Resolve the auth header: prefer explicit authHeader, fall back to inferred default.
-                let resolvedHeader = wsAuth.authHeader ?? getDefaultAuthHeader(wsAuth.authType);
-                // authScheme is set but getDefaultAuthHeader returned "" (e.g. unrecognized authType or
-                // custom scheme like "Ghost"/"Hawk"). authScheme only applies to Authorization headers.
-                if (!resolvedHeader && wsAuth.authScheme !== undefined) {
-                    resolvedHeader = "Authorization";
-                }
-                if (resolvedHeader && wsAuth.authType !== WorkspaceAuthType.None) {
-                    logger.info("Auth header was empty — resolved from workspace config", {
-                        authHeader: resolvedHeader,
-                        authType: wsAuth.authType,
-                    });
-                    params.authHeader = resolvedHeader;
-                    // Scheme only applies to Authorization headers; use header name (not authType) to detect.
-                    if (isAuthorizationHeaderName(resolvedHeader)) {
-                        // Prefer explicit authScheme from workspace (for custom schemes like "Ghost", "Hawk").
-                        // Fall back to getAuthScheme() for standard types (bearer→Bearer, token→Token).
-                        // Use ?? to preserve intentionally empty authScheme ("" = raw token, no prefix).
-                        params.authScheme = params.authScheme ?? wsAuth.authScheme ?? getAuthScheme(wsAuth.authType);
+                const resolved = await resolveAuthFromWorkspace(repoPath, params.authHeader, params.authScheme);
+                if (resolved) {
+                    params.authHeader = resolved.authHeader;
+                    if (resolved.authScheme !== undefined) {
+                        params.authScheme = resolved.authScheme;
                     }
                 }
             }
@@ -266,6 +253,19 @@ Call \`skyramp_integration_test_generation\` with the returned \`scenarioFile\`
                 logger.warning("Could not resolve auth from workspace config");
             }
         }
+        let defaultQueryParams;
+        try {
+            const repoPath = params.outputDir || process.cwd();
+            defaultQueryParams = await getWorkspaceDefaultQueryParams(repoPath);
+            if (defaultQueryParams) {
+                logger.info("Merged workspace defaultQueryParams into queryParams", {
+                    keys: Object.keys(defaultQueryParams),
+                });
+            }
+        }
+        catch {
+            logger.warning("Could not resolve default query params from workspace config");
+        }
         // Separate try/catch so auth errors don't silently swallow schema population.
         // Walk up from outputDir with a sync existsSync check — one stat per level,
         // one read+parse only when found — instead of an async readWorkspaceConfigRaw
@@ -410,7 +410,9 @@ Call \`skyramp_integration_test_generation\` with the returned \`scenarioFile\`
                 method: step.method,
                 path: step.path,
                 requestBody: step.requestBody,
-                queryParams: step.queryParams,
+                queryParams: defaultQueryParams
+                    ? mergeQueryParamsJson(step.queryParams, defaultQueryParams)
+                    : step.queryParams,
                 responseBody: step.responseBody,
                 statusCode: step.statusCode,
                 responseHeaders: step.responseHeaders,

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

@@ -367,8 +367,8 @@ const TOOL_NAME = TOOL_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/generateE2ERestTool.d.ts

@@ -8,6 +8,6 @@ export declare class E2ETestService extends TestGenerationService {
         responseData?: string;
         playwrightInput?: string;
     }): any;
-    protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+    protected handleApiAnalysis(_params: BaseTestParams): Promise<CallToolResult | null>;
 }
 export declare function registerE2ETestTool(server: McpServer): void;

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

@@ -21,7 +21,7 @@ export class E2ETestService extends TestGenerationService {
             playwrightInput: params.playwrightInput,
         };
     }
-    async handleApiAnalysis(params) {
+    async handleApiAnalysis(_params) {
         return null;
     }
 }

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

@@ -13,6 +13,6 @@ export declare class LoadTestService extends TestGenerationService {
         loadRampupInterval?: string;
         loadTargetRPS?: string;
     }): any;
-    protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+    protected handleApiAnalysis(_params: BaseTestParams): Promise<CallToolResult | null>;
 }
 export declare function registerLoadTestTool(server: McpServer): void;

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

@@ -19,7 +19,7 @@ export class LoadTestService extends TestGenerationService {
             loadTargetRPS: params.loadTargetRPS,
         };
     }
-    async handleApiAnalysis(params) {
+    async handleApiAnalysis(_params) {
         return null;
     }
 }