Patched code sample

def process_mcp_request(request_data):
    """
    Processes an MCP request, handling potential validation errors.
    """
    try:
        # Simulate the parsing and validation logic that might raise exceptions.
        # In a real-world scenario, this would involve deserializing the 
        # request_data according to the MCP specification and validating
        # its contents.  We simulate that with a few checks here.

        if not isinstance(request_data, dict):
            raise ValueError("Request data must be a dictionary.")

        if "model_name" not in request_data:
            raise ValueError("Request must contain 'model_name'.")

        if not isinstance(request_data["model_name"], str):
            raise ValueError("Model name must be a string.")

        # Simulate a vulnerable validation condition. This could be
        # any specific check that throws an exception in the original
        # vulnerable code.  For example, an invalid numerical value.
        if "param1" in request_data:
            try:
                param1_value = float(request_data["param1"])
                if param1_value < 0:
                    raise ValueError("Param1 must be non-negative.") # Example validation
            except (ValueError, TypeError) as e:
                 raise ValueError(f"Invalid value for param1: {e}")

        # If we get here, validation passed (at least our simulated version)
        print("Request validated successfully.")

        # Simulate actual request processing (e.g., interaction with the model)
        print(f"Processing request for model: {request_data['model_name']}")
        # Add actual business logic here
        return {"status": "success", "message": "Request processed"}

    except ValueError as e:
        # Catch specific validation errors and return a graceful error response
        print(f"Validation error: {e}")
        return {"status": "error", "message": str(e)}
    except Exception as e:  # Catch unexpected errors to prevent crashes.
        print(f"Unexpected error: {e}") # log unexpected errors.
        return {"status": "error", "message": "Internal server error"}


if __name__ == '__main__':
    # Example usage with valid and invalid requests:

    valid_request = {"model_name": "my_model", "param1": "1.5"}
    invalid_request_1 = "not a dictionary"
    invalid_request_2 = {"param1": "-1"}
    invalid_request_3 = {"model_name": 123}
    invalid_request_4 = {"model_name": "another_model", "param1": "abc"}
    

    print("Processing valid request:")
    print(process_mcp_request(valid_request))

    print("\nProcessing invalid request (not a dictionary):")
    print(process_mcp_request(invalid_request_1))

    print("\nProcessing invalid request (negative param1):")
    print(process_mcp_request(invalid_request_2))

    print("\nProcessing invalid request (invalid model_name type):")
    print(process_mcp_request(invalid_request_3))

    print("\nProcessing invalid request (invalid param1 type):")
    print(process_mcp_request(invalid_request_4))